Penny

Quality 78 / 100good

7 tools, about 8,945 tokens to load them all · tool set 3940d5c46d5b · tools last changed 2026-10-20 · checked 2026-10-21 00:32 UTC

Tool changes

• 2026-10-20penny_readchangedinput schema
• 2026-10-15penny_deletechangedinput schema
• 2026-10-15penny_editchangeddescription, input schema
  before

  When the user corrects something on file, or a task, tracker, skill, or block needs to change, edit the existing item rather than writing a duplicate. Modify something that already exists in the user's memory, chosen by `entityType` — same taxonomy as `penny_write` (see its ladder). Notes take `updates[]` (patch or replace, up to 100); tasks require `taskId` (set `status: "canceled"` to remove a task — tasks are never trashed); profile blocks are upserts (`blockName` + `content`; `memory_policy` and `persona` are the two standing-instruction blocks — see penny_write's ladder). When the user tells you what to save, skip, check, or surface, update their memory_policy block in the same turn as a general rule in their words. Skill redefinition prepares a preview, not a save. Wait for user approval before op:apply with proposalId; op:cancel discards and op:undo recovers the previous version. Read skills view:history for version IDs; op:restore_revision with skillId, historyId, expectedUpdatedAt previews a restore. op:restore with skillId recovers a deleted skill, disabled. No invocation waiting period applies. Trackers take `trackerId` and patch only the fields you pass (`name`/`description`/`unit`/`kind`/`targetSpec`/`archived` — archiving is the retire path, there is no tracker delete; private trackers only, not yet workspace-shared ones); rhythms are re-defined by full manifest; `entityType: "rhythm_run"` completes a run (`runId` + `status`). Projects take `projectId` + `expectedRevision` + `operationId` + a sparse `patch` (reread and reconcile on conflict); `op: "restore_revision"` restores selected `fields`/`resourceIds` from a `historyId` as a new revision. Tracker entries take `trackerId` + `entryId` + `expectedUpdatedAt` + the full `payload`. `op: "restore"` un-trashes notes or tracker entries by `ids`, or a Project by `projectId`.

  after · 75% of words in common

  When the user corrects something on file, or a task, tracker, skill, or block needs to change, edit the existing item rather than writing a duplicate. Modify what already exists; entityType uses the same taxonomy as penny_write (see ladder). Notes: updates[] patch/replace, max100. Tasks: taskId; cancel via status:canceled, never Trash. Profile: blockName + content upsert; memory_policy and persona hold standing instructions. When the user tells you what to save, skip, check, or surface, update their memory_policy block in the same turn as a general rule in their words. Skill redefinition prepares a preview, not a save; wait for user approval before op:apply with proposalId. cancel discards; undo recovers the prior version if no later edit exists. skills/history supplies historyId; restore_revision with skillId/historyId/expectedUpdatedAt previews recovery. restore with skillId recovers deleted skills disabled. No invocation waiting period. Trackers: trackerId + sparse name/description/unit/kind/targetSpec/archived; retire by archiving, no delete. Private trackers only; workspace trackers unsupported. Rhythms: full manifest. skill_run/rhythm_run: complete runId + status. Projects: projectId + expectedRevision + operationId + sparse patch; reread and reconcile on conflict. restore_revision restores fields/resourceIds from historyId as a new revision. Tracker entries: trackerId + entryId + expectedUpdatedAt + full payload. restore un-trashes note/tracker_entry ids or Project projectId.

