From 90a0881a2a7863149fd8c35d59eb0d5f63de6307 Mon Sep 17 00:00:00 2001 From: Peyton-Spencer Date: Fri, 6 Nov 2026 23:10:09 -0500 Subject: [PATCH 1/2] feat(skills): keep coding-agent steps out of the chat path Regenerate from ditto-assistant/ditto-skills#18 (bda49c1). Every SKILL.md now works in a chat app; shell, git, disk and deploy steps move to each skill's references/coding-agent.md behind a gate chat hosts skip. handoff in Chat/Cowork is note, save, readback, close. Docs updated to match. Co-Authored-By: Claude Opus 5.5 --- .kimi-plugin/plugin.json | 2 +- docs/handoff.md | 13 +- plugins/ditto/.antigravity-plugin/plugin.json | 2 +- plugins/ditto/.claude-plugin/plugin.json | 2 +- plugins/ditto/.codex-plugin/plugin.json | 2 +- plugins/ditto/.cursor-plugin/plugin.json | 2 +- plugins/ditto/.github/plugin/plugin.json | 2 +- plugins/ditto/.grok-plugin/plugin.json | 2 +- plugins/ditto/.kimi-plugin/plugin.json | 2 +- plugins/ditto/.openai-plugin/plugin.json | 2 +- plugins/ditto/README.md | 14 +- plugins/ditto/shared-skills.lock.json | 19 +- plugins/ditto/skills/code-review/SKILL.md | 20 +- .../code-review/references/coding-agent.md | 13 ++ plugins/ditto/skills/diagnose-bug/SKILL.md | 31 +-- .../diagnose-bug/references/coding-agent.md | 15 ++ plugins/ditto/skills/handoff/SKILL.md | 191 ++++++++---------- .../skills/handoff/references/coding-agent.md | 53 +++++ .../handoff/references/workspace-cleanup.md | 3 +- plugins/ditto/skills/tdd/SKILL.md | 29 +-- .../skills/tdd/references/coding-agent.md | 16 ++ plugins/ditto/skills/verify-done/SKILL.md | 21 +- .../verify-done/references/coding-agent.md | 19 ++ 23 files changed, 298 insertions(+), 177 deletions(-) create mode 100644 plugins/ditto/skills/code-review/references/coding-agent.md create mode 100644 plugins/ditto/skills/diagnose-bug/references/coding-agent.md create mode 100644 plugins/ditto/skills/handoff/references/coding-agent.md create mode 100644 plugins/ditto/skills/tdd/references/coding-agent.md create mode 100644 plugins/ditto/skills/verify-done/references/coding-agent.md diff --git a/.kimi-plugin/plugin.json b/.kimi-plugin/plugin.json index c397e63..7d67201 100644 --- a/.kimi-plugin/plugin.json +++ b/.kimi-plugin/plugin.json @@ -1,6 +1,6 @@ { "name": "ditto", - "version": "0.4.0", + "version": "0.4.1", "author": { "name": "Omni Aura LLC", "email": "support@heyditto.ai", diff --git a/docs/handoff.md b/docs/handoff.md index 9a975d0..ba9c07c 100644 --- a/docs/handoff.md +++ b/docs/handoff.md @@ -19,8 +19,11 @@ identified fresh UI control if one exists. If it does not, retain the verified memory and report manual closeout; do not equate exiting Code, deleting a chat or removing a transcript file with archival. -Chat without authorized local tools cannot measure or clean the Mac. Code/Cowork -local capabilities depend on actual grants. Follow the bundled cleanup reference: -inventory owned paths, verify pushed code/PR state and unique/ignored file recovery, -keep active/shared/pinned work safe, and require exact cleanup authorization. -No hooks, automatic capture, new MCP tools or public tool grants are added. +In Chat and Cowork the handoff is four steps: write the note, save it, read it +back, and archive the chat or say how to. It does not inspect tools, files, disk, +git or processes. Claude Code (or another coding agent with a local workspace) +also reads the skill's `references/coding-agent.md`: it records repository, +branch and commit state, makes code recoverable, and follows the bundled cleanup +reference only with exact cleanup authorization, keeping active, shared and +pinned work safe. No hooks, automatic capture, new MCP tools or public tool +grants are added. diff --git a/plugins/ditto/.antigravity-plugin/plugin.json b/plugins/ditto/.antigravity-plugin/plugin.json index 6ac24ca..10e3630 100644 --- a/plugins/ditto/.antigravity-plugin/plugin.json +++ b/plugins/ditto/.antigravity-plugin/plugin.json @@ -2,7 +2,7 @@ "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json", "name": "ditto", "displayName": "Ditto", - "version": "0.4.0", + "version": "0.4.1", "description": "Ditto memory through hosted MCP, with 20 skills for life, business and engineering: recall and save context, keep decisions, meetings and weekly reviews, debug, test and review code, plan days, trips and meals, curate music, and hand off chats. Archival and owned workspace cleanup depend on host capabilities and authorization. Sign in through Antigravity.", "logo": "assets/icon.png", "suggestedPrompts": [ diff --git a/plugins/ditto/.claude-plugin/plugin.json b/plugins/ditto/.claude-plugin/plugin.json index 6c1efb8..1d88f14 100644 --- a/plugins/ditto/.claude-plugin/plugin.json +++ b/plugins/ditto/.claude-plugin/plugin.json @@ -1,7 +1,7 @@ { "$schema": "https://anthropic.com/claude-code/plugin.schema.json", "name": "ditto", - "version": "0.4.0", + "version": "0.4.1", "description": "Ditto memory through hosted MCP, with 20 skills for life, business and engineering: recall and save context, keep decisions, meetings and weekly reviews, debug, test and review code, plan days, trips and meals, curate music, and hand off chats. Archival and owned workspace cleanup depend on host capabilities and authorization. Sign in through Claude.", "author": { "name": "Omni Aura LLC", diff --git a/plugins/ditto/.codex-plugin/plugin.json b/plugins/ditto/.codex-plugin/plugin.json index 9ddb272..93ce72f 100644 --- a/plugins/ditto/.codex-plugin/plugin.json +++ b/plugins/ditto/.codex-plugin/plugin.json @@ -1,6 +1,6 @@ { "name": "ditto", - "version": "0.4.0", + "version": "0.4.1", "author": { "name": "Omni Aura LLC", "email": "support@heyditto.ai", diff --git a/plugins/ditto/.cursor-plugin/plugin.json b/plugins/ditto/.cursor-plugin/plugin.json index d509960..25bc326 100644 --- a/plugins/ditto/.cursor-plugin/plugin.json +++ b/plugins/ditto/.cursor-plugin/plugin.json @@ -2,7 +2,7 @@ "name": "ditto", "displayName": "Ditto", "description": "Ditto memory through hosted MCP, with 20 skills for life, business and engineering: recall and save context, keep decisions, meetings and weekly reviews, debug, test and review code, plan days, trips and meals, curate music, and hand off chats. Archival and owned workspace cleanup depend on host capabilities and authorization. Sign in through Cursor.", - "version": "0.4.0", + "version": "0.4.1", "author": { "name": "Omni Aura LLC", "email": "support@heyditto.ai" diff --git a/plugins/ditto/.github/plugin/plugin.json b/plugins/ditto/.github/plugin/plugin.json index d0eb85b..06a8251 100644 --- a/plugins/ditto/.github/plugin/plugin.json +++ b/plugins/ditto/.github/plugin/plugin.json @@ -1,6 +1,6 @@ { "name": "ditto", - "version": "0.4.0", + "version": "0.4.1", "displayName": "Ditto", "description": "Ditto memory through hosted MCP, with 20 skills for life, business and engineering: recall and save context, keep decisions, meetings and weekly reviews, debug, test and review code, plan days, trips and meals, curate music, and hand off chats. Archival and owned workspace cleanup depend on host capabilities and authorization. Sign in through GitHub Copilot.", "author": { diff --git a/plugins/ditto/.grok-plugin/plugin.json b/plugins/ditto/.grok-plugin/plugin.json index a308461..62c039b 100644 --- a/plugins/ditto/.grok-plugin/plugin.json +++ b/plugins/ditto/.grok-plugin/plugin.json @@ -1,6 +1,6 @@ { "name": "ditto", - "version": "0.4.0", + "version": "0.4.1", "author": { "name": "Omni Aura LLC", "email": "support@heyditto.ai", diff --git a/plugins/ditto/.kimi-plugin/plugin.json b/plugins/ditto/.kimi-plugin/plugin.json index c3c0cee..2873de6 100644 --- a/plugins/ditto/.kimi-plugin/plugin.json +++ b/plugins/ditto/.kimi-plugin/plugin.json @@ -1,6 +1,6 @@ { "name": "ditto", - "version": "0.4.0", + "version": "0.4.1", "author": { "name": "Omni Aura LLC", "email": "support@heyditto.ai", diff --git a/plugins/ditto/.openai-plugin/plugin.json b/plugins/ditto/.openai-plugin/plugin.json index ad42873..318d820 100644 --- a/plugins/ditto/.openai-plugin/plugin.json +++ b/plugins/ditto/.openai-plugin/plugin.json @@ -1,7 +1,7 @@ { "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json", "name": "ditto", - "version": "0.4.0", + "version": "0.4.1", "description": "Ditto memory for everyday life, business and engineering: recall and save memories, keep decisions and meetings, plan weeks, trips and meals, debug, test and review code, and hand off chats.", "extensions": { "com.openai": { diff --git a/plugins/ditto/README.md b/plugins/ditto/README.md index 1c84d40..fe0a7e6 100644 --- a/plugins/ditto/README.md +++ b/plugins/ditto/README.md @@ -56,10 +56,16 @@ a relaxed evening, with a few discoveries." Use `/handoff` for verified private continuation notes and supported host archival, including explicitly selected -bulk closeout. Disk assessment requires local tools; cleanup requires exact -authority and verified code/file recovery. A memory summary is not a file backup. -If this host cannot archive, the skill saves the handoff and explains the manual -closeout step. Exiting a CLI session is not an archive operation. +bulk closeout. In a chat app it only writes the note, saves it, reads it back +and closes the chat. Coding agents with a local workspace also make code +recoverable and, with exact authority, clean up their own files; those steps +live in the skill's `references/coding-agent.md`. A memory summary is not a file +backup. If this host cannot archive, the skill saves the handoff and explains the +manual closeout step. Exiting a CLI session is not an archive operation. + +Every skill works in a chat app. Steps that need a shell, such as git, test +runners, disk checks and deploy probes, sit in a skill's +`references/coding-agent.md`, which chat hosts skip. The plugin respects your current instructions, private capture preferences, source authorship and actual tool grants. The plugin does not automatically save diff --git a/plugins/ditto/shared-skills.lock.json b/plugins/ditto/shared-skills.lock.json index 85fb5c4..f25df3d 100644 --- a/plugins/ditto/shared-skills.lock.json +++ b/plugins/ditto/shared-skills.lock.json @@ -1,32 +1,37 @@ { "schema_version": 1, "source_repository": "https://github.com/ditto-assistant/ditto-skills", - "source_commit": "8c61acf273526bd5c0bb9b4648b1091354dcd56f", + "source_commit": "bda49c1d98798fcb600e2c5c99cd22ea14a491f8", "host": "plugins", "core_sha256": "5912af5483c469ec15db27858122fc9128fc25cd239202c0fdd9727de7dd5f6b", "adapter_sha256": "7cd895ab3feb0581e7e782de46b8b8220e4281a9ebfe6f6b651753e3a545bac1", "generator_sha256": "210bce4b3167244d234ee0cc0e5adf771a72ce78a99675ad9dcf103969018d12", "skill_sha256": "dc4a46fc6de30ceac400ced65b122895738757cdcdaf1be529d63bec165e5835", "files_sha256": { - "plugins/ditto/skills/code-review/SKILL.md": "6696e1a3d3887ad8d5e115e463d1ad0f5652db3032ad9d425584460c0dbe4a76", + "plugins/ditto/skills/code-review/SKILL.md": "7d14eeb3b40ed330ad2dd4078a545d4539c96242bcd9f1ce1e130eb2bac0dd9f", + "plugins/ditto/skills/code-review/references/coding-agent.md": "6bdadaf39fd80e797236e4f429b655c8563f3451cb490f975e0e4d89f28df6f5", "plugins/ditto/skills/curate-music/SKILL.md": "b498f8639aeb64e59f88830ac162a894f9f128b7e1f2db6a7c528092904c1eb4", "plugins/ditto/skills/curate-music/references/youtube-music.md": "e763797cc7821114682c7b92cec6919e6f957792cdc54756f670c7086b09e52c", "plugins/ditto/skills/daily-brief/SKILL.md": "aa4b1398e2b1fb1ad0b6588ff92e44e07b96316204544429c7582f56828e6dfd", "plugins/ditto/skills/decision-log/SKILL.md": "fe131adeab044ebef9ec0d98be607629cdf7acf27b65d344ac6a01b333a52985", - "plugins/ditto/skills/diagnose-bug/SKILL.md": "b1899c41cc9362b41fbe5bd069352cb1ddc8e209bb9e33e0558fd0aef29b3ab6", + "plugins/ditto/skills/diagnose-bug/SKILL.md": "a8209a3c7adab8925c520586353eda235ef44663c17ebfc2025156ef7f221f29", + "plugins/ditto/skills/diagnose-bug/references/coding-agent.md": "cf3a3daa29e74731e9c3763130c979bae73922229ec22f018d9c280c08962719", "plugins/ditto/skills/gift-ideas/SKILL.md": "f8c60204bb8fb8156e1a6d2e7130009a905d6cb2b3dfecf5098f1983b58b1db1", "plugins/ditto/skills/grill-me/SKILL.md": "14e9e774d33286f0a51fc8521dd9ed479e7eccbd5567697da3a6586b8564cf2a", - "plugins/ditto/skills/handoff/SKILL.md": "84624fa46d8740f0dc0a26055dd427be5aa664edeac5193542b256ca2c3b733d", - "plugins/ditto/skills/handoff/references/workspace-cleanup.md": "be4d5ec45fdaf7ed5a16c00bec7b013a61b86f26084cfaeddc39f430c4c92a53", + "plugins/ditto/skills/handoff/SKILL.md": "7ff62ccbee9bac8359db9af178f295b4398e81983c4ccb915d7e4927b379d334", + "plugins/ditto/skills/handoff/references/coding-agent.md": "da33714119762443fc0aee9633c5da828e9367f650a304c438ec486c94f97a4d", + "plugins/ditto/skills/handoff/references/workspace-cleanup.md": "43feda4be882ce38e165fdc8ae650cc32a645a39cb3910241d526ff6e8b91f76", "plugins/ditto/skills/launch-post/SKILL.md": "1c634996254a9a48df0b3f6ec8ae8aa094231286927686bccb82354a06b90307", "plugins/ditto/skills/learn-anything/SKILL.md": "997550bbdb5354c2e0e95ad358a69bd5a3f2209f22a401c1eac64bfbb9a6d9f0", "plugins/ditto/skills/plan-meals/SKILL.md": "ca6959b54c5008e23c902c1cc8785fc63047f78988ed334bdc94fd46ccda8787", "plugins/ditto/skills/plan-trip/SKILL.md": "ed7aac4da4219030b40f50ecbfd726fa3adbf85042387a608f0b0c90984caf3e", "plugins/ditto/skills/prep-meeting/SKILL.md": "13e49ec46686cee975fb3ab13fc86c8de01378e4a749415efdc0ba9efb08f83a", "plugins/ditto/skills/research-brief/SKILL.md": "3fa3d9c865b48f7d3a6aa76e5570619983afb8adac783e56c6c9a4438ad31780", - "plugins/ditto/skills/tdd/SKILL.md": "95dcdd4fc7eab08662a8cf37ce10efc26aafde87eda94c714e9c66977fc9ee18", + "plugins/ditto/skills/tdd/SKILL.md": "041fd8a54d1abb754a1cbf05ae83bb879e07321977fc3e244c11ca66837d30a2", + "plugins/ditto/skills/tdd/references/coding-agent.md": "539a6e52b337f30e9cd458a4dede97e368a4f0c7fadf142a7db3f738e213e457", "plugins/ditto/skills/tidy-memory/SKILL.md": "496c0cbeabb76e4874f106f91ec14221b80c8111e28af814daa36c52487ea7f9", - "plugins/ditto/skills/verify-done/SKILL.md": "5cd669a2157d9723c19449571aafc8cbe880a42bf54bc7a72e5119f9318c858c", + "plugins/ditto/skills/verify-done/SKILL.md": "905647d40b04d167d7286c02c001e0107b7aa704f7cdaa4c8042d56d9bc6301d", + "plugins/ditto/skills/verify-done/references/coding-agent.md": "ed7e11eff722a493470989622b3e681e3f9f41e129a60deb38aacddcdeb43d80", "plugins/ditto/skills/weekly-review/SKILL.md": "efecbfcc90f68222ce1072272063a4ea7111a69bc636f0273814bc060aaa8753", "plugins/ditto/skills/write-spec/SKILL.md": "3d93adbf733f71dc14cbbf07f98865c766fcc4c837d1e01e3785978e630dad1d" } diff --git a/plugins/ditto/skills/code-review/SKILL.md b/plugins/ditto/skills/code-review/SKILL.md index 7780b23..6e36671 100644 --- a/plugins/ditto/skills/code-review/SKILL.md +++ b/plugins/ditto/skills/code-review/SKILL.md @@ -9,15 +9,20 @@ Find the problems that would hurt users or maintainers, and say each one so the author can act on it. Correctness first, clarity second, style last. Use the bundled `ditto-memory` skill for connection, recall and capture rules. +If this host gives you a local shell and the change is in a repository you can +open, also read [coding-agent.md](references/coding-agent.md). In a chat app, +skip it and review what the user shares. ## Gather context -Read the full diff and enough surrounding code to understand each change. Read -the description or linked issue to learn the intent. Search Ditto for the team's -review conventions, past review decisions about this area and known pitfalls; a -convention the team agreed on outranks your personal preference. Compare against -the branch the change will merge into, not an older one, or you will review -someone else's work. +Review the diff the user pasted, uploaded or linked through a connected tool, +with as much surrounding code as you can see. Read the description or linked +issue to learn the intent. Search Ditto for the team's review conventions, past +review decisions about this area and known pitfalls; a convention the team +agreed on outranks your personal preference. If a finding depends on code you +cannot see, ask for that file or mark the finding as a question rather than +guessing. Say whether each issue is new in this change or already in the code it +modifies; when the shared context cannot tell, say so. ## Review in passes @@ -34,8 +39,7 @@ someone else's work. For each candidate finding, trace the actual code path and try to construct the failing input. Drop findings you cannot support. Mark a finding as a question -when you are unsure. Check whether an issue is new in this change or already on -the base branch, and say which. +when you are unsure. ## Report diff --git a/plugins/ditto/skills/code-review/references/coding-agent.md b/plugins/ditto/skills/code-review/references/coding-agent.md new file mode 100644 index 0000000..001978b --- /dev/null +++ b/plugins/ditto/skills/code-review/references/coding-agent.md @@ -0,0 +1,13 @@ +# Code review: coding-agent additions + +Read this only when you have a local shell and the change is in a repository you +can open. In a chat app, skip it. + +- Build the diff yourself against the merge base of the branch the change will + merge into, not an older branch, or you will review someone else's work. +- Read whole files around each hunk, plus callers and tests of what changed. +- Check whether each issue is new in this change or already on the base branch, + and say which. +- Run the project's own tests, type checker or linter when that is cheap and + confirms or refutes a finding. Use the commands the repository documents. +- Do not edit, commit or push while reviewing unless the user asks for fixes. diff --git a/plugins/ditto/skills/diagnose-bug/SKILL.md b/plugins/ditto/skills/diagnose-bug/SKILL.md index 3526d68..7cd3399 100644 --- a/plugins/ditto/skills/diagnose-bug/SKILL.md +++ b/plugins/ditto/skills/diagnose-bug/SKILL.md @@ -5,10 +5,13 @@ description: Find the root cause of a bug or slowdown with a reproduce-and-test # Diagnose a bug -Find the cause before changing code. A fix without a cause is a guess, and a +Find the cause before changing anything. A fix without a cause is a guess, and a guess that happens to make the symptom disappear is the most expensive kind. Use the bundled `ditto-memory` skill for connection, recall and capture rules. +If this host gives you a local shell and the code is in a repository you can +run, also read [coding-agent.md](references/coding-agent.md). In a chat app, +skip it: the user runs each step and shares the result with you. ## 1. Recall @@ -19,31 +22,33 @@ can save hours. Treat a recalled cause as a hypothesis to test, not an answer. ## 2. Reproduce Get a reliable reproduction before anything else: the smallest input, command or -sequence that shows the failure. Record the exact environment (versions, branch, -data, flags). If the bug is intermittent, measure how often it happens so you can -later tell a fix from luck. If you cannot reproduce it, say so and gather -evidence (logs, traces, the user's exact steps) instead of guessing. +sequence that shows the failure, with the exact environment (versions or +branch, data, settings). If the bug is intermittent, find out how often it +happens so a fix can later be told from luck. If it cannot be reproduced, say so and gather evidence +(logs, screenshots, the user's exact steps) instead of guessing. When the user is +the one running things, give one exact step at a time and ask for its output. ## 3. Hypothesize and test List the candidate causes and, for each, the observation that would rule it in or out. Test the cheapest discriminating one first. Change one thing at a time. Prefer evidence that can fail: a log line that would show a different value, a -bisect between a known-good and known-bad version, a stripped-down test case. +comparison between a known-good and known-bad version, a stripped-down case. A check that could only ever pass proves nothing. When a hypothesis survives, confirm it from both sides: the failure appears when -you introduce the cause, and disappears when you remove it. +the cause is introduced, and disappears when it is removed. ## 4. Fix and guard Fix the cause, not the symptom. Add a regression test that fails on the unfixed -code and passes on the fixed code; run it both ways. Remove temporary -instrumentation. If the fix is a workaround, say so plainly. +version and passes on the fixed one, and see it run both ways (in a chat app, +ask the user to run it before and after the fix). Remove any temporary logging added +to test hypotheses. If the fix is a workaround, say so plainly. ## 5. Report and remember -Report the symptom, root cause, evidence, fix and remaining risk, keeping what you -observed separate from what you inferred. Offer to save the incident to Ditto -(symptom, cause, fix, how it was found) so the next occurrence starts from it. -Save only when the user agrees, and exclude secrets and customer data. +Report the symptom, root cause, evidence, fix and remaining risk, keeping what +was observed separate from what you inferred. Offer to save the incident to +Ditto (symptom, cause, fix, how it was found) so the next occurrence starts from +it. Save only when the user agrees, and exclude secrets and customer data. diff --git a/plugins/ditto/skills/diagnose-bug/references/coding-agent.md b/plugins/ditto/skills/diagnose-bug/references/coding-agent.md new file mode 100644 index 0000000..35f475c --- /dev/null +++ b/plugins/ditto/skills/diagnose-bug/references/coding-agent.md @@ -0,0 +1,15 @@ +# Diagnose a bug: coding-agent additions + +Read this only when you have a local shell and can run the code. In a chat app, +skip it. + +- Run the reproduction yourself and record the command, branch, commit, data + and flags. For an intermittent failure, run it enough times to state a rate. +- Use `git bisect` (or a manual binary search over commits) between a + known-good and known-bad version when the regression window is unclear. +- Add temporary logging or assertions to discriminate hypotheses, and remove + them before you finish. +- Write the regression test in the project's existing test setup and run it + both ways: red on the unfixed code, green on the fix. +- Reproduce a suspected regression on the base branch in a separate checkout + before believing your own change caused it. diff --git a/plugins/ditto/skills/handoff/SKILL.md b/plugins/ditto/skills/handoff/SKILL.md index 71ea10b..b683845 100644 --- a/plugins/ditto/skills/handoff/SKILL.md +++ b/plugins/ditto/skills/handoff/SKILL.md @@ -1,118 +1,91 @@ --- name: handoff -description: Save verified continuation context to Ditto before closing one or more authorized chats, and assess safe cleanup of the agent's own workspace and build artifacts when disk space matters. +description: Save a verified continuation note to Ditto so the next conversation can pick up the work, then close the chat where the host supports it. --- # Handoff -Preserve useful context, make code and files recoverable, and close out only the -authorized chats. Use `/handoff` where supported, or invoke this skill by name. -A draft or summary request alone does not authorize saving or archival. A full -handoff request authorizes private save and archival of the invoking chat; an -explicit bulk request covers only the selected set. It does not itself authorize -file deletion, messages to other chats, merging, deployment or ongoing capture. - -## Establish scope and capabilities - -Finish already-authorized work or record its blocker. Identify the invoking chat -from trusted host context, never recency or a similar title. For bulk requests, -inventory the selected set with stable host IDs, status and exclusion reasons. -Keep active, shared, pinned and unresolved recovery work unless explicitly -selected by the user and its remaining work can be preserved. Start with one -chat at a time; use concurrency only for an explicitly requested bounded batch. -Do not dispatch messages to every chat merely to gather handoffs. - -Inspect available tools and fresh UI state. Ditto MCP stores the note; host tools -or UI manage host chats and local workspaces. Do not invent archive APIs, edit -host databases or count exiting a CLI as archival. Browser-only ChatGPT cannot -inspect or delete local files without a suitable authorized local filesystem or -computer tool. Disclose missing capabilities and continue independent steps. -Missing local inspection does not block an otherwise verified save and archive. -Preserve MCP and host-managed sign-in; do not install shell memory helpers, -new hooks or transcript capture. - -## Preserve the continuation and assess disk - -Write a concise note containing: - -* Objective, durable decisions, constraints and scope of authorization. -* Completed work with exact issue, PR, source, artifact and commit references; - repository, branch and workspace paths needed to resume or recover. -* Validation evidence, separating source, merge, distribution, installation, - deployment and actual functional behavior. Preserve limitations and failures. -* Open work, owners, blockers, approvals and concrete recovery/next steps. -* Disk inventory and cleanup disposition: measured candidates, preserved files, - recovery locations, owned processes, approved actions and deferrals with reasons. - -Disk pressure is a core closeout concern, especially on machines with recurring -low space. With authorized local inspection, measure free space and the agent's -own task/worktree and temporary builds before deciding what to reclaim. Read -[workspace-cleanup.md](references/workspace-cleanup.md) before filesystem cleanup. -If inspection is unavailable, record that rather than inventing a measurement. -Archiving a chat does not establish that disk space was reclaimed. - -Use current evidence; exclude transcripts, credentials and unnecessary sensitive -details. Mark outstanding archival/cleanup as pending. A memory summary is not -a backup of code or files. +Write down what the next conversation needs, save it to Ditto, check that it +saved, then close the chat. Use `/handoff` where supported, or invoke this skill +by name. Keep it quick: a handoff is a short note, not an audit. + +A draft or summary request alone does not authorize saving or closing anything. +A full handoff request authorizes a private save and archival of the invoking +chat. It does not authorize deleting files, messaging other chats, merging, +deploying or ongoing capture. + +## Which path + +- **Chat app** (Claude chat, ChatGPT, Cowork or any host without a local shell + or repository): follow this file only. Work from the conversation itself. Do + not inventory tools, inspect files, measure disk, check git or look for + processes, and do not mention them in the note. +- **Coding agent** (Claude Code, Codex CLI, Cursor or any host with a local + shell): follow this file. When the chat touched a repository or local files, + also read [coding-agent.md](references/coding-agent.md) for workspace recovery + and cleanup; otherwise treat it like a chat app. + +## Write the note + +Keep it concise and current: + +- Objective, durable decisions, constraints and what was authorized. +- What was done, with the exact links and references from the conversation: + documents, issues, tickets, messages, files shared. +- Evidence that it worked, kept separate from what was only planned, drafted or + assumed. Keep limitations and failures. +- Open work, owners, blockers, pending approvals and the concrete next step. + +Exclude transcripts, credentials and unnecessary sensitive details. A memory +note is not a backup of files or code. ## Save and verify through Ditto -Use bundled `ditto-memory` guidance and live MCP schemas. Verify the intended -account/private destination before writing. Use a known memory ID or search for -an existing handoff for this host/chat. Where supported, use a stable identity -derived from the host and actual chat ID, such as `handoff::`. -Never fabricate an ID or URL. Update an owned matching record rather than -duplicating it; do not rewrite another author's record. - -Save the note, inspect the receipt, then fetch its full content by returned ID. -Compare all intended content and critical references with the draft; a receipt, -title, search snippet or successful fetch alone is insufficient. Verify every -part if size limits require splitting. Search indexing may lag. If a write times -out, reconcile by returned ID or supported stable identity before retrying; -do not blindly repeat it. If ambiguity remains, stop that item's closeout. - -If save or exact readback fails, leave that chat open and preserve code/files. -Return the draft and the specific failure. Never put private handoffs in the -skill repository or plugin package. A local note is not the Ditto save gate. - -## Reclaim only authorized material - -After successful readback, perform only cleanup already authorized for exact -owned candidates and passing the cleanup reference's preservation or discard gates. Otherwise -present the measured scope for approval and retain the files. Archiving chats -does not authorize deleting their workspaces. Cleanup failure does not invalidate -a verified memory: report it separately and preserve a usable recovery path. -Direct deletion without a recovery archive is a valid user choice. When the user -asks to just delete, do not make an archive or backup a prerequisite. Verify -remote durability for code being retained and identify any unique local material -being discarded; do not infer permission to discard it from a memory summary. -Save material cleanup outcomes/recovery locations into the handoff and verify -that update before archiving. - -## Archive and record receipts - -Prefer a documented implicit-current-chat archive operation. Other targets need -a trusted stable ID and explicit selection. If tools are absent, use supported -UI only when fresh state identifies the exact chat and archive action. If neither -is available, retain the saved handoff, report `archive unsupported`, and give -the manual host closeout step. Never claim archival from memory save. - -For each selected chat keep a receipt with host/chat identity, memory IDs, -readback result, archive result and cleanup result/bytes or deferral reason. -Distinguish `saved and verified`, `already archived`, `archive failed`, -`unsupported`, `save uncertain` and `readback failed`. On retries, reconcile both -the memory and current archive state; do not duplicate or toggle blindly. -An already archived chat without a verified handoff remains a gap, not a success. -Leave failed items open when possible and continue independent selected items; -stop the batch for account mismatch, scope uncertainty or a user stop request. - -Before each archive, persist the known receipt state in that chat's verified -private handoff or an authorized private batch ledger, including the memory ID -and stable chat ID for restart. Keep post-archive receipts in the host or batch -ledger; never claim that the final self-archive result was saved beforehand. - -Complete tracker updates and expose recoverable receipts before archiving the -invoking chat, since that may end interaction. In bulk runs, process it last. -Archive each item only after its own save/readback gate. Inspect the archive -receipt or refreshed host state before reporting success; reconcile ambiguous -results before retrying. The invoking chat's archive is the final mutation. +Use the bundled `ditto-memory` guidance and the live MCP tool schemas. Check +that the connected account is the intended one. Search once for an existing +handoff for this chat; where the host exposes a real chat ID, use a stable +identity such as `handoff::`. Never invent an ID or URL. Update +your own matching record instead of duplicating it; never rewrite another +author's record. + +Save the note, then fetch it by the returned ID and check its content and key +references against the draft. If size limits split the note, fetch and check +every part. A receipt, title or search snippet alone is not verification; +search indexing may lag. If a save times out, reconcile by the +returned ID or stable identity before retrying rather than saving twice. + +If the save or readback fails, leave the chat open, give the user the draft and +the specific failure. A local file is not a substitute for the Ditto save, and +a private handoff never goes into a skill repository or plugin package. + +## Close the chat + +Close only after the readback passes. Use a documented archive operation for +the current chat when the host provides one. Otherwise use the host's own UI +only when you can see the exact chat and its archive action. If neither exists, +which is normal in chat apps, report the saved memory ID and tell the user to +archive the chat from the host's chat menu. Never claim the chat was archived +because the memory saved. Report `archived` only after the archive receipt or +refreshed host state shows it; reconcile an ambiguous result before retrying. + +Give the user the receipt before archiving, since archiving may end the +conversation: memory ID, readback result and the archive step about to run (or +`unsupported`, `already archived`, `readback failed` or `save uncertain` when +none will). If the conversation continues after the attempt, report `archived` +or `archive failed`; in a batch, record it in the batch ledger. Do not archive +an already archived chat again. +Archiving the invoking chat is the last action. + +## Several chats + +Close out more than one chat only when the user names the set. Identify each by +a stable host ID, never by recency or a similar title, and keep active, shared, +pinned or unfinished chats unless the user selects them. Do one chat at a time: +its own note, save, readback and archive, with a receipt per chat. Leave a chat +that fails open and continue with the other selected chats. Before each +archive, save that chat's memory ID and stable chat ID in its verified handoff +or an authorized private batch ledger, so an interrupted run can resume without +duplicating saves or toggling archives. Do not send messages to every chat just +to gather handoffs. An already archived chat with no +verified handoff is a gap, not a success. Stop the batch on an account mismatch, +scope doubt or the user's request, and process the invoking chat last. diff --git a/plugins/ditto/skills/handoff/references/coding-agent.md b/plugins/ditto/skills/handoff/references/coding-agent.md new file mode 100644 index 0000000..0ef7294 --- /dev/null +++ b/plugins/ditto/skills/handoff/references/coding-agent.md @@ -0,0 +1,53 @@ +# Handoff: coding-agent additions + +Read this only when the host gives you a local shell or filesystem and the chat +worked in a repository, task workspace or local files. In a chat app, skip it. +Everything here adds to the main skill; it does not replace its save, readback +and archive gates. + +## Add the workspace to the note + +Include what a later session needs to resume or recover the code: + +- repository, branch, workspace or worktree path, and exact commit SHAs; +- pull requests and CI runs with their state at the head you checked; +- validation evidence, keeping source, merge, deployment and live behaviour as + separate facts; +- owned processes still running (dev servers, builds), and why; +- the disk and cleanup disposition below, including anything deferred and why. + +Make code recoverable before you call it handed off. A memory note is not a +backup: code that exists only in an uncommitted or unpushed local checkout is +still at risk. Push or open a pull request only where the user or repository +rules already authorize it; a handoff alone grants neither. If that authority +or destination is missing, keep the checkout and say so in the note. + +## Disk + +Disk is a closeout concern when the machine is short of space or the task made +large builds. Only then, measure free space and the size of this task's own +workspace and temporary builds before deciding anything. If you cannot inspect +the filesystem, record that rather than inventing a number. Archiving a chat +does not reclaim disk and does not authorize deleting its workspace. + +Read [workspace-cleanup.md](workspace-cleanup.md) before deleting or archiving +any local files. + +## Reclaim only authorized material + +After the Ditto readback passes, perform only cleanup the user already +authorized for exact owned paths that pass the cleanup reference's gates. +Otherwise present the measured candidates, sizes and plan, and keep the files. +Direct deletion without a backup is a valid user choice; do not force an +archive on a user who asked to just delete. Identify any unique local material +before it is discarded. + +A cleanup failure does not invalidate a verified memory: report it separately +and keep a usable recovery path. Save the cleanup outcome and recovery locations +into the handoff and verify that update before archiving the chat. + +## Receipts + +Add the cleanup result (bytes reclaimed, or the deferral reason) to each chat's +receipt. Do not install shell memory helpers, new hooks or transcript capture +as part of a handoff. diff --git a/plugins/ditto/skills/handoff/references/workspace-cleanup.md b/plugins/ditto/skills/handoff/references/workspace-cleanup.md index e1b742b..242839a 100644 --- a/plugins/ditto/skills/handoff/references/workspace-cleanup.md +++ b/plugins/ditto/skills/handoff/references/workspace-cleanup.md @@ -1,6 +1,7 @@ # Owned workspace and build cleanup -Use this only with actual local inspection capabilities. A browser file upload +Reached from [coding-agent.md](coding-agent.md). Use this only with actual local +inspection capabilities. A browser file upload or cloud sandbox does not grant access to the user's Mac. Never substitute host transcript databases, plugin caches or arbitrary directories for an owned task workspace. Do not run a global cleanup sweep as a side effect of handoff. diff --git a/plugins/ditto/skills/tdd/SKILL.md b/plugins/ditto/skills/tdd/SKILL.md index f81c576..4c79e3a 100644 --- a/plugins/ditto/skills/tdd/SKILL.md +++ b/plugins/ditto/skills/tdd/SKILL.md @@ -9,27 +9,30 @@ Write the test that describes the behavior, watch it fail for the right reason, make it pass with the simplest change, then clean up. Repeat in small steps. Use the bundled `ditto-memory` skill for connection, recall and capture rules. +If this host gives you a local shell and a repository you can run, also read +[coding-agent.md](references/coding-agent.md). In a chat app, skip it: give the +user the test first and ask for the runner's red output, then the code and its +green output. ## Before starting Search Ditto for the project's testing conventions: the test runner and command, -fixture and mocking habits, and known traps. Then confirm them against the -repository itself; the repository wins when they disagree. Find the existing -test closest to what you are about to write and follow its shape. +fixture and mocking habits, and known traps. When the user shares an existing +test close to what you are about to write, follow its shape. Ask for one if the +project's conventions are unknown. ## The loop 1. **Red.** Write one test for one behavior, named for the behavior rather than - the implementation. Run it and read the failure. It must fail because the - behavior is missing, not because of a typo, an import error or a broken - fixture. -2. **Green.** Make the smallest change that passes. Run the whole relevant suite, - not only the new test. -3. **Refactor.** Remove duplication and improve names with the tests green. - Run them again after each change. - -Keep steps small enough that a failure points at the last change. Commit at -green when the user wants commits. + the implementation. It must fail because the behavior is missing, not because + of a typo, an import error or a broken fixture; read the failure to check. +2. **Green.** Make the smallest change that passes, then run the whole relevant + suite, not only the new test. +3. **Refactor.** Remove duplication and improve names with the tests green, and + run them again after each change. + +Keep steps small enough that a failure points at the last change. Never claim a +test went red or green unless you or the user actually saw that result. ## Tests that can fail diff --git a/plugins/ditto/skills/tdd/references/coding-agent.md b/plugins/ditto/skills/tdd/references/coding-agent.md new file mode 100644 index 0000000..8f7c0d8 --- /dev/null +++ b/plugins/ditto/skills/tdd/references/coding-agent.md @@ -0,0 +1,16 @@ +# TDD: coding-agent additions + +Read this only when you have a local shell and can run the project's tests. In a +chat app, skip it. + +- Confirm the remembered conventions against the repository: its documented + test command, runner configuration and the existing test closest to yours. + The repository wins when they disagree. +- Run each red and green step yourself and read the runner's summary line, not + only its exit code. +- A new test that went red against the missing behavior has already shown it + can fail. For a test that passed from the start, break the implementation + with a small temporary edit, watch the test go red, undo that edit and + confirm the diff is what you intended. Never use `git restore`, + `git checkout` or a stash over uncommitted work to do it. +- Commit at green only when the user wants commits. diff --git a/plugins/ditto/skills/verify-done/SKILL.md b/plugins/ditto/skills/verify-done/SKILL.md index 5661fc9..c7180d2 100644 --- a/plugins/ditto/skills/verify-done/SKILL.md +++ b/plugins/ditto/skills/verify-done/SKILL.md @@ -9,22 +9,27 @@ description: Check each claim before reporting work done: built, merged, deploye wrong answers come from letting one piece of evidence stand in for another. Use the bundled `ditto-memory` skill for connection, recall and capture rules. +If this host gives you a local shell and the work is in a repository, also read +[coding-agent.md](references/coding-agent.md) for the concrete checks. In a chat +app, skip it and check what the connected tools and the user can show you. ## Separate the claims Split the report into the claims it actually makes, and check each one: -- **Written:** the change exists in the files or document, in the right place. -- **Builds and tests pass:** at the exact version you are describing, from the - runner's own summary, not its exit code alone. -- **Reviewed and merged:** on the target branch, not only approved. -- **Deployed:** the running system serves this version. Read the version it - reports instead of assuming a pipeline succeeded. +- **Written:** the change exists in the file, document or draft, in the right + place. +- **Checked:** tests, builds or reviews passed for this exact version, read + from their own summary rather than a green badge. +- **Approved and landed:** on the target branch, published or sent, not only + approved or scheduled. +- **Live:** the running system or the published page serves this version. Read + what it reports instead of assuming a pipeline succeeded. - **Works:** someone exercised the behavior the user cares about, in the place they will use it. -Report each separately. Saying "merged" when you mean "works" is the failure -this skill exists to prevent. +Report each separately. Saying "merged" when you mean "works", or "scheduled" +when you mean "sent", is the failure this skill exists to prevent. ## Evidence that could have failed diff --git a/plugins/ditto/skills/verify-done/references/coding-agent.md b/plugins/ditto/skills/verify-done/references/coding-agent.md new file mode 100644 index 0000000..e01d21d --- /dev/null +++ b/plugins/ditto/skills/verify-done/references/coding-agent.md @@ -0,0 +1,19 @@ +# Verify done: coding-agent additions + +Read this only when you have a local shell and the work is in a repository. In a +chat app, skip it. + +- **Written:** `git status` and the full `git diff HEAD` (staged and unstaged) + show the change, and only the change, in the intended clone and branch. + Before claiming it is pushed, compare `git rev-parse HEAD` with + `git ls-remote origin `; a local tracking ref can be stale. +- **Checked:** read CI results attached to the current pull request head + commit, not an older run. A cancelled run can render as a failure, and a + required check that never started is not green. +- **Approved and landed:** the pull request state is merged and the merge + commit is on the target branch. With squash merges, branch ancestry alone + does not prove it. +- **Live:** read the version or build endpoint the running service exposes, + and compare it with the merge commit. +- Scripts that verify then commit need to stop on the first failure (for + example `set -e` in shell); otherwise a failed build can still be pushed. From 6cd00ab3275b1c37e24fd2d888d71e45919f5e0f Mon Sep 17 00:00:00 2001 From: Peyton-Spencer Date: Sat, 7 Nov 2026 00:15:36 -0500 Subject: [PATCH 2/2] chore(skills): lock to ditto-skills main f1b8c1b Co-Authored-By: Claude Opus 5.5 --- plugins/ditto/shared-skills.lock.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/plugins/ditto/shared-skills.lock.json b/plugins/ditto/shared-skills.lock.json index f25df3d..4064629 100644 --- a/plugins/ditto/shared-skills.lock.json +++ b/plugins/ditto/shared-skills.lock.json @@ -1,7 +1,7 @@ { "schema_version": 1, "source_repository": "https://github.com/ditto-assistant/ditto-skills", - "source_commit": "bda49c1d98798fcb600e2c5c99cd22ea14a491f8", + "source_commit": "f1b8c1bcd5f246dd497693a36fdafba5be23d080", "host": "plugins", "core_sha256": "5912af5483c469ec15db27858122fc9128fc25cd239202c0fdd9727de7dd5f6b", "adapter_sha256": "7cd895ab3feb0581e7e782de46b8b8220e4281a9ebfe6f6b651753e3a545bac1",