cclaw-cli 0.18.0 → 0.21.0

package/dist/constants.d.ts

@@ -7,6 +7,6 @@ export declare const DEFAULT_HARNESSES: HarnessId[];
 export declare const REQUIRED_DIRS: readonly [".cclaw", ".cclaw/commands", ".cclaw/skills", ".cclaw/contexts", ".cclaw/templates", ".cclaw/artifacts", ".cclaw/worktrees", ".cclaw/state", ".cclaw/runs", ".cclaw/rules", ".cclaw/adapters", ".cclaw/agents", ".cclaw/hooks", ".cclaw/custom-skills"];
 export declare const REQUIRED_GITIGNORE_PATTERNS: readonly ["# cclaw generated artifacts", ".cclaw/", ".claude/commands/cc-*.md", ".claude/commands/cc.md", ".cursor/commands/cc-*.md", ".cursor/commands/cc.md", ".opencode/commands/cc-*.md", ".opencode/commands/cc.md", ".codex/commands/cc-*.md", ".codex/commands/cc.md", ".claude/hooks/hooks.json", ".cursor/hooks.json", ".codex/hooks.json", ".opencode/plugins/cclaw-plugin.mjs", ".cursor/rules/cclaw-workflow.mdc"];
 export declare const COMMAND_FILE_ORDER: FlowStage[];
-export declare const UTILITY_COMMANDS: readonly ["learn", "next", "view", "status", "tree", "diff", "ops", "feature", "tdd-log", "retro", "archive", "rewind"];
+export declare const UTILITY_COMMANDS: readonly ["learn", "next", "ideate", "view", "status", "tree", "diff", "ops", "feature", "tdd-log", "retro", "compound", "archive", "rewind"];
 export declare const SUBAGENT_SKILL_FOLDERS: readonly ["subagent-dev", "parallel-dispatch"];
 export type UtilityCommand = (typeof UTILITY_COMMANDS)[number];

package/dist/constants.js