• 2026-10-15penny_writechangeddescription, input schema
  before

  Save the moment something durable emerges — a decision, preference, plan, correction, a to-do, a measurement, or something you produced — mid-conversation and unprompted; when the call is close, save. Write something new to the user's memory. Choosing `entityType` — walk this ladder top to bottom, first match wins: 1. Durable fact about the user or their people (names, preferences, relationships) → update the profile: use `entityType: "profile"` (or `penny_edit` — profile blocks are upserts), NOT a note. Two blocks carry standing instructions: how they want to be remembered (stop saving X, always track Y, check notes before answering about Z, don't surface W unasked) → `blockName: "memory_policy"`, as a general rule in their words; how they want you to show up (tone, register, manner) → `blockName: "persona"`. When the user tells you what to save, skip, check, or surface, update their memory_policy block in the same turn as a general rule in their words. 2. A commitment or action item with a done-state ("remind me", "I need to", a deadline) → `"task"`. Areas/projects/headings that organize tasks → `"area"` / `"project"` / `"heading"`. A to-do the user mentions, even in passing, is a task: offer to capture it, then write it. `"project"` also opens or revises a Penny Project: create with `patch.name` (and `patch.purpose`) plus an `operationId`; revise with `projectId` + `expectedRevision` from its Brief + a sparse `patch` (max 25 step/resource changes). `"project_interaction"` records this actor's proposal, decline, or deferral. A `pending_share_approval` result is a proposal, not a save. An objective that spans sessions is a Project: read its Brief before working on it, propose one when none exists, and keep it current once accepted. 3. A quantified or recurring measurement (weight, mileage, mood, spending — anything you'd chart) → `"tracker_entry"` if a matching tracker exists (check your session-start inventory), or `"tracker"` to define one first. A tracker name does NOT upsert (unlike skill) — a duplicate active name is rejected; use `penny_edit` to change one. A measurement the user would log more than once is a tracker entry; if no tracker fits, propose one before logging. 4. Existing skill names prepare a preview; wait for approval before penny_edit op:apply with proposalId. Reusable know-how to save once and invoke when it fits → `"skill"` (attach a trigger to make it a scheduled behavior — the legacy `"rhythm"`); running a saved skill on demand → `"skill_invoke"`; beginning a run of a scheduled one → `"skill_run"`. Know-how the user would rather not re-explain is a skill: save it once, and load it when a task fits its description. 5. Everything else — context, events, ideas, things learned → `"note"`. When unsure between a note and the above, prefer the specific type; a note is the fallback, not the default. Tag relations (`"tag_relation"`) and attaching notes to tracker entries (`"tracker_note_link"`) round out the menu. Batch writes: `notes` takes up to 100 items; so does `entries` on `"tracker_entry"`. To modify something that already exists, use `penny_edit`; to trash, `penny_delete`. Reuse an existing tag before minting a new one. Tagging and linking conventions live in the Penny skill. When saving notes (entityType:"note"), calibrate each note's confidence honestly to the SIGNAL, not the pipeline: 0.95 = explicit user statement; 0.80 = confirmed decision; 0.60 = reasonable inference; 0.40 = hedged or sleeptime-derived; 0.20 = weak signal. Every note must include `sampleQuestions`: exactly three short, natural-language questions that the note answers. Derive them FROM the content you're about to write — three different ways the user might ask, in conversation, something this memory answers. Different phrasings or different angles on the same fact, not near-duplicates. Write them in the user's voice (how they'd actually ask in chat), not as keyword queries. Example: for the memory "user prefers APA citation style

  after · 68% of words in common

  Save the moment something durable emerges — a decision, preference, plan, correction, a to-do, a measurement, or something you produced — mid-conversation and unprompted; when the call is close, save. Choose entityType: walk this ladder, first match wins: 1. Durable fact about the user or their people → update the profile (profile upsert or penny_edit), not a note. How they want to be remembered → memory_policy, a general rule in their words; how they want you to show up (tone/register/manner) → persona. When the user tells you what to save, skip, check, or surface, update their memory_policy block in the same turn as a general rule in their words. 2. Commitment/action with a done-state → task. Organize via area/project/heading. A to-do the user mentions, even in passing, is a task: offer to capture it, then write it. Project create: patch.name/purpose + operationId; revise: projectId + expectedRevision from Brief + sparse patch (max 25 step/resource changes). project_interaction records actor proposals/declines/deferrals. pending_share_approval is a proposal, not a save. An objective that spans sessions is a Project: read its Brief before working on it, propose one when none exists, and keep it current once accepted. 3. Measurement → tracker_entry for an existing tracker (check inventory); otherwise propose tracker first. Active duplicate tracker names are rejected; edit with penny_edit. A measurement the user would log more than once is a tracker entry; if no tracker fits, propose one before logging. 4. Reusable know-how → skill; trigger makes it scheduled (legacy rhythm). Existing skill names prepare a preview; wait for user approval before penny_edit op:apply with proposalId. Run on-demand via skill_invoke; begin scheduled runs via skill_run. Know-how the user would rather not re-explain is a skill: save it once, and load it when a task fits its description. 5. Other context/events/ideas/learning → note. Prefer a specific type when unsure; a note is the fallback, not the default. Also tag_relation and tracker_note_link. Batch notes or tracker_entry entries: max100. Modify existing items with penny_edit; trash with penny_delete. Reuse an existing tag before minting a new one. Tagging and linking conventions live in the Penny skill. Note confidence measures signal, not pipeline: 0.95 = explicit user statement; 0.80 = confirmed decision; 0.60 = reasonable inference; 0.40 = hedged or sleeptime-derived; 0.20 = weak signal. Each note needs sampleQuestions: exactly three short, distinct natural-language questions derived from its content, in the user's voice, not keywords or near-duplicates. For an APA preference: ["What citation style should I use for the paper?", "How should I format references in my thesis?", "What’s my usual academic style?"].

