cclaw-cli 0.15.1 → 0.21.0

package/dist/feature-system.js

@@ -1,36 +1,43 @@
 import fs from "node:fs/promises";
 import path from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
 import { RUNTIME_ROOT } from "./constants.js";
 import { ensureDir, exists, writeFileSafe } from "./fs-utils.js";
-const FEATURES_DIR_REL_PATH = `${RUNTIME_ROOT}/features`;
+const execFileAsync = promisify(execFile);
+const WORKTREES_DIR_REL_PATH = `${RUNTIME_ROOT}/worktrees`;
+const LEGACY_FEATURES_DIR_REL_PATH = `${RUNTIME_ROOT}/features`;
 const ACTIVE_FEATURE_META_REL_PATH = `${RUNTIME_ROOT}/state/active-feature.json`;
+const WORKTREE_REGISTRY_REL_PATH = `${RUNTIME_ROOT}/state/worktrees.json`;
 const DEFAULT_FEATURE_ID = "default";
+const WORKTREE_REGISTRY_SCHEMA_VERSION = 1;
 const FEATURE_ID_PATTERN = /^[a-z0-9][a-z0-9-]{0,63}$/u;
-const FEATURE_STATE_EXCLUDE_FROM_SNAPSHOT = new Set([
-    "active-feature.json",
-    ".flow-state.lock",
-    ".delegation.lock"
-]);
-function featuresRoot(projectRoot) {
-    return path.join(projectRoot, FEATURES_DIR_REL_PATH);
+function worktreesRoot(projectRoot) {
+    return path.join(projectRoot, WORKTREES_DIR_REL_PATH);
 }
-function runtimeArtifactsRoot(projectRoot) {
-    return path.join(projectRoot, RUNTIME_ROOT, "artifacts");
-}
-function runtimeStateRoot(projectRoot) {
-    return path.join(projectRoot, RUNTIME_ROOT, "state");
+function legacyFeaturesRoot(projectRoot) {
+    return path.join(projectRoot, LEGACY_FEATURES_DIR_REL_PATH);
 }
 export function activeFeatureMetaPath(projectRoot) {
     return path.join(projectRoot, ACTIVE_FEATURE_META_REL_PATH);
 }
+export function worktreeRegistryPath(projectRoot) {
+    return path.join(projectRoot, WORKTREE_REGISTRY_REL_PATH);
+}
 export function featureRootPath(projectRoot, featureId) {
-    return path.join(featuresRoot(projectRoot), featureId);
+    return path.join(worktreesRoot(projectRoot), normalizedFeatureId(featureId));
 }
 export function featureArtifactsPath(projectRoot, featureId) {
-    return path.join(featureRootPath(projectRoot, featureId), "artifacts");
+    return path.join(featureRootPath(projectRoot, featureId), RUNTIME_ROOT, "artifacts");
 }
 export function featureStatePath(projectRoot, featureId) {
-    return path.join(featureRootPath(projectRoot, featureId), "state");
+    return path.join(featureRootPath(projectRoot, featureId), RUNTIME_ROOT, "state");
+}
+export function resolveFeatureWorkspacePath(projectRoot, entry) {
+    if (entry.path === ".") {
+        return projectRoot;
+    }
+    return path.resolve(projectRoot, entry.path);
 }
 function normalizedFeatureId(value) {
     const candidate = value
@@ -45,64 +52,134 @@ function normalizedFeatureId(value) {
     const clipped = candidate.slice(0, 64);
     return FEATURE_ID_PATTERN.test(clipped) ? clipped : DEFAULT_FEATURE_ID;
 }
-async function clearDirectory(dirPath, preserveTargetEntries = new Set()) {
-    await ensureDir(dirPath);
-    let entries;
-    try {
-        entries = await fs.readdir(dirPath, { withFileTypes: true });
+function toRelativePath(projectRoot, absolutePath) {
+    const rel = path.relative(projectRoot, absolutePath);
+    if (!rel || rel.trim().length === 0) {
+        return ".";
     }
-    catch {
-        return;
+    return rel.split(path.sep).join("/");
+}
+function sanitizeWorkspaceSource(value) {
+    if (value === "git-worktree" || value === "workspace" || value === "legacy-snapshot") {
+        return value;
+    }
+    return "workspace";
+}
+function sanitizeRegistryEntry(raw) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        return null;
     }
+    const typed = raw;
+    const featureIdRaw = typeof typed.featureId === "string" ? typed.featureId : "";
+    const featureId = normalizedFeatureId(featureIdRaw);
+    if (!FEATURE_ID_PATTERN.test(featureId)) {
+        return null;
+    }
+    const branch = typeof typed.branch === "string" && typed.branch.trim().length > 0
+        ? typed.branch.trim()
+        : (featureId === DEFAULT_FEATURE_ID ? "workspace/default" : `workspace/${featureId}`);
+    const pathRaw = typeof typed.path === "string" ? typed.path.trim() : "";
+    const workspacePath = pathRaw.length > 0 ? pathRaw : ".";
+    const createdAt = typeof typed.createdAt === "string" && typed.createdAt.trim().length > 0
+        ? typed.createdAt.trim()
+        : new Date().toISOString();
+    return {
+        featureId,
+        branch,
+        path: workspacePath,
+        source: sanitizeWorkspaceSource(typed.source),
+        createdAt
+    };
+}
+function dedupeEntries(entries) {
+    const byId = new Map();
     for (const entry of entries) {
-        if (preserveTargetEntries.has(entry.name)) {
-            continue;
+        if (!byId.has(entry.featureId)) {
+            byId.set(entry.featureId, entry);
         }
-        await fs.rm(path.join(dirPath, entry.name), { recursive: true, force: true });
     }
+    return [...byId.values()].sort((a, b) => a.featureId.localeCompare(b.featureId));
 }
-async function copyDirectoryContents(sourceDir, targetDir, options = {}) {
-    const exclude = options.exclude ?? new Set();
-    const preserveTargetEntries = options.preserveTargetEntries ?? new Set();
-    await ensureDir(targetDir);
-    await clearDirectory(targetDir, preserveTargetEntries);
-    if (!(await exists(sourceDir))) {
-        return;
-    }
-    let entries;
+async function runGit(projectRoot, args) {
     try {
-        entries = await fs.readdir(sourceDir, { withFileTypes: true });
+        const { stdout, stderr } = await execFileAsync("git", args, { cwd: projectRoot });
+        return { ok: true, stdout: stdout.trim(), stderr: stderr.trim() };
     }
-    catch {
-        return;
+    catch (error) {
+        const err = error;
+        return {
+            ok: false,
+            stdout: typeof err.stdout === "string" ? err.stdout.trim() : "",
+            stderr: typeof err.stderr === "string" && err.stderr.trim().length > 0
+                ? err.stderr.trim()
+                : (err.message ?? "git command failed")
+        };
     }
-    for (const entry of entries) {
-        if (exclude.has(entry.name)) {
-            continue;
-        }
-        const from = path.join(sourceDir, entry.name);
-        const to = path.join(targetDir, entry.name);
-        if (entry.isDirectory()) {
-            await fs.cp(from, to, { recursive: true, force: true });
-            continue;
-        }
-        if (entry.isFile()) {
-            await fs.copyFile(from, to);
-        }
+}
+async function isGitRepository(projectRoot) {
+    const result = await runGit(projectRoot, ["rev-parse", "--is-inside-work-tree"]);
+    return result.ok && result.stdout === "true";
+}
+async function currentBranch(projectRoot) {
+    const result = await runGit(projectRoot, ["rev-parse", "--abbrev-ref", "HEAD"]);
+    return result.ok && result.stdout.length > 0 ? result.stdout : "HEAD";
+}
+async function defaultStartPoint(projectRoot) {
+    const remoteHead = await runGit(projectRoot, ["symbolic-ref", "--short", "refs/remotes/origin/HEAD"]);
+    if (remoteHead.ok && remoteHead.stdout.length > 0) {
+        return remoteHead.stdout.replace(/^origin\//u, "");
     }
+    return currentBranch(projectRoot);
+}
+function buildDefaultEntry(source, branch) {
+    return {
+        featureId: DEFAULT_FEATURE_ID,
+        branch,
+        path: ".",
+        source,
+        createdAt: new Date().toISOString()
+    };
 }
-async function dirHasEntries(dirPath, exclude = new Set()) {
-    if (!(await exists(dirPath))) {
-        return false;
+async function readRegistry(projectRoot) {
+    const filePath = worktreeRegistryPath(projectRoot);
+    if (!(await exists(filePath))) {
+        return {
+            schemaVersion: WORKTREE_REGISTRY_SCHEMA_VERSION,
+            updatedAt: new Date().toISOString(),
+            entries: []
+        };
     }
     try {
-        const entries = await fs.readdir(dirPath, { withFileTypes: true });
-        return entries.some((entry) => !exclude.has(entry.name));
+        const parsed = JSON.parse(await fs.readFile(filePath, "utf8"));
+        const entriesRaw = Array.isArray(parsed.entries) ? parsed.entries : [];
+        const entries = dedupeEntries(entriesRaw
+            .map((entry) => sanitizeRegistryEntry(entry))
+            .filter((entry) => entry !== null));
+        const updatedAt = typeof parsed.updatedAt === "string" && parsed.updatedAt.trim().length > 0
+            ? parsed.updatedAt.trim()
+            : new Date().toISOString();
+        return {
+            schemaVersion: WORKTREE_REGISTRY_SCHEMA_VERSION,
+            updatedAt,
+            entries
+        };
     }
     catch {
-        return false;
+        return {
+            schemaVersion: WORKTREE_REGISTRY_SCHEMA_VERSION,
+            updatedAt: new Date().toISOString(),
+            entries: []
+        };
     }
 }
+async function writeRegistry(projectRoot, registry) {
+    const normalized = {
+        schemaVersion: WORKTREE_REGISTRY_SCHEMA_VERSION,
+        updatedAt: registry.updatedAt,
+        entries: dedupeEntries(registry.entries)
+    };
+    await writeFileSafe(worktreeRegistryPath(projectRoot), `${JSON.stringify(normalized, null, 2)}\n`);
+}
 async function readActiveFeatureMetaInternal(projectRoot) {
     const filePath = activeFeatureMetaPath(projectRoot);
     if (!(await exists(filePath))) {
@@ -138,84 +215,94 @@ async function writeActiveFeatureMeta(projectRoot, meta) {
     };
     await writeFileSafe(activeFeatureMetaPath(projectRoot), `${JSON.stringify(normalized, null, 2)}\n`);
 }
-async function ensureFeatureSnapshot(projectRoot, featureId) {
-    const id = normalizedFeatureId(featureId);
-    await ensureDir(featureArtifactsPath(projectRoot, id));
-    await ensureDir(featureStatePath(projectRoot, id));
+function registryHasFeature(registry, featureId) {
+    return registry.entries.some((entry) => entry.featureId === featureId);
 }
-export async function readActiveFeature(projectRoot) {
-    const meta = await readActiveFeatureMetaInternal(projectRoot);
-    return normalizedFeatureId(meta.activeFeature);
+function findEntry(registry, featureId) {
+    return registry.entries.find((entry) => entry.featureId === featureId);
 }
-export async function listFeatures(projectRoot) {
-    const root = featuresRoot(projectRoot);
+async function listLegacySnapshotIds(projectRoot) {
+    const root = legacyFeaturesRoot(projectRoot);
     if (!(await exists(root))) {
         return [];
     }
-    let entries;
     try {
-        entries = await fs.readdir(root, { withFileTypes: true });
+        const entries = await fs.readdir(root, { withFileTypes: true });
+        return entries
+            .filter((entry) => entry.isDirectory() && FEATURE_ID_PATTERN.test(entry.name))
+            .map((entry) => entry.name)
+            .sort((a, b) => a.localeCompare(b));
     }
     catch {
         return [];
     }
-    return entries
-        .filter((entry) => entry.isDirectory() && FEATURE_ID_PATTERN.test(entry.name))
-        .map((entry) => entry.name)
-        .sort((a, b) => a.localeCompare(b));
 }
-export async function ensureFeatureSystem(projectRoot) {
-    await ensureDir(featuresRoot(projectRoot));
-    await ensureDir(runtimeArtifactsRoot(projectRoot));
-    await ensureDir(runtimeStateRoot(projectRoot));
-    const existing = await readActiveFeatureMetaInternal(projectRoot);
-    const activeFeature = normalizedFeatureId(existing.activeFeature);
-    await ensureFeatureSnapshot(projectRoot, activeFeature);
-    const runtimeArtifactsHasData = await dirHasEntries(runtimeArtifactsRoot(projectRoot));
-    const runtimeStateHasData = await dirHasEntries(runtimeStateRoot(projectRoot), new Set(["active-feature.json"]));
-    const featureArtifactsHasData = await dirHasEntries(featureArtifactsPath(projectRoot, activeFeature));
-    const featureStateHasData = await dirHasEntries(featureStatePath(projectRoot, activeFeature));
-    if ((runtimeArtifactsHasData || runtimeStateHasData) && !featureArtifactsHasData && !featureStateHasData) {
-        await copyDirectoryContents(runtimeArtifactsRoot(projectRoot), featureArtifactsPath(projectRoot, activeFeature));
-        await copyDirectoryContents(runtimeStateRoot(projectRoot), featureStatePath(projectRoot, activeFeature), { exclude: FEATURE_STATE_EXCLUDE_FROM_SNAPSHOT });
-    }
-    else if ((!runtimeArtifactsHasData && !runtimeStateHasData) && (featureArtifactsHasData || featureStateHasData)) {
-        await copyDirectoryContents(featureArtifactsPath(projectRoot, activeFeature), runtimeArtifactsRoot(projectRoot));
-        await copyDirectoryContents(featureStatePath(projectRoot, activeFeature), runtimeStateRoot(projectRoot), { preserveTargetEntries: new Set(["active-feature.json"]) });
+async function ensureRegistryState(projectRoot) {
+    await ensureDir(path.join(projectRoot, RUNTIME_ROOT, "state"));
+    await ensureDir(worktreesRoot(projectRoot));
+    const gitRepo = await isGitRepository(projectRoot);
+    const source = gitRepo ? "git-worktree" : "workspace";
+    const branch = gitRepo ? await currentBranch(projectRoot) : "workspace/default";
+    const currentRegistry = await readRegistry(projectRoot);
+    const entries = [...currentRegistry.entries];
+    if (!entries.some((entry) => entry.featureId === DEFAULT_FEATURE_ID)) {
+        entries.push(buildDefaultEntry(source, branch));
     }
-    const normalized = {
-        activeFeature,
+    const legacyFeatureIds = await listLegacySnapshotIds(projectRoot);
+    for (const legacyId of legacyFeatureIds) {
+        if (entries.some((entry) => entry.featureId === legacyId)) {
+            continue;
+        }
+        entries.push({
+            featureId: legacyId,
+            branch: `legacy/${legacyId}`,
+            path: `${LEGACY_FEATURES_DIR_REL_PATH}/${legacyId}`,
+            source: "legacy-snapshot",
+            createdAt: new Date().toISOString()
+        });
+    }
+    const registry = {
+        schemaVersion: WORKTREE_REGISTRY_SCHEMA_VERSION,
+        updatedAt: new Date().toISOString(),
+        entries: dedupeEntries(entries)
+    };
+    await writeRegistry(projectRoot, registry);
+    const active = await readActiveFeatureMetaInternal(projectRoot);
+    const normalizedActive = registryHasFeature(registry, active.activeFeature)
+        ? active.activeFeature
+        : DEFAULT_FEATURE_ID;
+    const activeMeta = {
+        activeFeature: normalizedActive,
         updatedAt: new Date().toISOString()
     };
-    await writeActiveFeatureMeta(projectRoot, normalized);
-    return normalized;
+    await writeActiveFeatureMeta(projectRoot, activeMeta);
+    return { registry, activeMeta };
+}
+export async function ensureFeatureSystem(projectRoot) {
+    const { activeMeta } = await ensureRegistryState(projectRoot);
+    return activeMeta;
+}
+export async function readFeatureWorktreeRegistry(projectRoot) {
+    const { registry } = await ensureRegistryState(projectRoot);
+    return registry;
+}
+export async function readActiveFeature(projectRoot) {
+    const meta = await ensureFeatureSystem(projectRoot);
+    return normalizedFeatureId(meta.activeFeature);
+}
+export async function listFeatures(projectRoot) {
+    const registry = await readFeatureWorktreeRegistry(projectRoot);
+    return registry.entries.map((entry) => entry.featureId).sort((a, b) => a.localeCompare(b));
 }
 export async function syncActiveFeatureSnapshot(projectRoot) {
-    const activeFeature = await readActiveFeature(projectRoot);
-    await ensureFeatureSnapshot(projectRoot, activeFeature);
-    await copyDirectoryContents(runtimeArtifactsRoot(projectRoot), featureArtifactsPath(projectRoot, activeFeature));
-    await copyDirectoryContents(runtimeStateRoot(projectRoot), featureStatePath(projectRoot, activeFeature), {
-        exclude: FEATURE_STATE_EXCLUDE_FROM_SNAPSHOT
-    });
+    await ensureFeatureSystem(projectRoot);
 }
 export async function switchActiveFeature(projectRoot, featureId) {
-    await ensureFeatureSystem(projectRoot);
-    const current = await readActiveFeature(projectRoot);
+    const registry = await readFeatureWorktreeRegistry(projectRoot);
     const target = normalizedFeatureId(featureId);
-    if (current === target) {
-        const unchanged = {
-            activeFeature: current,
-            updatedAt: new Date().toISOString()
-        };
-        await writeActiveFeatureMeta(projectRoot, unchanged);
-        return unchanged;
-    }
-    await syncActiveFeatureSnapshot(projectRoot);
-    await ensureFeatureSnapshot(projectRoot, target);
-    await copyDirectoryContents(featureArtifactsPath(projectRoot, target), runtimeArtifactsRoot(projectRoot));
-    await copyDirectoryContents(featureStatePath(projectRoot, target), runtimeStateRoot(projectRoot), {
-        preserveTargetEntries: new Set(["active-feature.json"])
-    });
+    if (!registryHasFeature(registry, target)) {
+        throw new Error(`Feature "${target}" is not registered. Create it first with /cc-ops feature new ${target}.`);
+    }
     const nextMeta = {
         activeFeature: target,
         updatedAt: new Date().toISOString()
@@ -224,24 +311,78 @@ export async function switchActiveFeature(projectRoot, featureId) {
     return nextMeta;
 }
 export async function createFeature(projectRoot, rawFeatureId, options = {}) {
-    await ensureFeatureSystem(projectRoot);
+    const registry = await readFeatureWorktreeRegistry(projectRoot);
     const featureId = normalizedFeatureId(rawFeatureId);
-    if (featureId === DEFAULT_FEATURE_ID && rawFeatureId.trim().length > 0 && rawFeatureId.trim().toLowerCase() !== "default") {
+    if (featureId === DEFAULT_FEATURE_ID &&
+        rawFeatureId.trim().length > 0 &&
+        rawFeatureId.trim().toLowerCase() !== "default") {
         throw new Error(`Unable to create feature from "${rawFeatureId}" — use letters, numbers, and dashes.`);
     }
-    const featureDir = featureRootPath(projectRoot, featureId);
-    if (await exists(featureDir)) {
+    if (registryHasFeature(registry, featureId)) {
         throw new Error(`Feature "${featureId}" already exists.`);
     }
-    await ensureFeatureSnapshot(projectRoot, featureId);
-    if (options.cloneActive === true) {
-        const activeFeature = await readActiveFeature(projectRoot);
-        await syncActiveFeatureSnapshot(projectRoot);
-        await copyDirectoryContents(featureArtifactsPath(projectRoot, activeFeature), featureArtifactsPath(projectRoot, featureId));
-        await copyDirectoryContents(featureStatePath(projectRoot, activeFeature), featureStatePath(projectRoot, featureId));
+    const isGit = await isGitRepository(projectRoot);
+    let entry;
+    if (isGit) {
+        const workspacePath = featureRootPath(projectRoot, featureId);
+        if (await exists(workspacePath)) {
+            throw new Error(`Worktree path already exists: ${workspacePath}`);
+        }
+        await ensureDir(path.dirname(workspacePath));
+        const branch = `feature/${featureId}`;
+        const localBranchRef = `refs/heads/${branch}`;
+        const branchCheck = await runGit(projectRoot, ["show-ref", "--verify", "--quiet", localBranchRef]);
+        if (branchCheck.ok) {
+            const addExisting = await runGit(projectRoot, ["worktree", "add", workspacePath, branch]);
+            if (!addExisting.ok) {
+                throw new Error(`Unable to attach worktree for branch "${branch}": ${addExisting.stderr}`);
+            }
+        }
+        else {
+            const startPoint = options.cloneActive === false
+                ? await defaultStartPoint(projectRoot)
+                : "HEAD";
+            const addNew = await runGit(projectRoot, ["worktree", "add", "-b", branch, workspacePath, startPoint]);
+            if (!addNew.ok) {
+                throw new Error(`Unable to create worktree "${featureId}" on branch "${branch}": ${addNew.stderr}`);
+            }
+        }
+        entry = {
+            featureId,
+            branch,
+            path: toRelativePath(projectRoot, workspacePath),
+            source: "git-worktree",
+            createdAt: new Date().toISOString()
+        };
     }
+    else {
+        const workspacePath = featureRootPath(projectRoot, featureId);
+        await ensureDir(workspacePath);
+        entry = {
+            featureId,
+            branch: `workspace/${featureId}`,
+            path: toRelativePath(projectRoot, workspacePath),
+            source: "workspace",
+            createdAt: new Date().toISOString()
+        };
+    }
+    const nextRegistry = {
+        schemaVersion: WORKTREE_REGISTRY_SCHEMA_VERSION,
+        updatedAt: new Date().toISOString(),
+        entries: dedupeEntries([...registry.entries, entry])
+    };
+    await writeRegistry(projectRoot, nextRegistry);
     if (options.switchTo === true) {
         await switchActiveFeature(projectRoot, featureId);
     }
     return featureId;
 }
+export async function activeFeatureWorkspacePath(projectRoot) {
+    const registry = await readFeatureWorktreeRegistry(projectRoot);
+    const active = await readActiveFeature(projectRoot);
+    const entry = findEntry(registry, active);
+    if (!entry) {
+        return projectRoot;
+    }
+    return resolveFeatureWorkspacePath(projectRoot, entry);
+}

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,8 +18,9 @@ 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 { rewindAcknowledgeCommandContract, rewindCommandContract, rewindCommandSkillMarkdown } from "./content/rewind-command.js";
+import { rewindCommandContract, rewindCommandSkillMarkdown } from "./content/rewind-command.js";
 import { subagentDrivenDevSkill, parallelAgentsSkill } from "./content/subagents.js";
 import { sessionHooksSkillMarkdown } from "./content/session-hooks.js";
 import { sessionStartScript, stopCheckpointScript, preCompactScript, opencodePluginJs, claudeHooksJson, cursorHooksJson, codexHooksJson } from "./content/hooks.js";
@@ -204,15 +206,17 @@ 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());
     await writeFileSafe(runtimePath(projectRoot, "skills", "flow-tree", "SKILL.md"), treeCommandSkillMarkdown());
     await writeFileSafe(runtimePath(projectRoot, "skills", "flow-diff", "SKILL.md"), diffCommandSkillMarkdown());
     await writeFileSafe(runtimePath(projectRoot, "skills", "flow-ops", "SKILL.md"), opsCommandSkillMarkdown());
-    await writeFileSafe(runtimePath(projectRoot, "skills", "feature-workspaces", "SKILL.md"), featureCommandSkillMarkdown());
+    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,9 +280,9 @@ 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());
-    await writeFileSafe(runtimePath(projectRoot, "commands", "rewind-ack.md"), rewindAcknowledgeCommandContract());
 }
 function toObject(value) {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -827,10 +832,6 @@ async function ensureSessionStateFiles(projectRoot) {
     if (!(await exists(knowledgeDigestPath))) {
         await writeFileSafe(knowledgeDigestPath, "# Knowledge digest (auto-generated)\n\n(no entries yet)\n");
     }
-    const preambleLogPath = path.join(stateDir, "preamble-log.jsonl");
-    if (!(await exists(preambleLogPath))) {
-        await writeFileSafe(preambleLogPath, "");
-    }
     const tddCycleLogPath = path.join(stateDir, "tdd-cycle-log.jsonl");
     if (!(await exists(tddCycleLogPath))) {
         await writeFileSafe(tddCycleLogPath, "");
@@ -945,7 +946,8 @@ async function cleanLegacyArtifacts(projectRoot) {
         "session-guidelines",
         "security-review",
         "documentation",
-        "browser-qa-testing"
+        "browser-qa-testing",
+        "feature-workspaces"
     ]) {
         try {
             await fs.rm(runtimePath(projectRoot, "skills", legacyFolder), {

package/dist/policy.js

@@ -86,10 +86,13 @@ export async function policyChecks(projectRoot, options = {}) {
     const utilitySkillChecks = [
         { file: runtimeFile("skills/learnings/SKILL.md"), needle: "strict JSONL schema", name: "utility_skill:learnings:jsonl_schema" },
         { file: runtimeFile("skills/learnings/SKILL.md"), needle: "knowledge.jsonl", name: "utility_skill:learnings:jsonl_store" },
-        { file: runtimeFile("skills/learnings/SKILL.md"), needle: "type, trigger, action, confidence, domain, stage, created, project", name: "utility_skill:learnings:field_order" },
+        { file: runtimeFile("skills/learnings/SKILL.md"), needle: "type, trigger, action, confidence, domain, stage, origin_stage, origin_feature, frequency, universality, maturity, created, first_seen_ts, last_seen_ts, project", name: "utility_skill:learnings:field_order" },
         { 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" },
@@ -99,16 +102,18 @@ export async function policyChecks(projectRoot, options = {}) {
         { file: runtimeFile("skills/flow-diff/SKILL.md"), needle: "## Protocol", name: "utility_skill:diff:protocol" },
         { file: runtimeFile("skills/flow-diff/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:diff:hard_gate" },
         { file: runtimeFile("commands/feature.md"), needle: "## Subcommands", name: "utility_command:feature:subcommands" },
-        { file: runtimeFile("skills/feature-workspaces/SKILL.md"), needle: "## Protocol", name: "utility_skill:feature:protocol" },
-        { file: runtimeFile("skills/feature-workspaces/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:feature:hard_gate" },
+        { file: runtimeFile("skills/using-git-worktrees/SKILL.md"), needle: "## Protocol", name: "utility_skill:feature:protocol" },
+        { file: runtimeFile("skills/using-git-worktrees/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:feature:hard_gate" },
         { file: runtimeFile("commands/tdd-log.md"), needle: "## Subcommands", name: "utility_command:tdd_log:subcommands" },
         { file: runtimeFile("skills/tdd-cycle-log/SKILL.md"), needle: "## Protocol", name: "utility_skill:tdd_log:protocol" },
         { file: runtimeFile("skills/tdd-cycle-log/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:tdd_log:hard_gate" },
         { 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("commands/rewind-ack.md"), needle: "## Algorithm", name: "utility_command:rewind_ack: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" },
         { file: runtimeFile("skills/subagent-dev/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:sdd:hard_gate" },
@@ -157,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" },