cclaw-cli 0.15.1 → 0.21.0

package/dist/artifact-linter.js

@@ -188,6 +188,66 @@ function lineContainsVagueAdjective(text) {
     }
     return null;
 }
+const FRONTMATTER_REQUIRED_KEYS = [
+    "stage",
+    "schema_version",
+    "version",
+    "feature",
+    "locked_decisions",
+    "inputs_hash"
+];
+const PLACEHOLDER_PATTERNS = [
+    { label: "TODO", regex: /\bTODO\b/iu },
+    { label: "TBD", regex: /\bTBD\b/iu },
+    { label: "FIXME", regex: /\bFIXME\b/iu },
+    { label: "<fill-in>", regex: /<fill-in>/iu },
+    { label: "<your-*-here>", regex: /<your-[^>]*-here>/iu },
+    { label: "xxx", regex: /\bxxx\b/iu },
+    { label: "ellipsis", regex: /\.{3}/u }
+];
+const SCOPE_REDUCTION_PATTERNS = [
+    { label: "v1", regex: /\bv1\b/iu },
+    { label: "for now", regex: /\bfor now\b/iu },
+    { label: "later", regex: /\blater\b/iu },
+    { label: "temporary", regex: /\btemporary\b/iu },
+    { label: "placeholder", regex: /\bplaceholder\b/iu },
+    { label: "mock for now", regex: /\bmock for now\b/iu },
+    { label: "hardcoded for now", regex: /\bhardcoded for now\b/iu },
+    { label: "will improve later", regex: /\bwill improve later\b/iu }
+];
+function parseFrontmatter(markdown) {
+    const lines = markdown.split(/\r?\n/);
+    if (lines[0]?.trim() !== "---") {
+        return { hasFrontmatter: false, values: {} };
+    }
+    const endIndex = lines.findIndex((line, index) => index > 0 && line.trim() === "---");
+    if (endIndex < 0) {
+        return { hasFrontmatter: false, values: {} };
+    }
+    const values = {};
+    for (const line of lines.slice(1, endIndex)) {
+        const match = /^([A-Za-z0-9_-]+)\s*:\s*(.*)$/u.exec(line.trim());
+        if (!match)
+            continue;
+        const key = match[1];
+        const value = match[2].trim();
+        values[key] = value;
+    }
+    return { hasFrontmatter: true, values };
+}
+function extractDecisionIds(text) {
+    const ids = text.match(/\bD-\d+\b/gu) ?? [];
+    return [...new Set(ids)];
+}
+function collectPatternHits(text, patterns) {
+    const hits = [];
+    for (const pattern of patterns) {
+        if (pattern.regex.test(text)) {
+            hits.push(pattern.label);
+        }
+    }
+    return hits;
+}
 function validateSectionBody(sectionBody, rule, sectionName) {
     const bodyLines = sectionBody.split(/\r?\n/).map((line) => line.trim());
     const meaningful = meaningfulLineCount(sectionBody);
@@ -336,6 +396,37 @@ export async function lintArtifact(projectRoot, stage) {
     }
     const raw = await fs.readFile(absFile, "utf8");
     const sections = extractH2Sections(raw);
+    const parsedFrontmatter = parseFrontmatter(raw);
+    const frontmatterMissingKeys = FRONTMATTER_REQUIRED_KEYS.filter((key) => {
+        const value = parsedFrontmatter.values[key];
+        return typeof value !== "string" || value.trim().length === 0;
+    });
+    const frontmatterStage = parsedFrontmatter.values.stage?.replace(/^['"]|['"]$/gu, "");
+    const frontmatterSchemaVersion = parsedFrontmatter.values.schema_version?.replace(/^['"]|['"]$/gu, "");
+    const frontmatterInputsHash = parsedFrontmatter.values.inputs_hash?.replace(/^['"]|['"]$/gu, "");
+    const frontmatterValid = parsedFrontmatter.hasFrontmatter &&
+        frontmatterMissingKeys.length === 0 &&
+        frontmatterStage === stage &&
+        frontmatterSchemaVersion === "1" &&
+        /^sha256:(?:pending|[a-f0-9]{64})$/iu.test(frontmatterInputsHash ?? "");
+    const requireFrontmatter = parsedFrontmatter.hasFrontmatter;
+    findings.push({
+        section: "Frontmatter",
+        required: requireFrontmatter,
+        rule: "Artifact must include frontmatter keys (stage, schema_version=1, version, feature, locked_decisions, inputs_hash=sha256:pending|sha256:<64hex>).",
+        found: parsedFrontmatter.hasFrontmatter ? frontmatterValid : true,
+        details: !parsedFrontmatter.hasFrontmatter
+            ? "Legacy artifact without YAML frontmatter (allowed for backward compatibility)."
+            : frontmatterMissingKeys.length > 0
+                ? `Frontmatter missing required key(s): ${frontmatterMissingKeys.join(", ")}.`
+                : frontmatterStage !== stage
+                    ? `Frontmatter stage must be "${stage}" (found "${frontmatterStage ?? "(missing)"}").`
+                    : frontmatterSchemaVersion !== "1"
+                        ? `Frontmatter schema_version must be "1" (found "${frontmatterSchemaVersion ?? "(missing)"}").`
+                        : !/^sha256:(?:pending|[a-f0-9]{64})$/iu.test(frontmatterInputsHash ?? "")
+                            ? "Frontmatter inputs_hash must be sha256:pending or sha256:<64 hex chars>."
+                            : "Frontmatter integrity checks passed."
+    });
     const isTrivialOverride = schema.trivialOverrideSections &&
         schema.trivialOverrideSections.length > 0 &&
         /trivial.change|mini.design|escape.hatch/iu.test(raw);
@@ -362,6 +453,69 @@ export async function lintArtifact(projectRoot, stage) {
                 : validation.details
         });
     }
+    if (stage === "plan") {
+        const strictPlanGuards = parsedFrontmatter.hasFrontmatter ||
+            headingPresent(sections, "No-Placeholder Scan") ||
+            headingPresent(sections, "No Scope Reduction Language Scan") ||
+            headingPresent(sections, "Locked Decision Coverage");
+        const taskListBody = sectionBodyByName(sections, "Task List") ?? raw;
+        const placeholderHits = collectPatternHits(taskListBody, PLACEHOLDER_PATTERNS);
+        findings.push({
+            section: "No Placeholder Enforcement",
+            required: strictPlanGuards,
+            rule: "Task List must not contain placeholders (TODO/TBD/FIXME/<fill-in>/<your-*-here>/xxx/ellipsis).",
+            found: placeholderHits.length === 0,
+            details: placeholderHits.length === 0
+                ? "No placeholder tokens detected in Task List."
+                : `Detected placeholder token(s) in Task List: ${placeholderHits.join(", ")}.`
+        });
+        const scopePath = path.join(projectRoot, RUNTIME_ROOT, "artifacts", "02-scope.md");
+        const scopeRaw = (await exists(scopePath)) ? await fs.readFile(scopePath, "utf8") : "";
+        const scopeDecisionIds = extractDecisionIds(scopeRaw);
+        const missingDecisionRefs = scopeDecisionIds.filter((id) => !raw.includes(id));
+        findings.push({
+            section: "Locked Decision Traceability",
+            required: strictPlanGuards && scopeDecisionIds.length > 0,
+            rule: "Every locked decision ID (D-XX) in scope must be referenced in plan.",
+            found: missingDecisionRefs.length === 0,
+            details: scopeDecisionIds.length === 0
+                ? "No D-XX IDs found in scope artifact; traceability check skipped."
+                : missingDecisionRefs.length === 0
+                    ? `All ${scopeDecisionIds.length} scope decision IDs are referenced in plan.`
+                    : `Missing scope decision reference(s) in plan: ${missingDecisionRefs.join(", ")}.`
+        });
+        const reductionHits = collectPatternHits(taskListBody, SCOPE_REDUCTION_PATTERNS);
+        findings.push({
+            section: "No Scope Reduction Language",
+            required: strictPlanGuards && scopeDecisionIds.length > 0,
+            rule: "Task List must not include scope-reduction language when locked decisions exist.",
+            found: reductionHits.length === 0,
+            details: scopeDecisionIds.length === 0
+                ? "No locked decisions found in scope artifact; scope-reduction scan is advisory."
+                : reductionHits.length === 0
+                    ? "No scope-reduction phrases detected in Task List."
+                    : `Detected scope-reduction phrase(s) in Task List: ${reductionHits.join(", ")}.`
+        });
+    }
+    if (stage === "scope") {
+        const strictScopeGuards = parsedFrontmatter.hasFrontmatter ||
+            headingPresent(sections, "Locked Decisions (D-XX)");
+        const scopeSections = [
+            sectionBodyByName(sections, "In Scope / Out of Scope") ?? "",
+            sectionBodyByName(sections, "Scope Summary") ?? "",
+            sectionBodyByName(sections, "Locked Decisions (D-XX)") ?? ""
+        ].join("\n");
+        const reductionHits = collectPatternHits(scopeSections, SCOPE_REDUCTION_PATTERNS);
+        findings.push({
+            section: "No Scope Reduction Language",
+            required: strictScopeGuards,
+            rule: "Scope boundary sections must not use reduction placeholders (`v1`, `for now`, `later`, `temporary`, `placeholder`).",
+            found: reductionHits.length === 0,
+            details: reductionHits.length === 0
+                ? "No scope-reduction phrases detected in scope boundary sections."
+                : `Detected scope-reduction phrase(s): ${reductionHits.join(", ")}.`
+        });
+    }
     const passed = findings.every((f) => !f.required || f.found);
     return { stage, file: relFile, passed, findings };
 }

package/dist/cli.js

@@ -122,7 +122,8 @@ function buildInitSurfacePreview(harnesses) {
         ".cclaw/rules/**",
         ".cclaw/adapters/*.md",
         ".cclaw/custom-skills/README.md",
-        ".cclaw/features/**",
+        ".cclaw/worktrees/**",
+        ".cclaw/features/** (legacy snapshots, read-only migration)",
         ".cclaw/runs/**",
         ".cclaw/artifacts/**",
         ".cclaw/knowledge.jsonl",

package/dist/constants.d.ts

@@ -4,9 +4,9 @@ export declare const RUNTIME_ROOT = ".cclaw";
 export declare const CCLAW_VERSION = "0.1.1";
 export declare const FLOW_VERSION = "1.0.0";
 export declare const DEFAULT_HARNESSES: HarnessId[];
-export declare const REQUIRED_DIRS: readonly [".cclaw", ".cclaw/commands", ".cclaw/skills", ".cclaw/contexts", ".cclaw/templates", ".cclaw/artifacts", ".cclaw/features", ".cclaw/state", ".cclaw/runs", ".cclaw/rules", ".cclaw/adapters", ".cclaw/agents", ".cclaw/hooks", ".cclaw/custom-skills"];
+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", "rewind-ack"];
+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

@@ -15,7 +15,7 @@ export const REQUIRED_DIRS = [
     `${RUNTIME_ROOT}/contexts`,
     `${RUNTIME_ROOT}/templates`,
     `${RUNTIME_ROOT}/artifacts`,
-    `${RUNTIME_ROOT}/features`,
+    `${RUNTIME_ROOT}/worktrees`,
     `${RUNTIME_ROOT}/state`,
     `${RUNTIME_ROOT}/runs`,
     `${RUNTIME_ROOT}/rules`,
@@ -54,6 +54,7 @@ export const COMMAND_FILE_ORDER = [
 export const UTILITY_COMMANDS = [
     "learn",
     "next",
+    "ideate",
     "view",
     "status",
     "tree",
@@ -62,9 +63,9 @@ export const UTILITY_COMMANDS = [
     "feature",
     "tdd-log",
     "retro",
+    "compound",
     "archive",
-    "rewind",
-    "rewind-ack"
+    "rewind"
 ];
 export const SUBAGENT_SKILL_FOLDERS = [
     "subagent-dev",

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/contracts.js

@@ -34,7 +34,7 @@ ${schema.hardGate}
 2. Resolve active artifact root: \`.cclaw/artifacts/\`.
 3. Load required upstream artifacts for this stage:
 ${hydrationLines}
-4. Stream \`.cclaw/knowledge.jsonl\` and apply relevant JSON-line entries (strict schema: type, trigger, action, confidence, domain, stage, created, project).
+4. Stream \`.cclaw/knowledge.jsonl\` and apply relevant JSON-line entries (strict schema: type, trigger, action, confidence, domain, stage, origin_stage, origin_feature, frequency, universality, maturity, created, first_seen_ts, last_seen_ts, project).
 5. Write stage output to ${writeStepPaths}.
 6. Do NOT copy artifacts into \`.cclaw/runs/\`; archival is handled by \`/cc-ops archive\` (agent-facing wrapper over archive runtime).
 

package/dist/content/doctor-references.js

@@ -11,7 +11,7 @@ Reference docs for \`cclaw doctor\` checks.
 - \`hooks-and-lifecycle.md\` - hook wiring and harness lifecycle integration
 - \`harness-and-routing.md\` - harness shims, AGENTS/CLAUDE routing blocks, cursor rule
 - \`state-and-gates.md\` - flow-state integrity and gate evidence contracts
-- \`delegation-and-preamble.md\` - mandatory delegations and preamble budget controls
+- \`delegation-and-preamble.md\` - mandatory delegations and lightweight announce discipline
 - \`traceability.md\` - spec/plan/tdd trace matrix expectations
 - \`tooling-capabilities.md\` - local runtime prerequisites (bash/node/python/jq)
 - \`config-and-policy.md\` - config schema, rules policy, and validation references
@@ -84,18 +84,19 @@ Reference docs for \`cclaw doctor\` checks.
 - mandatory delegations for the current stage must be completed or waived
 - waivers should include an explicit reason
 - stale entries from previous runs are ignored by current-run checks
+- delegation entries use span-compatible fields (\`spanId\`, \`startTs\`, \`endTs\`, \`retryCount\`, \`evidenceRefs\`)
 
-## Preamble budget contract
+## Announce discipline contract
 
-- preamble events are logged to \`.cclaw/state/preamble-log.jsonl\`
-- repeated entries inside cooldown windows indicate noisy preamble behavior
-- in TDD wave mode, emit once per wave unless plan materially changes
+- no dedicated preamble runtime log is required
+- substantial turns should still start with a concise announce (stage + goal + next action)
+- do not spam repeated announces when intent did not change
 
 ## Typical fixes
 
 1. Append missing delegation records with \`completed\` or \`waived\` status.
 2. Record harness-limitation waivers when native delegation is unavailable.
-3. Reduce repeated preamble emissions and keep logs structured (\`ts/stage/trigger/hash\`).
+3. Keep announces concise and only refresh when plan/risk materially changes.
 `,
     "traceability.md": `# Traceability
 

package/dist/content/feature-command.js

@@ -1,66 +1,71 @@
 import { RUNTIME_ROOT } from "../constants.js";
-const FEATURE_SKILL_FOLDER = "feature-workspaces";
-const FEATURE_SKILL_NAME = "feature-workspaces";
+const FEATURE_SKILL_FOLDER = "using-git-worktrees";
+const FEATURE_SKILL_NAME = "using-git-worktrees";
 function activeFeaturePath() {
     return `${RUNTIME_ROOT}/state/active-feature.json`;
 }
-function featuresRoot() {
-    return `${RUNTIME_ROOT}/features`;
+function worktreeRegistryPath() {
+    return `${RUNTIME_ROOT}/state/worktrees.json`;
 }
-function runtimeArtifactsPath() {
-    return `${RUNTIME_ROOT}/artifacts`;
+function managedWorktreesRoot() {
+    return `${RUNTIME_ROOT}/worktrees`;
 }
-function runtimeStatePath() {
-    return `${RUNTIME_ROOT}/state`;
+function legacyFeaturesRoot() {
+    return `${RUNTIME_ROOT}/features`;
 }
 export function featureCommandContract() {
     return `# /cc-ops feature
 
 ## Purpose
 
-Manage multi-feature workspaces without flow-state/artifact collisions.
-
-The active runtime remains:
-- \`${runtimeArtifactsPath()}\` (active artifacts)
-- \`${runtimeStatePath()}\` (active state)
+Manage parallel feature execution using git worktrees (git-native isolation).
 
-Feature snapshots live under \`${featuresRoot()}/<feature-id>/\`.
+Runtime state/artifacts are **never** copied between features anymore. Isolation is branch/worktree-level.
 
 ## HARD-GATE
 
-- Never overwrite another feature snapshot silently.
-- Before switching feature, snapshot the current active runtime first.
-- Keep \`${activeFeaturePath()}\` as the single source of "current feature".
+- Do not mutate feature context by copying \`${RUNTIME_ROOT}/artifacts\` or \`${RUNTIME_ROOT}/state\` between feature IDs.
+- Use \`git worktree add\` for new feature execution paths.
+- Keep \`${activeFeaturePath()}\` + \`${worktreeRegistryPath()}\` as the feature routing source of truth.
+- Treat \`${legacyFeaturesRoot()}/\` as read-only migration data.
 
 ## Subcommands
 
 ### \`/cc-ops feature status\`
-Show active feature id and snapshot location.
+Show:
+- active feature id from \`${activeFeaturePath()}\`
+- resolved worktree entry from \`${worktreeRegistryPath()}\`
+- active workspace path
 
 ### \`/cc-ops feature list\`
-List all feature ids in \`${featuresRoot()}/\` (directory names).
+List registered feature worktrees from \`${worktreeRegistryPath()}\` and mark active entry.
 
 ### \`/cc-ops feature new <feature-id>\`
-Create \`${featuresRoot()}/<feature-id>/artifacts\` and \`${featuresRoot()}/<feature-id>/state\`.
+1. Validate \`feature-id\` (lowercase slug, letters/numbers/dashes).
+2. Create worktree under \`${managedWorktreesRoot()}/<feature-id>\`.
+3. Create/switch branch using \`git worktree add\` (prefer \`feature/<feature-id>\` naming).
+4. Register entry in \`${worktreeRegistryPath()}\`.
 
-Optional flag:
-- \`--clone-active\`: clone current active runtime into the new feature snapshot.
+Optional flags:
+- \`--clone-active\`: seed from active branch HEAD (default behavior).
+- \`--switch\`: mark new feature as active after registration.
 
 ### \`/cc-ops feature switch <feature-id>\`
-1. Snapshot current active runtime into \`${featuresRoot()}/<active>/\`.
-2. Restore target snapshot from \`${featuresRoot()}/<feature-id>/\` into active runtime:
-   - \`${runtimeArtifactsPath()}\`
-   - \`${runtimeStatePath()}\` (preserve \`active-feature.json\`)
-3. Update \`${activeFeaturePath()}\` with \`activeFeature=<feature-id>\`.
+1. Validate that \`<feature-id>\` exists in \`${worktreeRegistryPath()}\`.
+2. Update \`${activeFeaturePath()}\`.
+3. Print target worktree path and instruct the operator/agent to continue from that workspace root.
+
+## Migration note
 
-If the target snapshot is empty, initialize runtime as a fresh flow.
+Legacy snapshot folders under \`${legacyFeaturesRoot()}/\` are supported as read-only references during migration and should not be used for new execution.
 
 ## Output
 
 Always print:
 - active feature before
 - active feature after
-- whether snapshot/restore changed files
+- target workspace path
+- workspace source (\`git-worktree\` | \`workspace\` | \`legacy-snapshot\`)
 
 ## Primary skill
 
@@ -70,51 +75,49 @@ Always print:
 export function featureCommandSkillMarkdown() {
     return `---
 name: ${FEATURE_SKILL_NAME}
-description: "Manage cclaw multi-feature workspaces (status/list/new/switch) while preserving active flow runtime."
+description: "Manage cclaw feature isolation using git worktrees (status/list/new/switch)."
 ---
 
-# /cc-ops feature — Feature Workspace Manager
+# /cc-ops feature — Git Worktree Manager
 
 ## HARD-GATE
 
-Do not switch feature by editing only \`active-feature.json\`. A valid switch must snapshot current runtime and restore target runtime.
+Do not implement feature switching by copying runtime files between feature IDs. Use git worktrees and registry updates only.
 
 ## Paths
 
 - Active pointer: \`${activeFeaturePath()}\`
-- Feature snapshots: \`${featuresRoot()}/<feature-id>/\`
-- Active runtime artifacts: \`${runtimeArtifactsPath()}\`
-- Active runtime state: \`${runtimeStatePath()}\`
+- Worktree registry: \`${worktreeRegistryPath()}\`
+- Managed worktree root: \`${managedWorktreesRoot()}\`
+- Legacy snapshots (read-only): \`${legacyFeaturesRoot()}\`
 
 ## Protocol
 
 ### status
 1. Read \`${activeFeaturePath()}\`.
-2. Print active feature id and its snapshot folder.
+2. Resolve active entry in \`${worktreeRegistryPath()}\`.
+3. Print active id + workspace path + source.
 
 ### list
-1. Enumerate directories in \`${featuresRoot()}/\`.
+1. Enumerate entries in \`${worktreeRegistryPath()}\`.
 2. Mark the active one.
+3. Highlight any \`legacy-snapshot\` entries as migration-only.
 
-### new <feature-id> [--clone-active]
-1. Validate \`feature-id\` (lowercase slug, letters/numbers/dashes).
-2. Create snapshot dirs:
-   - \`${featuresRoot()}/<feature-id>/artifacts\`
-   - \`${featuresRoot()}/<feature-id>/state\`
-3. If \`--clone-active\`: copy active runtime artifacts/state into the new snapshot.
-4. Do not change active feature unless the user explicitly requests switch.
+### new <feature-id> [--clone-active] [--switch]
+1. Validate \`feature-id\` and ensure not already registered.
+2. Run \`git worktree add\` to create \`${managedWorktreesRoot()}/<feature-id>\`.
+3. Register entry in \`${worktreeRegistryPath()}\` with branch + path + source.
+4. If \`--switch\`, update \`${activeFeaturePath()}\`.
 
 ### switch <feature-id>
-1. Read current active feature id.
-2. Snapshot current runtime into current feature snapshot.
-3. Restore target snapshot into active runtime.
-4. Update \`${activeFeaturePath()}\`.
-5. Report stage/run after restore (\`flow-state.json\`).
+1. Validate target exists in \`${worktreeRegistryPath()}\`.
+2. Update \`${activeFeaturePath()}\`.
+3. Report target path and require continuation from that workspace root.
 
 ## Safety checks
 
 - If target feature does not exist: block and suggest \`/cc-ops feature new <id>\`.
-- If snapshot copy fails: abort switch, keep current active feature unchanged.
-- Preserve global pointer file \`active-feature.json\` when restoring state.
+- If \`git worktree add\` fails: do not write partial registry updates.
+- If active feature maps to \`legacy-snapshot\`, report read-only migration warning.
 `;
 }

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
@@ -75,12 +76,13 @@ Read-only subcommands:
 - \`/cc-view diff\` - before/after flow-state diff map
 
 Operations subcommands:
-- \`/cc-ops feature ...\` - multi-feature workspace management
+- \`/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
+- \`/cc-ops rewind --ack ...\` - clear stale stage markers after redo
 
 Stage order remains canonical:
 \`brainstorm -> scope -> design -> spec -> plan -> tdd -> review -> ship\`

package/dist/content/hooks.js

@@ -457,7 +457,7 @@ if [ -n "$ROUTING_MISSING" ]; then
 fi
 
 # --- Build context message ---
-CTX="cclaw loaded. Flow: stage=$STAGE ($COMPLETED/8 completed, run=$ACTIVE_RUN, feature=$ACTIVE_FEATURE). Active artifacts: ${RUNTIME_ROOT}/artifacts/. Feature snapshots: ${RUNTIME_ROOT}/features/$ACTIVE_FEATURE/. Learnings: $LEARNINGS_COUNT entries."
+CTX="cclaw loaded. Flow: stage=$STAGE ($COMPLETED/8 completed, run=$ACTIVE_RUN, feature=$ACTIVE_FEATURE). Active artifacts: ${RUNTIME_ROOT}/artifacts/. Feature registry: ${RUNTIME_ROOT}/state/worktrees.json (managed roots: ${RUNTIME_ROOT}/worktrees/). Learnings: $LEARNINGS_COUNT entries."
 if [ -n "$VERSION_NOTE" ]; then
   CTX="$CTX
 $VERSION_NOTE"
@@ -496,7 +496,7 @@ To disable suggestions persistently set ${RUNTIME_ROOT}/state/suggestion-memory.
 fi
 if [ -n "$STALE_STAGES" ]; then
   CTX="$CTX
-Stale stages pending acknowledgement: $STALE_STAGES (use /cc-ops rewind-ack <stage> after redo)."
+Stale stages pending acknowledgement: $STALE_STAGES (use /cc-ops rewind --ack <stage> after redo)."
 fi
 if [ -n "$KNOWLEDGE_DIGEST" ]; then
   CTX="$CTX

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 |
+`;
+}