MyPenny

Read the current Penny operating skill when session start reports a stale or missing installed copy. Default returns only SKILL.md; use file for a reference path from manifest when its cue applies. Use view:install after user approval for an exact installation archive and per-file hashes. Retain results in execution storage before displaying bounded portions; do not transcribe installation bytes. This is product guidance, not user-saved skills. Read-only; workspace-only connections may use it.

{
  "type": "object",
  "properties": {
    "file": {
      "description": "Exact manifest path, default SKILL.md; read view only.",
      "type": "string"
    },
    "view": {
      "description": "Default read. Install returns an archive, not readable guidance.",
      "enum": [
        "read",
        "install"
      ],
      "type": "string"
    }
  },
  "additionalProperties": false
}

Run the first-run setup interview with the user. Returns a short interview script (how to address them, who they are, communication preferences, current focus) for you to ask conversationally and save with penny_write (entityType:"profile"), plus a custom-instructions snippet for the user to paste into their AI app so future conversations use these notes. Calling this marks onboarding complete (see penny_read target:"profile" `meta.onboarded`), so only call it when the user agrees to set up. Pass `client` when you know which app the user is in, to tailor the paste-here instructions.

{
  "type": "object",
  "properties": {
    "client": {
      "description": "Optional client hint: 'claude-desktop' | 'chatgpt' | 'claude-web' | other. Tailors the snippet's where-to-paste guidance.",
      "type": "string"
    }
  }
}

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.onboarded` false → offer setup via penny_start_setup; `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.

{
  "type": "object",
  "properties": {
    "installedSkillSha256": {
      "description": "Exact metadata.bundle_sha256; report absent metadata as unversioned.",
      "type": "string"
    },
    "installedSkillSource": {
      "description": "How the skill is managed; plugin copies update through the plugin manager, standalone copies through approved archive installation.",
      "enum": [
        "standalone",
        "plugin",
        "unsupported",
        "unknown"
      ],
      "type": "string"
    },
    "installedSkillStatus": {
      "description": "Report after reading the installed Penny skill. Omission is retained only for legacy clients and returns not_reported.",
      "enum": [
        "versioned",
        "unversioned",
        "missing"
      ],
      "type": "string"
    },
    "installedSkillVersion": {
      "description": "Exact metadata.version from the installed skill; omit if missing or unversioned.",
      "type": "string"
    },
    "projectKey": {
      "description": "Includes only the matching subconscious:<projectKey> block; other subconscious blocks are always excluded.",
      "type": "string"
    },
    "tz": {
      "description": "IANA timezone for deriving today/overdue date boundaries (e.g. America/New_York). Defaults to UTC when omitted.",
      "type": "string"
    }
  }
}

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.