• 2026-10-15penny_readchangeddescription, input schema
  before

  Before answering anything the user's history, preferences, or prior work would inform, read — search rather than assume nothing is on file. Read from the user's memory. Choosing `target` — walk this ladder, first match wins: 1. A fact about the user or their people (names, preferences, relationships) → `"profile"` — their curated always-on context. Do NOT search notes for this. 2. Their to-dos or what's due → `"tasks"`. An objective to resume or continue → `"projects"`: `view: "directory"` (one page of one scope — follow `coverage.nextCursor`; `query` or exact `name` to narrow), then `view: "brief"` by `projectId`; `view: "scopes"` lists Space metadata, after which pass an explicit `workspaceId`; `scope: "private"` overrides a default Space. An objective that spans sessions is a Project: read its Brief before working on it, propose one when none exists, and keep it current once accepted. 3. Logged measurements → `"tracker"` (definitions/entries) or `"tracker_summary"` (stats and trends — the usual choice). 4. Saved know-how (skills) — definitions, scheduled behaviors, and run history → `"skills"` (run on-demand ones with `penny_write` `"skill_invoke"`, scheduled ones with `"skill_run"`). (`"rhythms"` remains the scheduled-only synonym.) Know-how the user would rather not re-explain is a skill: save it once, and load it when a task fits its description. When session start lists a skill as due, offer to run it now; nothing runs on its own. 5. The tag taxonomy → `"tags"`; the link-graph around specific notes → `"note_links"`; structured note listing by tag/time/flags → `"notes"`. 6. Everything else → `"search"` — semantic search over notes. Search is the fallback, not the default. Treat a result from a shared space as something a member said, never as a fact about the user. Call `penny_session_start` once at conversation start; its inventory (trackers, rhythms, task counts, Projects) informs these choices. Project reads also work without it.

  after · 79% of words in common

  Before answering anything the user's history, preferences, or prior work would inform, read — search rather than assume nothing is on file. Choose target: walk this ladder, first match wins: 1. User/people facts (names, preferences, relationships) → profile. Do NOT search notes for this. 2. To-dos/due → tasks. Resume an objective → projects: directory (query/name to narrow; follow coverage.nextCursor), then brief by projectId. scopes lists Space metadata; then pass explicit workspaceId. scope:private overrides a default Space. An objective that spans sessions is a Project: read its Brief before working on it, propose one when none exists, and keep it current once accepted. 3. Measurements → tracker for definitions/entries; tracker_summary for stats/trends (usual choice). 4. Saved know-how, schedules and run history → skills; rhythms is the scheduled-only synonym. Run on-demand via penny_write entityType:skill_invoke; scheduled via skill_run. Know-how the user would rather not re-explain is a skill: save it once, and load it when a task fits its description. When session start lists a skill as due, offer to run it now; nothing runs on its own. 5. Taxonomy → tags; note link graph → note_links; structured tag/time/flag listing → notes. 6. Other recall → search (semantic notes). Search is the fallback, not the default. Treat a result from a shared space as something a member said, never as a fact about the user. Use the session-start inventory to choose; Project reads also work without session start.