@@ -54,6 +54,7 @@ export const COMMAND_FILE_ORDER = [
 export const UTILITY_COMMANDS = [
     "learn",
     "next",
+    "ideate",
     "view",
     "status",
     "tree",
@@ -62,6 +63,7 @@ export const UTILITY_COMMANDS = [
     "feature",
     "tdd-log",
     "retro",
+    "compound",
     "archive",
     "rewind"
 ];

package/dist/content/compound-command.d.ts

@@ -0,0 +1,2 @@
+export declare function compoundCommandContract(): string;
+export declare function compoundCommandSkillMarkdown(): string;

package/dist/content/compound-command.js

@@ -0,0 +1,72 @@
+import { RUNTIME_ROOT } from "../constants.js";
+const COMPOUND_SKILL_FOLDER = "flow-compound";
+const COMPOUND_SKILL_NAME = "flow-compound";
+export function compoundCommandContract() {
+    return `# /cc-ops compound
+
+## Purpose
+
+Lift repeated lessons into durable project assets (rules, protocols, skills)
+so the next run is easier and safer.
+
+## HARD-GATE
+
+- Do not mutate rules/skills without explicit user approval.
+- Every proposal must cite concrete knowledge evidence (line references or IDs).
+- Keep scope focused: one compound change set per run.
+
+## Algorithm
+
+1. Read \`${RUNTIME_ROOT}/knowledge.jsonl\`.
+2. Cluster repeated trigger/action pairs.
+3. For clusters with frequency >= 3, propose one lift action:
+   - rule update
+   - protocol update
+   - utility skill update
+4. For each proposal include:
+   - why now
+   - target file(s)
+   - expected risk reduction
+5. Ask user approval for each proposal before writing.
+6. Apply approved lifts and record completion in retro artifact.
+
+## Primary skill
+
+**${RUNTIME_ROOT}/skills/${COMPOUND_SKILL_FOLDER}/SKILL.md**
+`;
+}
+export function compoundCommandSkillMarkdown() {
+    return `---
+name: ${COMPOUND_SKILL_NAME}
+description: "Compound mode: convert repeated learnings into durable rules/protocols/skills."
+---
+
+# /cc-ops compound
+
+## Announce at start
+
+"Using flow-compound to lift repeated learnings into durable workflow assets."
+
+## HARD-GATE
+
+No silent codification. Every lift requires explicit user approval.
+
+## Protocol
+
+1. Parse \`.cclaw/knowledge.jsonl\` and group repeated lessons.
+2. Keep only candidates with clear recurrence and actionable lift path.
+3. Propose each candidate using this template:
+
+\`\`\`
+Candidate: <short title>
+Evidence: <knowledge refs>
+Lift target: <rule/protocol/skill file>
+Change type: <add/update/remove>
+Expected benefit: <what regressions this prevents>
+\`\`\`
+
+4. Ask user to approve/reject per candidate.
+5. Apply only approved candidates.
+6. Append a \`compound\` learning entry summarizing what was lifted.
+`;
+}

package/dist/content/harnesses-doc.js

@@ -65,9 +65,10 @@ All harnesses receive the same utility commands:
 
 - \`/cc\` - flow entry and resume
 - \`/cc-next\` - stage progression
+- \`/cc-ideate\` - discovery mode for ranked repo-improvement backlog
 - \`/cc-view\` - read-only router for status/tree/diff
 - \`/cc-learn\` - knowledge capture/lookup
-- \`/cc-ops\` - operations router for feature/tdd-log/retro/archive/rewind
+- \`/cc-ops\` - operations router for feature/tdd-log/retro/compound/archive/rewind
 
 Read-only subcommands:
 - \`/cc-view status\` - visual flow snapshot
@@ -78,6 +79,7 @@ Operations subcommands:
 - \`/cc-ops feature ...\` - git-worktree feature isolation and routing
 - \`/cc-ops tdd-log ...\` - explicit RED/GREEN/REFACTOR evidence log
 - \`/cc-ops retro\` - mandatory retrospective gate before archive
+- \`/cc-ops compound\` - lift repeated learnings into durable rules/skills
 - \`/cc-ops archive\` - archive active run from harness flow
 - \`/cc-ops rewind ...\` - rewind flow and invalidate downstream stages
 - \`/cc-ops rewind --ack ...\` - clear stale stage markers after redo

package/dist/content/ideate-command.d.ts

@@ -0,0 +1,2 @@
+export declare function ideateCommandContract(): string;
+export declare function ideateCommandSkillMarkdown(): string;

package/dist/content/ideate-command.js

@@ -0,0 +1,73 @@
+import { RUNTIME_ROOT } from "../constants.js";
+const IDEATE_SKILL_FOLDER = "flow-ideate";
+const IDEATE_SKILL_NAME = "flow-ideate";
+export function ideateCommandContract() {
+    return `# /cc-ideate
+
+## Purpose
+
+Repository-improvement discovery mode. Generate a ranked backlog of high-value
+improvements before committing to a specific feature request.
+
+## HARD-GATE
+
+- This is discovery mode only. Do not start implementation automatically.
+- Every recommendation must include evidence from the current repository.
+- End with a decision prompt: pick one candidate or cancel.
+
+## Algorithm
+
+1. Scan repo signals:
+   - open TODO/backlog notes
+   - flaky or failing tests
+   - oversized modules / complexity hotspots
+   - docs drift vs changed code
+   - repeated learnings from \`.cclaw/knowledge.jsonl\`
+2. Produce 5-10 candidates with:
+   - impact (High/Medium/Low)
+   - effort (S/M/L)
+   - confidence (High/Medium/Low)
+   - evidence path(s)
+3. Rank candidates by impact/effort ratio.
+4. Present one recommendation as default.
+5. Ask user to choose:
+   - (A) start with recommended item
+   - (B) choose another candidate
+   - (C) cancel
+
+## Primary skill
+
+**${RUNTIME_ROOT}/skills/${IDEATE_SKILL_FOLDER}/SKILL.md**
+`;
+}
+export function ideateCommandSkillMarkdown() {
+    return `---
+name: ${IDEATE_SKILL_NAME}
+description: "Repository ideation mode: detect and rank high-leverage improvements before implementation."
+---
+
+# /cc-ideate
+
+## Announce at start
+
+"Using flow-ideate to identify highest-leverage improvements in this repository."
+
+## HARD-GATE
+
+Do not start coding in ideate mode. End with an explicit user choice.
+
+## Protocol
+
+1. Collect evidence from the current repo state.
+2. Build candidate improvements with impact/effort/confidence.
+3. Rank and recommend one candidate.
+4. Ask for explicit selection.
+5. If user selects a candidate, hand off to \`/cc <selected idea>\`.
+
+## Candidate format
+
+| ID | Improvement | Impact | Effort | Confidence | Evidence |
+|---|---|---|---|---|---|
+| I-1 |  | High/Medium/Low | S/M/L | High/Medium/Low | path or command evidence |
+`;
+}

package/dist/content/meta-skill.js

@@ -3,7 +3,7 @@ export const META_SKILL_NAME = "using-cclaw";
 export function usingCclawSkillMarkdown() {
     return `---
 name: using-cclaw
-description: "Routing brain for cclaw. Decide whether to start/resume a stage, answer directly, or use utility commands like /cc-learn, /cc-view, and /cc-ops."
+description: "Routing brain for cclaw. Decide whether to start/resume a stage, answer directly, or use utility commands like /cc-learn, /cc-ideate, /cc-view, and /cc-ops."
 ---
 
 # Using Cclaw
@@ -25,10 +25,11 @@ Task arrives
   ├─ Running as spawned subagent? -> obey parent prompt only; do not run cclaw routing
   ├─ Pure question / non-software ask? -> answer directly (no stage)
   ├─ New software work? -> /cc <idea>
+  ├─ Repo-improvement discovery? -> /cc-ideate
   ├─ Resume existing flow? -> /cc or /cc-next
   ├─ Knowledge operation? -> /cc-learn
   ├─ Read-only workspace view? -> /cc-view [status|tree|diff]
-  └─ Workspace operation? -> /cc-ops [feature|tdd-log|retro|archive|rewind]
+  └─ Workspace operation? -> /cc-ops [feature|tdd-log|retro|compound|archive|rewind]
 \`\`\`
 
 ## Task classification
@@ -60,6 +61,8 @@ Tracks may skip stages via \`flow-state.track\` + \`skippedStages\`.
 Load utility skills only when triggered by the current task:
 
 - security, performance, debugging, docs, ci-cd
+- verification-before-completion before completion claims
+- finishing-a-development-branch during ship/finalization
 - document-review and execution context skills
 - language rule packs from \`.cclaw/config.yaml\` when enabled
 

package/dist/content/next-command.js

@@ -33,7 +33,7 @@ This is the only progression command the user needs to drive the entire flow. St
 
 - **Do not** invent gate completion: use only \`${flowPath}\` plus observable evidence in repo artifacts.
 - **Do not** skip stages: advance only from \`currentStage\` to its configured successor.
-- If the flow reaches terminal ship completion, route closeout in order: **/cc-ops retro -> /cc-ops archive**.
+- If the flow reaches terminal ship completion, route closeout in order: **/cc-ops retro -> /cc-ops compound (optional) -> /cc-ops archive**.
 
 ## Algorithm (mandatory)
 
@@ -56,7 +56,7 @@ This is the only progression command the user needs to drive the entire flow. St
 
 → If current stage's \`next\` is **\`done\`**:
   - if \`currentStage === "ship"\` and \`retro.completedAt\` is missing -> route to \`/cc-ops retro\`,
-  - if \`currentStage === "ship"\` and \`retro.completedAt\` is present -> route to \`/cc-ops archive\`,
+  - if \`currentStage === "ship"\` and \`retro.completedAt\` is present -> suggest \`/cc-ops compound\` then route to \`/cc-ops archive\`,
   - otherwise report **"Flow complete. All stages finished."** and stop.
 → Otherwise: load **\`${RUNTIME_ROOT}/skills/<skillFolder>/SKILL.md\`** and **\`${RUNTIME_ROOT}/commands/<nextStage>.md\`** for the successor stage. Execute that stage's protocol.
 
@@ -150,7 +150,7 @@ Execute the stage protocol. The stage skill handles interaction, STOP points, ga
 If \`next\` is \`done\`:
 
 - If \`currentStage\` is \`ship\` and \`retro.completedAt\` is missing -> route to \`/cc-ops retro\`.
-- If \`currentStage\` is \`ship\` and \`retro.completedAt\` exists -> route to \`/cc-ops archive\`.
+- If \`currentStage\` is \`ship\` and \`retro.completedAt\` exists -> suggest \`/cc-ops compound\`, then route to \`/cc-ops archive\`.
 - Otherwise report **"Flow complete. All stages finished."** and stop.
 
 Otherwise load the next stage's skill and command contract, begin execution.

package/dist/content/ops-command.js

@@ -12,6 +12,7 @@ Subcommands:
 - \`feature\` -> \`/cc-ops feature\`
 - \`tdd-log\` -> \`/cc-ops tdd-log\`
 - \`retro\` -> \`/cc-ops retro\`
+- \`compound\` -> \`/cc-ops compound\`
 - \`archive\` -> \`/cc-ops archive\`
 - \`rewind\` -> \`/cc-ops rewind\`
 
@@ -27,6 +28,7 @@ Subcommands:
    - \`feature\` -> \`${RUNTIME_ROOT}/commands/feature.md\`
    - \`tdd-log\` -> \`${RUNTIME_ROOT}/commands/tdd-log.md\`
    - \`retro\` -> \`${RUNTIME_ROOT}/commands/retro.md\`
+   - \`compound\` -> \`${RUNTIME_ROOT}/commands/compound.md\`
    - \`archive\` -> \`${RUNTIME_ROOT}/commands/archive.md\`
    - \`rewind\` -> \`${RUNTIME_ROOT}/commands/rewind.md\`
 3. Unknown subcommand -> print supported values and stop.
@@ -39,7 +41,7 @@ Subcommands:
 export function opsCommandSkillMarkdown() {
     return `---
 name: ${OPS_SKILL_NAME}
-description: "Unified operational router for feature/tdd-log/retro/archive/rewind commands."
+description: "Unified operational router for feature/tdd-log/retro/compound/archive/rewind commands."
 ---
 
 # /cc-ops
@@ -50,7 +52,7 @@ This wrapper only dispatches. It must not apply state mutations itself.
 
 ## Protocol
 
-1. Require a subcommand (\`feature|tdd-log|retro|archive|rewind\`).
+1. Require a subcommand (\`feature|tdd-log|retro|compound|archive|rewind\`).
 2. Route to the matching command contract + skill pair.
 3. Preserve pass-through args after the subcommand (e.g. \`/cc-ops rewind design\`).
 4. Echo which subcommand was dispatched for auditability.

package/dist/content/protocols.js

@@ -75,7 +75,12 @@ export function ethosProtocolMarkdown() {
 
 Shared operating principles across all stages.
 
-## Search before building
+## 1) Boil the Lake
+
+When the "complete version" costs only slightly more than a shortcut, prefer the
+complete version. Do not leave obvious quality gaps for hypothetical follow-ups.
+
+## 2) Search Before Building
 
 Before adding new code/templates/rules:
 
@@ -84,13 +89,30 @@ Before adding new code/templates/rules:
 3. Search codebase for reusable implementations.
 4. Prefer built-in/library primitives over custom helpers.
 
-## Do less, prove more
+## 3) User Sovereignty
+
+AI recommends. User decides. If your recommendation changes the user's stated
+direction, ask first and wait for explicit approval.
+
+## 4) Iron-Law Discipline
+
+Every stage has a non-negotiable Iron Law. If a proposed action violates it,
+stop and escalate via Decision Protocol instead of rationalizing exceptions.
+
+## 5) Complete Before Ship
 
-- Prefer minimal, verifiable changes.
-- Evidence beats volume.
-- Keep stage output concrete and testable.
+No release shortcuts:
+- review verdict must be explicit,
+- preflight evidence must be fresh,
+- rollback must be written before finalization.
 
-## Turn announce discipline
+## 6) Compound, Don't Repeat
+
+When a reusable lesson appears, add one strict-schema JSONL entry via
+\`/cc-learn add\`. Repeated lessons should be lifted into stable rules/skills so
+the same class of mistake gets harder to repeat.
+
+## Turn Announce Discipline
 
 Keep orchestration visible without maintaining a dedicated preamble runtime log.
 
@@ -98,10 +120,5 @@ Keep orchestration visible without maintaining a dedicated preamble runtime log.
 - Skip announce for trivial single-command actions.
 - Never repeat boilerplate announces when the intent did not change.
 - If plan or risk changes materially, post a fresh announce before executing.
-
-## Operational learning
-
-When a reusable lesson appears, add one strict-schema JSONL entry via
-\`/cc-learn add\`. Keep the knowledge store append-only.
 `;
 }

package/dist/content/retro-command.js

@@ -36,7 +36,7 @@ Mandatory retrospective gate before archive once ship is complete.
    - \`required: true\`
    - \`completedAt: <ISO>\`
    - \`compoundEntries: <count>\`
-5. Report completion summary and remind user that \`/cc-ops archive\` is now unblocked.
+5. Report completion summary and remind user that \`/cc-ops compound\` (optional) can lift repeated learnings before \`/cc-ops archive\`.
 
 ## Primary skill
 
@@ -67,6 +67,7 @@ Archive must remain blocked until retro artifact exists and compound knowledge w
 5. Print explicit completion line:
    - \`retro gate: complete\`
    - \`compound entries added: <N>\`
+   - \`next: /cc-ops compound (optional) -> /cc-ops archive\`
 
 ## Validation
 

package/dist/content/skills.js

@@ -98,6 +98,9 @@ Provide fresh, stage-local verification evidence from this turn:
 1. Run verification commands (tests/build/lint/type-check) for the changed scope.
 2. Confirm output, do not infer success from prior runs.
 3. If this is a bug fix, capture RED -> GREEN evidence for the regression path.
+
+Reference utility skill:
+\`.cclaw/skills/verification-before-completion/SKILL.md\`
 `;
 }
 function waveExecutionModeBlock(stage) {
@@ -191,11 +194,14 @@ function stageSpecificSeeAlso(stage) {
         ],
         review: [
             `- \`${RUNTIME_ROOT}/skills/security/SKILL.md\``,
-            `- \`${RUNTIME_ROOT}/skills/parallel-dispatch/SKILL.md\``
+            `- \`${RUNTIME_ROOT}/skills/parallel-dispatch/SKILL.md\``,
+            `- \`${RUNTIME_ROOT}/skills/verification-before-completion/SKILL.md\``
         ],
         ship: [
             `- \`${RUNTIME_ROOT}/skills/ci-cd/SKILL.md\``,
-            `- \`${RUNTIME_ROOT}/skills/docs/SKILL.md\``
+            `- \`${RUNTIME_ROOT}/skills/docs/SKILL.md\``,
+            `- \`${RUNTIME_ROOT}/skills/verification-before-completion/SKILL.md\``,
+            `- \`${RUNTIME_ROOT}/skills/finishing-a-development-branch/SKILL.md\``
         ]
     };
     return refs[stage];
@@ -226,9 +232,10 @@ function quickStartBlock(stage) {
     const gatePreview = schema.requiredGates.slice(0, 3).map((g) => `\`${g.id}\``).join(", ");
     return `## Quick Start
 
-1. Obey HARD-GATE and Iron Law.
-2. Execute checklist in order and persist \`${RUNTIME_ROOT}/artifacts/${schema.artifactFile}\`.
-3. Satisfy gates (${gatePreview}${schema.requiredGates.length > 3 ? ` +${schema.requiredGates.length - 3}` : ""}).
+1. Announce at start: "Using \`${schema.skillName}\` to ${schema.purpose}".
+2. Obey HARD-GATE and Iron Law.
+3. Execute checklist in order and persist \`${RUNTIME_ROOT}/artifacts/${schema.artifactFile}\`.
+4. Satisfy gates (${gatePreview}${schema.requiredGates.length > 3 ? ` +${schema.requiredGates.length - 3}` : ""}).
 `;
 }
 /**

package/dist/content/stages/review.js

@@ -168,6 +168,26 @@ export const REVIEW = {
             ],
             stopGate: true
         },
+        {
+            title: "Specialist Lens: Data & Migration Safety",
+            evaluationPoints: [
+                "Schema/data migrations are reversible and include backfill/rollback strategy",
+                "Idempotency expectations are explicit for retryable flows",
+                "Data-loss scenarios (truncate/overwrite/drop) are guarded by checks or dry-runs",
+                "Boundary contracts (API/schema/event payload) maintain backward compatibility or are versioned"
+            ],
+            stopGate: false
+        },
+        {
+            title: "Specialist Lens: Developer Experience",
+            evaluationPoints: [
+                "New behavior includes discoverable docs/usage notes where needed",
+                "Error messages are actionable for on-call and local debugging",
+                "Default configuration remains safe and unsurprising",
+                "Change footprint stays minimal and avoids hidden coupling"
+            ],
+            stopGate: false
+        },
         {
             title: "Meta-Review: Verify the Verification",
             evaluationPoints: [

package/dist/content/stages/ship.js

@@ -26,6 +26,7 @@ export const SHIP = {
         "Re-run tests on merged result — if merging locally, run the full test suite AFTER the merge, not just before. Post-merge failures are common.",
         "Generate release notes — summarize what changed, why, and what it affects. Reference spec criteria. Include: breaking changes, new dependencies, migration steps if any.",
         "Write rollback plan — trigger conditions (what tells you it is broken), rollback steps (exact commands/git operations), and verification (how to confirm rollback worked).",
+        "Load utility skills — `verification-before-completion` for fresh evidence and `finishing-a-development-branch` for finalization workflow.",
         "Monitoring checklist — what should be watched after deploy? Error rates, latency, key business metrics. If no monitoring exists, flag it as a risk.",
         "Select finalization mode — exactly ONE enum: (A) FINALIZE_MERGE_LOCAL, (B) FINALIZE_OPEN_PR, (C) FINALIZE_KEEP_BRANCH, (D) FINALIZE_DISCARD_BRANCH. For discard: list what will be deleted, require typed confirmation.",
         "Execute finalization — perform the selected action. For merge: verify clean merge. For PR: include structured body (summary, test plan, rollback). For discard: verify deletion.",

package/dist/content/utility-skills.d.ts

@@ -10,6 +10,8 @@ export declare function ciCdSkill(): string;
 export declare function docsSkill(): string;
 export declare function executingPlansSkill(): string;
 export declare function contextEngineeringSkill(): string;
+export declare function verificationBeforeCompletionSkill(): string;
+export declare function finishingDevelopmentBranchSkill(): string;
 export declare function sourceDrivenDevelopmentSkill(): string;
 export declare function frontendAccessibilitySkill(): string;
 export declare function landscapeCheckSkill(): string;
@@ -44,5 +46,5 @@ export declare const LANGUAGE_RULE_PACK_GENERATORS: Record<string, () => string>
  * clean them up after the move to `.cclaw/rules/lang/`.
  */
 export declare const LEGACY_LANGUAGE_RULE_PACK_FOLDERS: readonly ["language-typescript", "language-python", "language-go"];
-export declare const UTILITY_SKILL_FOLDERS: readonly ["security", "debugging", "performance", "ci-cd", "docs", "executing-plans", "context-engineering", "source-driven-development", "frontend-accessibility", "landscape-check", "adversarial-review", "security-audit", "knowledge-curation", "retrospective", "document-review"];
+export declare const UTILITY_SKILL_FOLDERS: readonly ["security", "debugging", "performance", "ci-cd", "docs", "executing-plans", "verification-before-completion", "finishing-a-development-branch", "context-engineering", "source-driven-development", "frontend-accessibility", "landscape-check", "adversarial-review", "security-audit", "knowledge-curation", "retrospective", "document-review"];
 export declare const UTILITY_SKILL_MAP: Record<string, () => string>;

package/dist/content/utility-skills.js

@@ -594,6 +594,92 @@ Modes are stored in \`.cclaw/contexts/\`:
 - Shipping decisions based on stale pre-compaction context.
 `;
 }