{
  "type": "object",
  "properties": {
    "areaId": {
      "description": "target:\"tasks\" — filter by area, or organize=\"project\" filter.",
      "type": "string"
    },
    "blockNames": {
      "description": "profile: exact block names.",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "blocked": {
      "description": "target:\"tasks\" — restrict to tasks with unmet dependsOn.",
      "type": "boolean"
    },
    "bucket": {
      "description": "target:\"tasks\" — filter by schedule bucket.",
      "enum": [
        "today",
        "upcoming",
        "anytime",
        "someday"
      ],
      "type": "string"
    },
    "confidence": {
      "description": "notes: confidence range.",
      "properties": {
        "max": {
          "type": "number"
        },
        "min": {
          "type": "number"
        }
      },
      "type": "object"
    },
    "cursor": {
      "description": "Project cursor; retain view/scope.",
      "type": "string"
    },
    "dateAxis": {
      "description": "target:\"notes\" — which date timeRange filters ('created' = when written, 'valid' = when the fact holds).",
      "enum": [
        "created",
        "valid"
      ],
      "type": "string"
    },
    "depth": {
      "description": "target:\"note_links\" — hops to expand (1 = direct links; 2-6 = bounded BFS).",
      "type": "number"
    },
    "dueRange": {
      "description": "target:\"tasks\" — due-date window (ms epoch).",
      "properties": {
        "end": {
          "type": "number"
        },
        "start": {
          "type": "number"
        }
      },
      "type": "object"
    },
    "edgeTypes": {
      "description": "target:\"note_links\" — only follow/return edges of these relationship types.",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "enabledOnly": {
      "description": "target:\"rhythms\" view:\"list\" — only enabled rhythms.",
      "type": "boolean"
    },
    "eventKey": {
      "description": "Projects interactions: actor event key; omit to page.",
      "type": "string"
    },
    "flags": {
      "description": "notes: locked/pinned filter.",
      "properties": {
        "locked": {
          "type": "boolean"
        },
        "pinned": {
          "type": "boolean"
        }
      },
      "type": "object"
    },
    "from": {
      "description": "target:\"tracker\" entries / tracker_summary — start of window (ms epoch).",
      "type": "number"
    },
    "graphTraversal": {
      "description": "search: opt into tag/link graph expansion (default false; measured recall loss). Use only for deliberate graph exploration.",
      "type": "boolean"
    },
    "includeArchived": {
      "description": "Include archived trackers, Projects, or task containers.",
      "type": "boolean"
    },
    "includeCompleted": {
      "description": "target:\"tasks\" — include done/canceled tasks (default false).",
      "type": "boolean"
    },
    "includeRelations": {
      "description": "tags/list: include parents/children/synonyms.",
      "type": "boolean"
    },
    "limit": {
      "description": "Max results. Applies to search, notes, tracker entries, tasks, and rhythm runs.",
      "type": "number"
    },
    "maxDepth": {
      "description": "tags/related: maximum traversal depth.",
      "type": "number"
    },
    "maxNodes": {
      "description": "target:\"note_links\" — cap on returned nodes when depth > 1 (default 50).",
      "type": "number"
    },
    "minWeight": {
      "description": "tags/related: minimum edge weight (default 0.4).",
      "type": "number"
    },
    "name": {
      "description": "Projects directory: exact-name candidates; continue incomplete coverage.",
      "type": "string"
    },
    "orgStatus": {
      "description": "target:\"tasks\" organize=\"project\" — filter projects by status.",
      "enum": [
        "active",
        "paused",
        "done",
        "canceled"
      ],
      "type": "string"
    },
    "organize": {
      "description": "target:\"tasks\" — enumerate containers instead of tasks.",
      "enum": [
        "area",
        "project",
        "heading"
      ],
      "type": "string"
    },
    "owner": {
      "description": "target:\"tasks\" — filter by owner.",
      "enum": [
        "me",
        "agent",
        "unassigned"
      ],
      "type": "string"
    },
    "projectId": {
      "description": "target:projects brief/section/resources/resource/history — required stable Project ID. target:tasks — Project filter, or heading parent.",
      "type": "string"
    },
    "projectKey": {
      "description": "profile: include subconscious:<projectKey>.",
      "type": "string"
    },
    "query": {
      "description": "search: required semantic query. projects directory: name/purpose filter; check coverage.",
      "type": "string"
    },
    "resourceId": {
      "description": "Projects resource: read the authorized current source.",
      "type": "string"
    },
    "resourceState": {
      "enum": [
        "attached",
        "suggested",
        "removed"
      ],
      "type": "string"
    },
    "rhythmId": {
      "description": "target:\"rhythms\" view:\"one\" (required) or view:\"runs\" (optional scope).",
      "type": "string"
    },
    "scope": {
      "description": "Projects: private overrides defaults; workspace requires workspaceId.",
      "enum": [
        "private",
        "workspace"
      ],
      "type": "string"
    },
    "section": {
      "description": "target:projects view:section — one Brief section.",
      "enum": [
        "purpose",
        "progress",
        "resources",
        "plan",
        "instructions"
      ],
      "type": "string"
    },
    "seedIds": {
      "description": "target:\"note_links\" — note id(s) to start the link-graph walk from (required).",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "seriesId": {
      "description": "tasks: one recurring series’ complete occurrence history, newest first (includes completed).",
      "type": "string"
    },
    "skillId": {
      "description": "target:\"skills\" view:\"one\" (required) or view:\"runs\" (optional scope).",
      "type": "string"
    },
    "status": {
      "description": "target:\"tasks\" — filter by task status.",
      "enum": [
        "open",
        "in_progress",
        "done",
        "canceled",
        "active",
        "paused"
      ],
      "type": "string"
    },
    "tags": {
      "description": "Filter by tags. Applies to target \"search\" and \"notes\".",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "target": {
      "description": "What to read. Walk the ladder in the tool description; first match wins.",
      "enum": [
        "profile",
        "projects",
        "tasks",
        "tracker",
        "tracker_summary",
        "rhythms",
        "skills",
        "tags",
        "note_links",
        "notes",
        "search"
      ],
      "type": "string"
    },
    "taskId": {
      "description": "tasks: full detail. A repeating task returns seriesId/currentOccurrenceId; act on the current occurrence, not a completed ID.",
      "type": "string"
    },
    "timeRange": {
      "description": "Time window (ms epoch). Applies to target \"search\" and \"notes\".",
      "properties": {
        "end": {
          "type": "number"
        },
        "start": {
          "type": "number"
        }
      },
      "type": "object"
    },
    "to": {
      "description": "target:\"tracker\" entries / tracker_summary — end of window (ms epoch).",
      "type": "number"
    },
    "trackerId": {
      "description": "target:\"tracker\" view:\"entries\" (required), or target:\"tracker_summary\" (required).",
      "type": "string"
    },
    "tz": {
      "description": "target:\"tasks\" — IANA timezone for Today/Upcoming boundaries.",
      "type": "string"
    },
    "view": {
      "description": "Projects: directory (default), brief, section, resources, resource, history, scopes (Space metadata), attention (dated candidates), interactions (actor only). Secondary selector: target:\"tracker\" list|entries; target:\"rhythms\" list|one|due|runs; target:\"skills\" list|one|due|runs|history|trash (to run one, use penny_write \"skill_invoke\"); target:\"tags\" list|related.",
      "type": "string"
    }
  },
  "required": [
    "target"
  ]
}

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 MyPenny 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 for which that note would be a useful retrieval result. Derive them FROM the content you're about to write — three different ways the user might ask, in conversation, something this memory should answer. 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 retrieval queries. Example: for the memory "user prefers APA citation style for academic writing", good sampleQuestions are ["What citation style should I use for the paper?", "How should I format references in my thesis?", "What's my usual academic style?"].

{
  "type": "object",
  "properties": {
    "actor": {
      "description": "entityType:\"task\"/\"area\"/\"project\"/\"heading\" — who took the action (me|agent), written to the activity ledger.",
      "type": "string"
    },
    "agentNote": {
      "description": "entityType:\"tracker_entry\" (single-entry form only) — short caption on this one data point (not searchable).",
      "type": "string"
    },
    "areaId": {
      "description": "entityType:\"project\" (required) — the area the project belongs to.",
      "type": "string"
    },
    "blockName": {
      "description": "entityType:\"profile\" (required) — the profile block name to upsert.",
      "type": "string"
    },
    "child": {
      "description": "entityType:\"tag_relation\" (required) — the child tag.",
      "type": "string"
    },
    "content": {
      "description": "entityType:\"profile\" (required) — the block content.",
      "type": "string"
    },
    "deadline": {
      "description": "entityType:\"task\"/\"project\" — hard due date (ms epoch).",
      "type": "number"
    },
    "deliver": {
      "description": "entityType:\"skill\" — REQUIRED once `trigger` is set (and on the legacy entityType:\"rhythm\"); omit on an on-demand skill. Where a scheduled run's output lands: { kind:'note', tags?:string[] } | { kind:'profile_block', blockName:string } | { kind:'notify' }.",
      "type": "object"
    },
    "dependsOn": {
      "description": "entityType:\"task\" — full replacement set of taskIds that must complete first.",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "description": {
      "description": "entityType:\"tracker\" (required) — natural-language meaning. entityType:\"skill\" (required — every skill, on-demand or scheduled) or legacy \"rhythm\" — one-line description of what it is for.",
      "type": "string"
    },
    "entityType": {
      "description": "What to create. Walk the ladder in the tool description; first match wins.",
      "enum": [
        "profile",
        "task",
        "area",
        "project",
        "project_interaction",
        "heading",
        "tracker",
        "tracker_entry",
        "rhythm",
        "rhythm_run",
        "skill",
        "skill_invoke",
        "skill_run",
        "tag_relation",
        "tracker_note_link",
        "note"
      ],
      "type": "string"
    },
    "entries": {
      "description": "tracker_entry: batch up to 100 entries for one trackerId; each {payload,loggedAt?,agentNote?,noteIds?,source?,metadata?}. Mutually exclusive with top-level payload. Receipts report each saved/failed item; do not claim all saved from a partial result.",
      "type": "array"
    },
    "expectedRevision": {
      "description": "Project edit revision from Brief; reconcile conflicts.",
      "type": "number"
    },
    "expectedUpdatedAt": {
      "description": "Source version from the read.",
      "type": "number"
    },
    "goal": {
      "description": "entityType:\"rhythm\" (required) — natural-language instruction: what the run should do. On entityType:\"skill\" this is `instructions`.",
      "type": "string"
    },
    "headingId": {
      "description": "entityType:\"task\" — heading to file the task under.",
      "type": "string"
    },
    "instructions": {
      "description": "entityType:\"skill\" (required) — the saved know-how: what to do when the skill is invoked, or when a connected agent picks it up after it comes due. Generalizes the rhythm \"goal\".",
      "type": "string"
    },
    "interaction": {
      "description": "project_interaction: actor decision; read first, update with expectedUpdatedAt.",
      "properties": {
        "content": {
          "description": "Rationale required for reconsideration.",
          "type": "string"
        },
        "deferredUntil": {
          "type": "number"
        },
        "eventKey": {
          "type": "string"
        },
        "expectedUpdatedAt": {
          "type": "number"
        },
        "kind": {
          "enum": [
            "proposal",
            "attention"
          ],
          "type": "string"
        },
        "objective": {
          "description": "First proposal objective.",
          "type": "string"
        },
        "reconsider": {
          "type": "boolean"
        },
        "state": {
          "enum": [
            "proposed",
            "declined",
            "deferred",
            "presented",
            "dismissed",
            "accepted"
          ],
          "type": "string"
        },
        "taskId": {
          "type": "string"
        },
        "urgencyKey": {
          "type": "string"
        }
      },
      "required": [
        "kind",
        "state"
      ],
      "type": "object"
    },
    "kind": {
      "description": "entityType:\"tracker\" (required) — habit | metric | goal | log | status | custom.",
      "type": "string"
    },
    "linkNotes": {
      "description": "entityType:\"task\" — note ids to link to this task.",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "name": {
      "description": "Required for tracker/area/project and entityType:\"skill\" (also rhythm); for skill_invoke/skill_run, an alternative to skillId. Existing skill names prepare a change preview; new names create. Active tracker duplicates are rejected; archived names reactivate.",
      "type": "string"
    },
    "noteIds": {
      "description": "entityType:\"tracker_entry\" — archival note ids to attach; or \"tracker_note_link\" (required) — the notes to link.",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "notes": {
      "description": "note: array (max 100), each requires content and confidence (0–1), plus tags and exactly 3 sampleQuestions in the user’s voice; optional source/memoryType (episodic|semantic|procedural)/validFrom. task/area/project: markdown string.",
      "type": [
        "array",
        "string"
      ]
    },
    "operationId": {
      "description": "Project receipt key; identical retries only.",
      "type": "string"
    },
    "order": {
      "description": "entityType:\"task\"/\"area\"/\"project\"/\"heading\" — sort order.",
      "type": "number"
    },
    "owner": {
      "description": "entityType:\"task\" — assignee.",
      "enum": [
        "me",
        "agent",
        "unassigned"
      ],
      "type": "string"
    },
    "parent": {
      "description": "entityType:\"tag_relation\" (required) — the parent tag in the child_of edge.",
      "type": "string"
    },
    "patch": {
      "additionalProperties": false,
      "description": "Project sparse changes; omitted fields stay. Max 25 step/resource changes.",
      "properties": {
        "archived": {
          "type": "boolean"
        },
        "areaId": {
          "type": [
            "string",
            "null"
          ]
        },
        "checkpoint": {
          "description": "Factual handoff: changes, unfinished work, next step (4 KiB).",
          "type": "string"
        },
        "deadline": {
          "type": [
            "number",
            "null"
          ]
        },
        "instructions": {
          "type": "string"
        },
        "name": {
          "type": "string"
        },
        "notes": {
          "type": "string"
        },
        "order": {
          "type": "number"
        },
        "progress": {
          "type": "string"
        },
        "purpose": {
          "type": "string"
        },
        "resources": {
          "description": "Attach created_for/deliberately_used sources; otherwise suggest. Removed links need restore; links do not share source content.",
          "items": {
            "properties": {
              "label": {
                "type": [
                  "string",
                  "null"
                ]
              },
              "op": {
                "enum": [
                  "attach",
                  "suggest",
                  "remove",
                  "restore"
                ],
                "type": "string"
              },
              "reason": {
                "enum": [
                  "created_for",
                  "deliberately_used",
                  "suggested"
                ],
                "type": "string"
              },
              "resourceId": {
                "type": "string"
              },
              "role": {
                "enum": [
                  "reference",
                  "method"
                ],
                "type": "string"
              },
              "source": {
                "properties": {
                  "id": {
                    "type": "string"
                  },
                  "kind": {
                    "enum": [
                      "note",
                      "task",
                      "tracker",
                      "tracker_entry",
                      "skill",
                      "profile_block",
                      "external"
                    ],
                    "type": "string"
                  },
                  "scope": {
                    "properties": {
                      "kind": {
                        "enum": [
                          "private",
                          "workspace"
                        ],
                        "type": "string"
                      },
                      "orgId": {
                        "type": "string"
                      },
                      "workspaceId": {
                        "type": "string"
                      }
                    },
                    "required": [
                      "kind"
                    ],
                    "type": "object"
                  }
                },
                "required": [
                  "kind",
                  "id",
                  "scope"
                ],
                "type": "object"
              },
              "url": {
                "type": [
                  "string",
                  "null"
                ]
              }
            },
            "required": [
              "op"
            ],
            "type": "object"
          },
          "maxItems": 25,
          "type": "array"
        },
        "status": {
          "enum": [
            "active",
            "paused",
            "done",
            "canceled"
          ],
          "type": "string"
        },
        "steps": {
          "description": "accept converts a saved suggestion into a To-do.",
          "items": {
            "properties": {
              "op": {
                "enum": [
                  "suggest",
                  "edit",
                  "dismiss",
                  "accept"
                ],
                "type": "string"
              },
              "order": {
                "type": "number"
              },
              "stepId": {
                "type": "string"
              },
              "text": {
                "type": "string"
              }
            },
            "required": [
              "op",
              "stepId"
            ],
            "type": "object"
          },
          "maxItems": 25,
          "type": "array"
        },
        "whenAt": {
          "type": [
            "number",
            "null"
          ]
        },
        "whenBucket": {
          "enum": [
            "anytime",
            "someday",
            null
          ],
          "type": [
            "string",
            "null"
          ]
        }
      },
      "type": "object"
    },
    "payload": {
      "description": "entityType:\"tracker_entry\" (required unless `entries` is used) — the structured data point; shape is tracker-defined.",
      "type": "object"
    },
    "posture": {
      "description": "entityType:\"skill\" with a `trigger` set (or legacy \"rhythm\") — read | propose | act (defaults 'read').",
      "type": "string"
    },
    "projectId": {
      "description": "entityType:\"task\" — parent project; or \"heading\" — the project it belongs to (required).",
      "type": "string"
    },
    "reasoning": {
      "description": "entityType:\"tag_relation\" — short justification (typically a user quote) for the edge.",
      "type": "string"
    },
    "recordedAt": {
      "description": "entityType:\"tracker_entry\" (single-entry form only) — observation time (ms epoch; defaults to now).",
      "type": "number"
    },
    "recurrence": {
      "description": "entityType:\"task\" — makes the task repeat. The returned `taskId` is this task's first occurrence; completing it later returns `nextTaskId` for the next one (see penny_edit's `status` field) — don't cache this id past its first completion.",
      "properties": {
        "at": {
          "description": "Time expression: \"HH:MM\" for daily, \"<Wd> HH:MM\" for weekly, \"DD HH:MM\" for monthly.",
          "type": "string"
        },
        "cadence": {
          "enum": [
            "daily",
            "weekly",
            "monthly"
          ],
          "type": "string"
        },
        "timezone": {
          "description": "IANA timezone (e.g. America/New_York).",
          "type": "string"
        }
      },
      "required": [
        "cadence"
      ],
      "type": "object"
    },
    "retrievalPlan": {
      "description": "entityType:\"skill\" (or legacy \"rhythm\") — OPTIONAL deterministic steps [{ tool, args }] for a bounded tier.",
      "type": "array"
    },
    "rhythmId": {
      "description": "entityType:\"rhythm_run\" — the rhythm to begin a run of (or pass `name`).",
      "type": "string"
    },
    "scope": {
      "description": "Profile: global|workspace. Projects: private; workspace requires workspaceId.",
      "enum": [
        "global",
        "workspace",
        "private"
      ],
      "type": "string"
    },
    "skillId": {
      "description": "entityType:\"skill_invoke\" (required, or pass `name`) — the skill to run now. entityType:\"skill_run\" — the skill to begin a run of (or pass `name`).",
      "type": "string"
    },
    "source": {
      "description": "entityType:\"note\"/\"tracker_entry\" — provenance label (defaults 'conversation' / 'agent-mcp').",
      "type": "string"
    },
    "status": {
      "description": "entityType:\"task\" — initial status.",
      "enum": [
        "open",
        "in_progress",
        "done",
        "canceled"
      ],
      "type": "string"
    },
    "tags": {
      "description": "entityType:\"task\" — tags to attach.",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "targetSpec": {
      "description": "entityType:\"tracker\" — JSON target spec, interpreted at retrieval (e.g. { kind: 'daily_minimum', value: 10000 }).",
      "type": "object"
    },
    "title": {
      "description": "entityType:\"task\" (required) or \"heading\" (required) — the title/label.",
      "type": "string"
    },
    "trackerEntryId": {
      "description": "entityType:\"tracker_note_link\" (required) — the logged tracker entry to attach notes to.",
      "type": "string"
    },
    "trackerId": {
      "description": "entityType:\"tracker_entry\" (required) — the tracker to log against.",
      "type": "string"
    },
    "trigger": {
      "description": "entityType:\"skill\": optional schedule (required for rhythm), requires deliver. MyPenny does not run it: due signals reach the connected agent. Schedule: {kind:\"schedule\",cadence:\"daily\"|\"weekly\"|\"monthly\",at?:\"Fri 16:00\",timezone?:\"America/Denver\"}. ALWAYS set timezone (IANA); default UTC shifts local times. Event: {kind:\"event\",on:\"note.created\",where?:{tags?:string[]}}.",
      "type": "object"
    },
    "unit": {
      "description": "entityType:\"tracker\" — unit of measure.",
      "type": "string"
    },
    "whenAt": {
      "description": "entityType:\"task\"/\"project\" — schedule date (ms epoch).",
      "type": "number"
    },
    "whenBucket": {
      "description": "entityType:\"task\"/\"project\" — undated bucket; mutually exclusive with whenAt.",
      "enum": [
        "anytime",
        "someday"
      ],
      "type": "string"
    }
  },
  "required": [
    "entityType"
  ]
}

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`.

{
  "type": "object",
  "properties": {
    "actor": {
      "description": "entityType:\"task\"/\"area\"/\"project\"/\"heading\" — who took the action (me|agent), written to the activity ledger.",
      "type": "string"
    },
    "agentNote": {
      "type": "string"
    },
    "archived": {
      "description": "Area/project/tracker: archive; false reactivates. Tracker definitions retire only this way.",
      "type": "boolean"
    },
    "areaId": {
      "description": "entityType:\"project\" — the area the project belongs to.",
      "type": "string"
    },
    "blockName": {
      "description": "entityType:\"profile\" (required) — the profile block to upsert.",
      "type": "string"
    },
    "clearFields": {
      "description": "entityType:\"task\" — names of optional fields to UNSET on the task.",
      "items": {
        "enum": [
          "whenAt",
          "whenBucket",
          "deadline",
          "projectId",
          "headingId",
          "recurrence"
        ],
        "type": "string"
      },
      "type": "array"
    },
    "content": {
      "description": "entityType:\"profile\" (required) — the new block content.",
      "type": "string"
    },
    "deadline": {
      "description": "entityType:\"task\"/\"project\" — hard due date (ms epoch).",
      "type": "number"
    },
    "deliver": {
      "description": "entityType:\"skill\": required with trigger (also rhythm); omit for on-demand. See penny_write for shape.",
      "type": "object"
    },
    "dependsOn": {
      "description": "entityType:\"task\" — full replacement set of taskIds that must complete first.",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "description": {
      "description": "entityType:\"skill\": REQUIRED use-when description; also rhythm. tracker: meaning; log trackers must document payload shape.",
      "type": "string"
    },
    "enabled": {
      "description": "entityType:\"skill\": false pauses due signals, true resumes; requires skillId. MyPenny does not run skills.",
      "type": "boolean"
    },
    "entityType": {
      "description": "Item type.",
      "enum": [
        "profile",
        "task",
        "area",
        "project",
        "heading",
        "tracker",
        "rhythm",
        "rhythm_run",
        "skill",
        "skill_run",
        "note",
        "tracker_entry"
      ],
      "type": "string"
    },
    "entryId": {
      "type": "string"
    },
    "expectedRevision": {
      "description": "Project edit revision from Brief; reconcile conflicts.",
      "type": "number"
    },
    "expectedUpdatedAt": {
      "description": "Source version from the read.",
      "type": "number"
    },
    "fields": {
      "description": "Restore selection: field names or step:<stepId>; fields/resourceIds required.",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "goal": {
      "description": "entityType:\"rhythm\" (required) — what the run should do. On entityType:\"skill\" this is `instructions`.",
      "type": "string"
    },
    "historyId": {
      "description": "restore_revision: Project history item or skill history item. Skill restoration prepares a preview; requires skillId and expectedUpdatedAt.",
      "type": "string"
    },
    "ids": {
      "description": "op:\"restore\" — ids to un-trash (max 100).",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "instructions": {
      "description": "entityType:\"skill\" (required) — the saved know-how (generalizes the rhythm \"goal\").",
      "type": "string"
    },
    "kind": {
      "description": "entityType:\"tracker\" — habit | metric | goal | log | status | custom.",
      "type": "string"
    },
    "linkNotes": {
      "description": "entityType:\"task\" — note ids to link to this task.",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "name": {
      "description": "Area/project/tracker name; entityType:\"skill\" names prepare a preview of the replacement (rhythm names upsert).",
      "type": "string"
    },
    "notes": {
      "description": "entityType:\"task\"/\"area\"/\"project\" — markdown body.",
      "type": "string"
    },
    "op": {
      "description": "op:\"restore\" un-trashes notes or tracker entries by `ids`.",
      "enum": [
        "restore",
        "restore_revision",
        "apply",
        "cancel",
        "undo"
      ],
      "type": "string"
    },
    "operationId": {
      "description": "Project receipt key; identical retries only.",
      "type": "string"
    },
    "order": {
      "description": "entityType:\"task\"/\"area\"/\"project\"/\"heading\" — sort order.",
      "type": "number"
    },
    "orgId": {
      "description": "entityType:\"area\"/\"project\"/\"heading\" (required) — the container to update.",
      "type": "string"
    },
    "owner": {
      "description": "entityType:\"task\" — assignee.",
      "enum": [
        "me",
        "agent",
        "unassigned"
      ],
      "type": "string"
    },
    "patch": {
      "description": "Project patch: full schema on penny_write.",
      "type": "object"
    },
    "payload": {
      "type": [
        "object",
        "string"
      ]
    },
    "posture": {
      "description": "entityType:\"skill\" with a `trigger` set (or legacy \"rhythm\") — read | propose | act.",
      "type": "string"
    },
    "projectId": {
      "description": "entityType:\"heading\" (required) — the project the heading belongs to.",
      "type": "string"
    },
    "proposalId": {
      "description": "Skill change proposal returned by an edit. op:apply commits after user review; cancel discards; undo restores the previous version if no later edit exists.",
      "type": "string"
    },
    "provenance": {
      "description": "entityType:\"rhythm_run\" — accountability summary of what the run did (ids/labels, never full content).",
      "properties": {
        "delivered": {
          "type": "string"
        },
        "outsideWorld": {
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "reads": {
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "summary": {
          "type": "string"
        },
        "writes": {
          "items": {
            "type": "string"
          },
          "type": "array"
        }
      },
      "type": "object"
    },
    "recordedAt": {
      "type": "number"
    },
    "recurrence": {
      "description": "entityType:\"task\" — makes the task repeat, or (on an existing repeating task) changes its schedule. Setting `clearFields: [\"recurrence\"]` ENDS the series (task becomes a one-off; completed occurrences stay as history) but must target `currentOccurrenceId`, not a stale/completed id.",
      "properties": {
        "at": {
          "description": "task: set/change recurrence; shape as penny_write. clearFields:[\"recurrence\"] ends the series, preserving history; target currentOccurrenceId.",
          "type": "string"
        },
        "cadence": {
          "enum": [
            "daily",
            "weekly",
            "monthly"
          ],
          "type": "string"
        },
        "timezone": {
          "description": "IANA timezone (e.g. America/New_York).",
          "type": "string"
        }
      },
      "required": [
        "cadence"
      ],
      "type": "object"
    },
    "resourceIds": {
      "description": "Restore selected links.",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "retrievalPlan": {
      "description": "entityType:\"skill\" (or legacy \"rhythm\") — OPTIONAL deterministic steps for a bounded tier.",
      "type": "array"
    },
    "runId": {
      "description": "entityType:\"skill_run\" (required) — the run to complete; same field on the legacy \"rhythm_run\".",
      "type": "string"
    },
    "scope": {
      "description": "Profile: global|workspace. Projects: private; workspace requires workspaceId.",
      "enum": [
        "global",
        "workspace",
        "private"
      ],
      "type": "string"
    },
    "skillId": {
      "description": "entityType:\"skill\" pause/resume — the skill id (required with enabled).",
      "type": "string"
    },
    "snapshot": {
      "description": "Skill restore_revision: which side of the history entry to restore (default before). Select after to recover a change that was undone.",
      "enum": [
        "before",
        "after"
      ],
      "type": "string"
    },
    "status": {
      "description": "task: open|in_progress|done|canceled. Repeating completion returns nextTaskId: act on that new occurrence; the completed ID rejects further status writes. skill_run/rhythm_run: done|error|skipped.",
      "type": "string"
    },
    "targetSpec": {
      "description": "tracker: replaces the whole target spec; shape as penny_write.",
      "type": "object"
    },
    "taskId": {
      "description": "entityType:\"task\" (required) — the task to update.",
      "type": "string"
    },
    "title": {
      "description": "entityType:\"task\"/\"heading\" — the title/label.",
      "type": "string"
    },
    "trackerId": {
      "description": "entityType:\"tracker\" (required) — the tracker to update. Only the fields you pass are patched — omit any you don't want to change.",
      "type": "string"
    },
    "trigger": {
      "description": "entityType:\"skill\": optional (required for rhythm). Omit to return to on-demand. MyPenny does not run it; the connected agent receives due signals. See penny_write for shape; ALWAYS set IANA timezone, default UTC.",
      "type": "object"
    },
    "unit": {
      "description": "entityType:\"tracker\" — unit of measure.",
      "type": "string"
    },
    "updates": {
      "description": "entityType:\"note\" — patch or supersede existing notes (up to 100).",
      "items": {
        "properties": {
          "content": {
            "description": "Required when mode is \"patch\".",
            "type": "string"
          },
          "expectedUpdatedAt": {
            "type": "number"
          },
          "memoryId": {
            "type": "string"
          },
          "mode": {
            "enum": [
              "patch",
              "replace"
            ],
            "type": "string"
          },
          "supersededBy": {
            "description": "Required when mode is \"replace\" — the id of the note that replaces this one.",
            "type": "string"
          },
          "tags": {
            "items": {
              "type": "string"
            },
            "type": "array"
          }
        },
        "required": [
          "memoryId",
          "mode"
        ],
        "type": "object"
      },
      "maxItems": 100,
      "type": "array"
    },
    "whenAt": {
      "description": "entityType:\"task\"/\"project\" — schedule date (ms epoch).",
      "type": "number"
    },
    "whenBucket": {
      "description": "entityType:\"task\"/\"project\" — undated bucket; mutually exclusive with whenAt.",
      "enum": [
        "anytime",
        "someday"
      ],
      "type": "string"
    }
  },
  "required": [
    "entityType"
  ]
}

Move to Trash. Project: projectId + expectedRevision + operationId; penny_edit op:restore recovers. Repeat in_progress with the same operationId; report partial_recovery conflicts. Note/tracker_entry: ids (max100); skill/rhythm: one id; profile_block: ids are block names. Tag/link removal uses the identifiers below. Tasks are canceled via penny_edit; tracker definitions are archived, not deleted.

{
  "type": "object",
  "properties": {
    "entityType": {
      "description": "What to trash.",
      "enum": [
        "project",
        "note",
        "tracker_entry",
        "rhythm",
        "skill",
        "profile_block",
        "tag_relation",
        "tracker_note_link"
      ],
      "type": "string"
    },
    "expectedRevision": {
      "type": "number"
    },
    "ids": {
      "description": "entityType:\"note\"/\"tracker_entry\" — ids to trash (max 100); \"rhythm\"/\"skill\" — exactly one id; \"profile_block\" — block names to trash.",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "noteIds": {
      "description": "entityType:\"tracker_note_link\" (required) — the notes to unlink.",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "operationId": {
      "type": "string"
    },
    "projectId": {
      "type": "string"
    },
    "scope": {
      "description": "Profile block scope; Project private overrides defaults, workspace requires workspaceId.",
      "enum": [
        "global",
        "workspace",
        "private"
      ],
      "type": "string"
    },
    "tagA": {
      "description": "entityType:\"tag_relation\" (required) — one endpoint of the edge to remove.",
      "type": "string"
    },
    "tagB": {
      "description": "entityType:\"tag_relation\" (required) — the other endpoint.",
      "type": "string"
    },
    "trackerEntryId": {
      "description": "entityType:\"tracker_note_link\" (required) — the entry to detach notes from.",
      "type": "string"
    }
  },
  "required": [
    "entityType"
  ]
}