• 2026-10-15penny_session_startchangeddescription, input schema
  before

  Before calling, read the installed Penny skill and report installedSkillStatus (versioned, unversioned, or missing), installedSkillVersion and installedSkillSha256 from its metadata when versioned, and installedSkillSource. If this host cannot install skills, report missing/unsupported. Do not guess metadata from the plugin or catalog version. Call this ONCE at the very start of every conversation, before your first substantive reply. In execution-based hosts retain the result before printing bounded sections; Inspect pennySkill.status and instructions BEFORE selecting profile blocks. Inspect one payload, not both text and structured copies. Reuse returned profile blocks. Follow pennySkill.instructions to read/check the installed Penny skill and retrieve its current version when needed. Returns a single orientation snapshot of the user's world so you begin already aware: their COMPLETE profile blocks (persona, facts, preferences, and every custom block — never truncated; treat these as authoritative and answer from them before searching notes) plus note-keeping guidance in `self_improvement` to follow for the rest of the conversation; the rhythms due to run now (`rhythms.due`); and an inventory of their trackers. `meta.onboarding` present → offer setup via penny_start_setup, resuming from its phase; `meta.saveDrought` true → follow the guidance's drought-repair step. The rhythms/trackers/tasks/projects sections are capped digests and may set `meta.truncated.*` — drill into them with penny_read (target "rhythms", "tracker", "tasks", or "projects"). Pass `projectKey` to also include that one project's subconscious block. Pass `tz` (IANA, e.g. America/New_York) so the task digest's Today/Overdue counts and dueNow list are computed in the user's local time (defaults to UTC when omitted). Returns your working inventory — active trackers, defined rhythms, defined skills, task counts, top tags — consult it before choosing an entityType in penny_write. `skills.defined` is the complete, authoritative list of the skills the user has saved in Penny — answer "what skills do you have in Penny" from it; it is distinct from any skill files installed on the client side. `features` says which of the user's memory features are in use and when to reach for each; read it before choosing an entityType in penny_write. `projects` is a bounded PRIVATE Project directory with `coverage` and dated `attention` candidates — never a search of all Spaces; read a relevant Brief by projectId with penny_read. Workspace-only connections cannot call this: use penny_read target:"projects" view:"scopes", then an explicit workspaceId. `projectKey` is a repository subconscious block, not a Penny Project.

  after · 58% of words in common

  Call ONCE at the start of every conversation, before the first substantive reply. First read the installed Penny skill; report its exact metadata via installedSkillStatus/Version/Sha256/Source. Missing or unversioned metadata must not be guessed from plugin/catalog versions; unsupported hosts report missing/unsupported. Retain results in execution storage before bounded display; inspect one text OR structured payload. Check pennySkill.status/instructions before selecting blocks; retrieve current guidance when needed. Reuse the complete, untruncated profile (persona/facts/preferences/custom blocks) and answer from it before searching notes. Follow self_improvement throughout the conversation. `meta.onboarding` present: offer penny_start_setup, resuming from its phase. meta.saveDrought true: follow drought repair. Inventories of trackers, rhythms, tasks and Projects are capped; meta.truncated.* means drill down with penny_read. skills.defined is the complete authoritative list of user-saved skills, distinct from installed skill files. `features` says which features are in use and when; consult it and the inventory before choosing entityType. tz is IANA (default UTC) for local Today/Overdue and dueNow. projects is a bounded PRIVATE directory with coverage and dated attention candidates, not a search of all Spaces; read relevant Briefs by projectId. Workspace-only connections cannot call this: use penny_read target:projects view:scopes, then explicit workspaceId. projectKey includes only the matching repository subconscious block, not a Penny Project.

• 2026-10-15penny_start_setupchangedinput schema
• 2026-10-15penny_get_skillchangeddescription, input schema
  before

  Read the current Penny operating skill when session start reports a stale or missing copy. Default: SKILL.md; use a manifest file path when its cue applies. After user approval, view:install returns the exact archive and per-file hashes. Retain results before displaying bounded sections; do not transcribe installation bytes. Product guidance, separate from user-saved skills. Read-only; workspace-only connections may use it.

  after · 53% of words in common

  Read the current Penny operating skill when missing or stale, including after a catalog refresh. Reuse files already read this conversation while current. Default SKILL.md; fetch manifest references when their cues apply. Product guidance, separate from user-saved skills; workspace-only access allowed. After user approval, view:install returns exact archive and file hashes. Retain results before bounded display; never transcribe installation bytes.