+export function verificationBeforeCompletionSkill() {
+    return `---
+name: verification-before-completion
+description: "Final verification discipline before stage closeout or ship. Use when preparing a completion claim."
+---
+
+# Verification Before Completion
+
+## Announce at start
+
+"Using verification-before-completion to validate fresh evidence before completion."
+
+## HARD-GATE
+
+Do not claim completion from memory. Every pass claim requires fresh, in-turn evidence.
+
+## Protocol
+
+1. Identify changed scope (files, modules, user-facing behaviors).
+2. Run the smallest command set that still proves the scope:
+   - tests for changed area
+   - typecheck/build/lint if the stack requires it
+3. Capture exact command + pass/fail output in the artifact.
+4. If this is a bug fix, include RED -> GREEN regression evidence.
+5. If any check fails, stop completion and return to fix loop.
+
+## Completion claim checklist
+
+- [ ] Commands were run in this turn (not reused from earlier output).
+- [ ] Output corresponds to the actual changed scope.
+- [ ] Failures (if any) are resolved or explicitly escalated.
+- [ ] Artifact includes evidence references.
+- [ ] Completion status reflects evidence (DONE / DONE_WITH_CONCERNS / BLOCKED).
+
+## Anti-patterns
+
+- "Tests passed earlier today" without rerunning.
+- Reporting only "PASS" without command context.
+- Running unrelated checks while skipping changed scope checks.
+- Marking DONE while blockers still fail.
+`;
+}
+export function finishingDevelopmentBranchSkill() {
+    return `---
+name: finishing-a-development-branch
+description: "Finalize implementation branch after review: verify, choose integration mode, execute safely, and clean up."
+---
+
+# Finishing a Development Branch
+
+## Announce at start
+
+"Using finishing-a-development-branch to complete this branch safely."
+
+## HARD-GATE
+
+Do not merge, open PR, or discard branch until verification and rollback notes are explicit.
+
+## Protocol
+
+1. Verify readiness:
+   - review verdict is APPROVED or APPROVED_WITH_CONCERNS
+   - verification-before-completion checklist is satisfied
+2. Choose one finalization mode:
+   - FINALIZE_MERGE_LOCAL
+   - FINALIZE_OPEN_PR
+   - FINALIZE_KEEP_BRANCH
+   - FINALIZE_DISCARD_BRANCH
+3. Execute only the chosen mode and record exact result.
+4. If merge or discard happened in a feature worktree, clean the worktree.
+5. Update ship artifact with release notes, rollback, and finalization evidence.
+
+## Rollback minimum
+
+- Trigger: what tells us release is wrong.
+- Steps: exact revert/reset/rollback commands.
+- Verification: how we confirm rollback worked.
+
+## Anti-patterns
+
+- Multiple finalization modes in one run.
+- Merge without rollback section.
+- PR without test/verification summary.
+- Discarding branch without explicit user confirmation.
+`;
+}
 export function sourceDrivenDevelopmentSkill() {
     return `---
 name: source-driven-development
@@ -1524,6 +1610,8 @@ export const UTILITY_SKILL_FOLDERS = [
     "ci-cd",
     "docs",
     "executing-plans",
+    "verification-before-completion",
+    "finishing-a-development-branch",
     "context-engineering",
     "source-driven-development",
     "frontend-accessibility",
@@ -1541,6 +1629,8 @@ export const UTILITY_SKILL_MAP = {
     "ci-cd": ciCdSkill,
     docs: docsSkill,
     "executing-plans": executingPlansSkill,
+    "verification-before-completion": verificationBeforeCompletionSkill,
+    "finishing-a-development-branch": finishingDevelopmentBranchSkill,
     "context-engineering": contextEngineeringSkill,
     "source-driven-development": sourceDrivenDevelopmentSkill,
     "frontend-accessibility": frontendAccessibilitySkill,

package/dist/doctor.js

@@ -34,6 +34,27 @@ async function isGitRepo(projectRoot) {
         return false;
     }
 }
+async function gitWorktreePaths(projectRoot) {
+    try {
+        const { stdout } = await execFileAsync("git", ["worktree", "list", "--porcelain"], {
+            cwd: projectRoot
+        });
+        const out = new Set();
+        for (const line of stdout.split(/\r?\n/)) {
+            const trimmed = line.trim();
+            if (!trimmed.startsWith("worktree "))
+                continue;
+            const rawPath = trimmed.slice("worktree ".length).trim();
+            if (!rawPath)
+                continue;
+            out.add(path.resolve(rawPath));
+        }
+        return out;
+    }
+    catch {
+        return new Set();
+    }
+}
 async function resolveGitHooksDir(projectRoot) {
     try {
         const { stdout } = await execFileAsync("git", ["rev-parse", "--git-path", "hooks"], { cwd: projectRoot });
@@ -462,6 +483,7 @@ export async function doctorChecks(projectRoot, options = {}) {
         const hasMarkers = content.includes(CCLAW_MARKER_START) && content.includes(CCLAW_MARKER_END);
         const hasCcCommand = content.includes("/cc");
         const hasCcNext = content.includes("/cc-next");
+        const hasCcIdeate = content.includes("/cc-ideate");
         const hasCcLearn = content.includes("/cc-learn");
         const hasCcView = content.includes("/cc-view");
         const hasCcOps = content.includes("/cc-ops");
@@ -471,6 +493,7 @@ export async function doctorChecks(projectRoot, options = {}) {
         agentsBlockOk = hasMarkers
             && hasCcCommand
             && hasCcNext
+            && hasCcIdeate
             && hasCcLearn
             && hasCcView
             && hasCcOps
@@ -484,7 +507,7 @@ export async function doctorChecks(projectRoot, options = {}) {
         details: `${agentsFile} must contain the managed cclaw marker block with routing, verification, and minimal detail pointer`
     });
     // Utility commands
-    for (const cmd of ["learn", "next", "status", "tree", "diff", "feature", "tdd-log", "retro", "rewind"]) {
+    for (const cmd of ["learn", "next", "ideate", "status", "tree", "diff", "feature", "tdd-log", "retro", "compound", "rewind"]) {
         const cmdPath = path.join(projectRoot, RUNTIME_ROOT, "commands", `${cmd}.md`);
         checks.push({
             name: `utility_command:${cmd}`,
@@ -495,12 +518,16 @@ export async function doctorChecks(projectRoot, options = {}) {
     // Utility skills
     for (const [folder, label] of [
         ["learnings", "learnings"],
+        ["flow-ideate", "flow-ideate"],
         ["flow-tree", "flow-tree"],
         ["flow-diff", "flow-diff"],
         ["using-git-worktrees", "using-git-worktrees"],
         ["tdd-cycle-log", "tdd-cycle-log"],
         ["flow-retro", "flow-retro"],
+        ["flow-compound", "flow-compound"],
         ["flow-rewind", "flow-rewind"],
+        ["verification-before-completion", "verification-before-completion"],
+        ["finishing-a-development-branch", "finishing-a-development-branch"],
         ["subagent-dev", "sdd"],
         ["parallel-dispatch", "parallel-agents"],
         ["session", "session"],
@@ -834,6 +861,8 @@ export async function doctorChecks(projectRoot, options = {}) {
         let malformedKnowledgeLines = 0;
         let missingSchemaV2Fields = 0;
         let parsedKnowledgeLines = 0;
+        let lowConfidenceLines = 0;
+        const triggerActionCounts = new Map();
         const requiredV2Fields = [
             "type",
             "trigger",
@@ -865,6 +894,16 @@ export async function doctorChecks(projectRoot, options = {}) {
                         continue;
                     }
                     parsedKnowledgeLines += 1;
+                    const confidence = typeof parsed.confidence === "string" ? parsed.confidence.toLowerCase() : "";
+                    if (confidence === "low") {
+                        lowConfidenceLines += 1;
+                    }
+                    const trigger = typeof parsed.trigger === "string" ? parsed.trigger.trim().toLowerCase() : "";
+                    const action = typeof parsed.action === "string" ? parsed.action.trim().toLowerCase() : "";
+                    if (trigger.length > 0 && action.length > 0) {
+                        const key = `${trigger} => ${action}`;
+                        triggerActionCounts.set(key, (triggerActionCounts.get(key) ?? 0) + 1);
+                    }
                     const missing = requiredV2Fields.some((field) => !Object.prototype.hasOwnProperty.call(parsed, field));
                     if (missing) {
                         missingSchemaV2Fields += 1;
@@ -894,6 +933,24 @@ export async function doctorChecks(projectRoot, options = {}) {
                     ? `all ${parsedKnowledgeLines} knowledge line(s) include schema v2 fields`
                     : `warning: ${missingSchemaV2Fields}/${parsedKnowledgeLines} knowledge line(s) miss schema v2 fields (origin/maturity/frequency metadata)`
         });
+        const lowConfidenceRatio = parsedKnowledgeLines === 0 ? 0 : lowConfidenceLines / parsedKnowledgeLines;
+        checks.push({
+            name: "warning:knowledge:low_confidence_density",
+            ok: true,
+            details: parsedKnowledgeLines === 0
+                ? "knowledge.jsonl is empty"
+                : lowConfidenceRatio <= 0.35
+                    ? `low-confidence entries: ${lowConfidenceLines}/${parsedKnowledgeLines}`
+                    : `warning: low-confidence entries are high (${lowConfidenceLines}/${parsedKnowledgeLines}, ${(lowConfidenceRatio * 100).toFixed(1)}%). Consider /cc-learn curate before adding more.`
+        });
+        const repeatedClusters = [...triggerActionCounts.entries()].filter(([, count]) => count >= 3);
+        checks.push({
+            name: "warning:knowledge:repeat_clusters",
+            ok: true,
+            details: repeatedClusters.length === 0
+                ? "no high-frequency repeated trigger/action clusters detected"
+                : `warning: ${repeatedClusters.length} repeated learning cluster(s) detected (>=3 repeats). Consider /cc-ops compound to lift them into rules/skills.`
+        });
     }
     checks.push({
         name: "state:checkpoint_exists",
@@ -1049,6 +1106,34 @@ export async function doctorChecks(projectRoot, options = {}) {
         ok: await exists(path.join(projectRoot, RUNTIME_ROOT, "artifacts")),
         details: `${RUNTIME_ROOT}/artifacts must exist as the active artifact root`
     });
+    const artifactsRoot = path.join(projectRoot, RUNTIME_ROOT, "artifacts");
+    let artifactPlaceholderHits = [];
+    if (await exists(artifactsRoot)) {
+        try {
+            const entries = await fs.readdir(artifactsRoot, { withFileTypes: true });
+            const placeholderPattern = /\b(?:TODO|TBD|FIXME)\b|<fill-in>|<your-.*-here>/giu;
+            for (const entry of entries) {
+                if (!entry.isFile() || !entry.name.endsWith(".md"))
+                    continue;
+                const filePath = path.join(artifactsRoot, entry.name);
+                const content = await fs.readFile(filePath, "utf8");
+                const matchCount = (content.match(placeholderPattern) ?? []).length;
+                if (matchCount > 0) {
+                    artifactPlaceholderHits.push(`${entry.name}:${matchCount}`);
+                }
+            }
+        }
+        catch {
+            artifactPlaceholderHits = [];
+        }
+    }
+    checks.push({
+        name: "warning:artifacts:stale_placeholders",
+        ok: true,
+        details: artifactPlaceholderHits.length === 0
+            ? "no TODO/TBD/FIXME placeholder markers found in active artifacts"
+            : `warning: placeholder markers detected in active artifacts (${artifactPlaceholderHits.join(", ")}). Clear before marking completion.`
+    });
     const features = await listFeatures(projectRoot);
     const worktreeRegistry = await readFeatureWorktreeRegistry(projectRoot);
     const activeFeatureEntry = worktreeRegistry.entries.find((entry) => entry.featureId === activeFeature);
@@ -1086,6 +1171,43 @@ export async function doctorChecks(projectRoot, options = {}) {
             ? `active feature "${activeFeature}" maps to workspace path ${activeFeatureEntry.path} (${activeFeatureEntry.source})`
             : `active feature "${activeFeature}" has no worktree registry entry`
     });
+    const missingRegistryPaths = [];
+    for (const entry of worktreeRegistry.entries) {
+        const workspacePath = resolveFeatureWorkspacePath(projectRoot, entry);
+        if (!(await exists(workspacePath))) {
+            missingRegistryPaths.push(`${entry.featureId}:${entry.path}`);
+        }
+    }
+    checks.push({
+        name: "state:worktree_registry_paths_exist",
+        ok: missingRegistryPaths.length === 0,
+        details: missingRegistryPaths.length === 0
+            ? "all worktree registry entries resolve to existing paths"
+            : `missing worktree paths for registry entries: ${missingRegistryPaths.join(", ")}`
+    });
+    const gitTrackedPaths = await gitWorktreePaths(projectRoot);
+    const registryGitPaths = worktreeRegistry.entries
+        .filter((entry) => entry.source === "git-worktree")
+        .map((entry) => resolveFeatureWorkspacePath(projectRoot, entry));
+    const missingFromGitList = registryGitPaths.filter((workspacePath) => !gitTrackedPaths.has(path.resolve(workspacePath)));
+    checks.push({
+        name: "warning:state:worktree_registry_git_drift",
+        ok: true,
+        details: missingFromGitList.length === 0
+            ? "git-worktree registry entries align with `git worktree list`"
+            : `warning: ${missingFromGitList.length} registry worktree path(s) are missing from \`git worktree list\`: ${missingFromGitList.join(", ")}`
+    });
+    const managedWorktreeRoot = path.join(projectRoot, RUNTIME_ROOT, "worktrees");
+    const unregisteredManagedWorktrees = [...gitTrackedPaths]
+        .filter((workspacePath) => workspacePath.startsWith(path.resolve(managedWorktreeRoot)))
+        .filter((workspacePath) => !registryGitPaths.some((registeredPath) => path.resolve(registeredPath) === workspacePath));
+    checks.push({
+        name: "warning:state:worktree_unregistered_paths",
+        ok: true,
+        details: unregisteredManagedWorktrees.length === 0
+            ? "no unmanaged git worktrees under .cclaw/worktrees"
+            : `warning: unregistered git worktree paths detected: ${unregisteredManagedWorktrees.map((value) => path.relative(projectRoot, value)).join(", ")}`
+    });
     const legacyWorkspaceEntries = worktreeRegistry.entries
         .filter((entry) => entry.source === "legacy-snapshot")
         .map((entry) => entry.featureId);