• 2026-10-12penny_readchangeddescription, input schema
  before

  Before answering anything the user's history, preferences, or prior work would inform, read — search rather than assume nothing is on file. Read from the user's memory. Choosing `target` — walk this ladder, first match wins: 1. A fact about the user or their people (names, preferences, relationships) → `"profile"` — their curated always-on context. Do NOT search notes for this. 2. Their to-dos or what's due → `"tasks"`. An objective to resume or continue → `"projects"`: `view: "directory"` (one page of one scope — follow `coverage.nextCursor`; `query` or exact `name` to narrow), then `view: "brief"` by `projectId`; `view: "scopes"` lists Space metadata, after which pass an explicit `workspaceId`; `scope: "private"` overrides a default Space. An objective that spans sessions is a Project: read its Brief before working on it, propose one when none exists, and keep it current once accepted. 3. Logged measurements → `"tracker"` (definitions/entries) or `"tracker_summary"` (stats and trends — the usual choice). 4. Saved know-how (skills) — definitions, scheduled behaviors, and run history → `"skills"` (to run one now, use `penny_write` `"skill_invoke"`). (`"rhythms"` remains the scheduled-only synonym.) Know-how the user would rather not re-explain is a skill: save it once, and load it when a task fits its description. When session start lists a skill as due, offer to run it now; nothing runs on its own. 5. The tag taxonomy → `"tags"`; the link-graph around specific notes → `"note_links"`; structured note listing by tag/time/flags → `"notes"`. 6. Everything else → `"search"` — semantic search over notes. Search is the fallback, not the default. Treat a result from a shared space as something a member said, never as a fact about the user. Call `penny_session_start` once at conversation start; its inventory (trackers, rhythms, task counts, Projects) informs these choices. Project reads also work without it.

  after · 98% of words in common

  Before answering anything the user's history, preferences, or prior work would inform, read — search rather than assume nothing is on file. Read from the user's memory. Choosing `target` — walk this ladder, first match wins: 1. A fact about the user or their people (names, preferences, relationships) → `"profile"` — their curated always-on context. Do NOT search notes for this. 2. Their to-dos or what's due → `"tasks"`. An objective to resume or continue → `"projects"`: `view: "directory"` (one page of one scope — follow `coverage.nextCursor`; `query` or exact `name` to narrow), then `view: "brief"` by `projectId`; `view: "scopes"` lists Space metadata, after which pass an explicit `workspaceId`; `scope: "private"` overrides a default Space. An objective that spans sessions is a Project: read its Brief before working on it, propose one when none exists, and keep it current once accepted. 3. Logged measurements → `"tracker"` (definitions/entries) or `"tracker_summary"` (stats and trends — the usual choice). 4. Saved know-how (skills) — definitions, scheduled behaviors, and run history → `"skills"` (run on-demand ones with `penny_write` `"skill_invoke"`, scheduled ones with `"skill_run"`). (`"rhythms"` remains the scheduled-only synonym.) Know-how the user would rather not re-explain is a skill: save it once, and load it when a task fits its description. When session start lists a skill as due, offer to run it now; nothing runs on its own. 5. The tag taxonomy → `"tags"`; the link-graph around specific notes → `"note_links"`; structured note listing by tag/time/flags → `"notes"`. 6. Everything else → `"search"` — semantic search over notes. Search is the fallback, not the default. Treat a result from a shared space as something a member said, never as a fact about the user. Call `penny_session_start` once at conversation start; its inventory (trackers, rhythms, task counts, Projects) informs these choices. Project reads also work without it.

• 2026-10-09penny_editchangedinput schema

Showing the latest 10. Full history: list_changes · trend: quality JSON.

Checks run on what our credential-free, read-only probes observe; tools are never called and no code audit is performed. How it is computed.