package/dist/harness-adapters.js

@@ -18,6 +18,12 @@ const UTILITY_SHIMS = [
         skillFolder: "flow-next-step",
         commandFile: "next.md"
     },
+    {
+        fileName: "cc-ideate.md",
+        command: "ideate",
+        skillFolder: "flow-ideate",
+        commandFile: "ideate.md"
+    },
     {
         fileName: "cc-view.md",
         command: "view",
@@ -99,6 +105,15 @@ function agentsMdBlock() {
 > Auto-generated by \`cclaw sync\`. Do not edit this managed block manually.
 > Existing project rules in this repository take precedence over cclaw defaults.
 
+## Anti-Slop Guard
+
+Treat quality as a hard requirement, not style preference:
+
+1. Confirm there is a real problem statement before proposing broad changes.
+2. Prefer one focused change over bundled unrelated edits.
+3. Verify claims with fresh evidence in this turn.
+4. If uncertain, escalate with options instead of fabricating certainty.
+
 ### Activation Rule
 
 Before responding to a coding request:
@@ -133,9 +148,10 @@ When in doubt, prefer **non-trivial** — the quick track is opt-in and only saf
 |---|---|
 | \`/cc\` | **Entry point.** No args = resume current stage. With prompt = classify task and start the right flow. |
 | \`/cc-next\` | **Progression.** Advances to the next stage when current is complete. |
+| \`/cc-ideate\` | **Discovery mode.** Generates a ranked repo-improvement backlog before implementation. |
 | \`/cc-view\` | **Read-only router.** Unified entry for status/tree/diff views. |
 | \`/cc-learn\` | **Cross-cutting.** Capture or review project knowledge (append-only JSONL). |
-| \`/cc-ops\` | **Operations router.** Unified entry for feature/tdd-log/retro/archive/rewind actions. |
+| \`/cc-ops\` | **Operations router.** Unified entry for feature/tdd-log/retro/compound/archive/rewind actions. |
 
 **Stage order:** brainstorm > scope > design > spec > plan > tdd > review > ship.
 \`/cc-next\` loads the right stage skill automatically. Gates must pass before handoff.

package/dist/install.js

@@ -8,6 +8,7 @@ import { commandContract } from "./content/contracts.js";
 import { contextModeFiles, createInitialContextModeState } from "./content/contexts.js";
 import { learnSkillMarkdown, learnCommandContract } from "./content/learnings.js";
 import { nextCommandContract, nextCommandSkillMarkdown } from "./content/next-command.js";
+import { ideateCommandContract, ideateCommandSkillMarkdown } from "./content/ideate-command.js";
 import { startCommandContract, startCommandSkillMarkdown } from "./content/start-command.js";
 import { statusCommandContract, statusCommandSkillMarkdown } from "./content/status-command.js";
 import { treeCommandContract, treeCommandSkillMarkdown } from "./content/tree-command.js";
@@ -17,6 +18,7 @@ import { opsCommandContract, opsCommandSkillMarkdown } from "./content/ops-comma
 import { featureCommandContract, featureCommandSkillMarkdown } from "./content/feature-command.js";
 import { tddLogCommandContract, tddLogCommandSkillMarkdown } from "./content/tdd-log-command.js";
 import { retroCommandContract, retroCommandSkillMarkdown } from "./content/retro-command.js";
+import { compoundCommandContract, compoundCommandSkillMarkdown } from "./content/compound-command.js";
 import { archiveCommandContract, archiveCommandSkillMarkdown } from "./content/archive-command.js";
 import { rewindCommandContract, rewindCommandSkillMarkdown } from "./content/rewind-command.js";
 import { subagentDrivenDevSkill, parallelAgentsSkill } from "./content/subagents.js";
@@ -204,6 +206,7 @@ async function writeSkills(projectRoot, config) {
     // Utility skills (not flow stages)
     await writeFileSafe(runtimePath(projectRoot, "skills", "learnings", "SKILL.md"), learnSkillMarkdown());
     await writeFileSafe(runtimePath(projectRoot, "skills", "flow-next-step", "SKILL.md"), nextCommandSkillMarkdown());
+    await writeFileSafe(runtimePath(projectRoot, "skills", "flow-ideate", "SKILL.md"), ideateCommandSkillMarkdown());
     await writeFileSafe(runtimePath(projectRoot, "skills", "flow-start", "SKILL.md"), startCommandSkillMarkdown());
     await writeFileSafe(runtimePath(projectRoot, "skills", "flow-view", "SKILL.md"), viewCommandSkillMarkdown());
     await writeFileSafe(runtimePath(projectRoot, "skills", "flow-status", "SKILL.md"), statusCommandSkillMarkdown());
@@ -213,6 +216,7 @@ async function writeSkills(projectRoot, config) {
     await writeFileSafe(runtimePath(projectRoot, "skills", "using-git-worktrees", "SKILL.md"), featureCommandSkillMarkdown());
     await writeFileSafe(runtimePath(projectRoot, "skills", "tdd-cycle-log", "SKILL.md"), tddLogCommandSkillMarkdown());
     await writeFileSafe(runtimePath(projectRoot, "skills", "flow-retro", "SKILL.md"), retroCommandSkillMarkdown());
+    await writeFileSafe(runtimePath(projectRoot, "skills", "flow-compound", "SKILL.md"), compoundCommandSkillMarkdown());
     await writeFileSafe(runtimePath(projectRoot, "skills", "flow-rewind", "SKILL.md"), rewindCommandSkillMarkdown());
     await writeFileSafe(runtimePath(projectRoot, "skills", "flow-archive", "SKILL.md"), archiveCommandSkillMarkdown());
     await writeFileSafe(runtimePath(projectRoot, "skills", "subagent-dev", "SKILL.md"), subagentDrivenDevSkill());
@@ -266,6 +270,7 @@ async function writeSkills(projectRoot, config) {
 async function writeUtilityCommands(projectRoot) {
     await writeFileSafe(runtimePath(projectRoot, "commands", "learn.md"), learnCommandContract());
     await writeFileSafe(runtimePath(projectRoot, "commands", "next.md"), nextCommandContract());
+    await writeFileSafe(runtimePath(projectRoot, "commands", "ideate.md"), ideateCommandContract());
     await writeFileSafe(runtimePath(projectRoot, "commands", "view.md"), viewCommandContract());
     await writeFileSafe(runtimePath(projectRoot, "commands", "start.md"), startCommandContract());
     await writeFileSafe(runtimePath(projectRoot, "commands", "status.md"), statusCommandContract());
@@ -275,6 +280,7 @@ async function writeUtilityCommands(projectRoot) {
     await writeFileSafe(runtimePath(projectRoot, "commands", "feature.md"), featureCommandContract());
     await writeFileSafe(runtimePath(projectRoot, "commands", "tdd-log.md"), tddLogCommandContract());
     await writeFileSafe(runtimePath(projectRoot, "commands", "retro.md"), retroCommandContract());
+    await writeFileSafe(runtimePath(projectRoot, "commands", "compound.md"), compoundCommandContract());
     await writeFileSafe(runtimePath(projectRoot, "commands", "archive.md"), archiveCommandContract());
     await writeFileSafe(runtimePath(projectRoot, "commands", "rewind.md"), rewindCommandContract());
 }

package/dist/policy.js

@@ -90,6 +90,9 @@ export async function policyChecks(projectRoot, options = {}) {
         { file: runtimeFile("skills/learnings/SKILL.md"), needle: "## Subcommands", name: "utility_skill:learnings:subcommands" },
         { file: runtimeFile("skills/learnings/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:learnings:hard_gate" },
         { file: runtimeFile("commands/learn.md"), needle: "## Subcommands", name: "utility_command:learn:subcommands" },
+        { file: runtimeFile("commands/ideate.md"), needle: "## Algorithm", name: "utility_command:ideate:algorithm" },
+        { file: runtimeFile("skills/flow-ideate/SKILL.md"), needle: "## Protocol", name: "utility_skill:ideate:protocol" },
+        { file: runtimeFile("skills/flow-ideate/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:ideate:hard_gate" },
         { file: runtimeFile("commands/status.md"), needle: "bar:", name: "utility_command:status:visual_bar" },
         { file: runtimeFile("commands/status.md"), needle: "/cc-view tree · /cc-view diff", name: "utility_command:status:tree_diff_link" },
         { file: runtimeFile("commands/tree.md"), needle: "## Algorithm", name: "utility_command:tree:algorithm" },
@@ -107,6 +110,9 @@ export async function policyChecks(projectRoot, options = {}) {
         { file: runtimeFile("commands/retro.md"), needle: "## Algorithm", name: "utility_command:retro:algorithm" },
         { file: runtimeFile("skills/flow-retro/SKILL.md"), needle: "## Protocol", name: "utility_skill:retro:protocol" },
         { file: runtimeFile("skills/flow-retro/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:retro:hard_gate" },
+        { file: runtimeFile("commands/compound.md"), needle: "## Algorithm", name: "utility_command:compound:algorithm" },
+        { file: runtimeFile("skills/flow-compound/SKILL.md"), needle: "## Protocol", name: "utility_skill:compound:protocol" },
+        { file: runtimeFile("skills/flow-compound/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:compound:hard_gate" },
         { file: runtimeFile("commands/rewind.md"), needle: "## Algorithm", name: "utility_command:rewind:algorithm" },
         { file: runtimeFile("skills/flow-rewind/SKILL.md"), needle: "## Protocol", name: "utility_skill:rewind:protocol" },
         { file: runtimeFile("skills/flow-rewind/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:rewind:hard_gate" },
@@ -156,6 +162,10 @@ export async function policyChecks(projectRoot, options = {}) {
         { file: runtimeFile("skills/executing-plans/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:executing_plans:hard_gate" },
         { file: runtimeFile("skills/executing-plans/SKILL.md"), needle: "## Execution Protocol", name: "utility_skill:executing_plans:protocol" },
         { file: runtimeFile("skills/executing-plans/SKILL.md"), needle: "## Wave Checklist", name: "utility_skill:executing_plans:waves" },
+        { file: runtimeFile("skills/verification-before-completion/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:verification_before_completion:hard_gate" },
+        { file: runtimeFile("skills/verification-before-completion/SKILL.md"), needle: "## Protocol", name: "utility_skill:verification_before_completion:protocol" },
+        { file: runtimeFile("skills/finishing-a-development-branch/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:finishing_branch:hard_gate" },
+        { file: runtimeFile("skills/finishing-a-development-branch/SKILL.md"), needle: "## Protocol", name: "utility_skill:finishing_branch:protocol" },
         { file: runtimeFile("skills/context-engineering/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:context_engineering:hard_gate" },
         { file: runtimeFile("skills/context-engineering/SKILL.md"), needle: "## Context Modes", name: "utility_skill:context_engineering:modes" },
         { file: runtimeFile("skills/context-engineering/SKILL.md"), needle: "## Mode Switching Protocol", name: "utility_skill:context_engineering:switch" },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cclaw-cli",
-  "version": "0.18.0",
+  "version": "0.21.0",
   "description": "Installer-first flow toolkit for coding agents",
   "type": "module",
   "bin": {