cclaw-cli 7.1.1 → 7.3.0

package/dist/cli.d.ts

@@ -9,6 +9,7 @@ interface ParsedArgs {
     track?: FlowTrack;
     dryRun?: boolean;
     interactive?: boolean;
+    syncCheck?: boolean;
     archiveName?: string;
     archiveSkipRetro?: boolean;
     archiveSkipRetroReason?: string;

package/dist/cli.js

@@ -40,6 +40,7 @@ Commands:
   sync       Reconcile generated runtime files with the current config.
              Flags: --harnesses=<list>  Update configured harnesses before syncing.
                     --interactive      Pick harnesses from a numbered TTY menu.
+                    --check            Verify managed hook files are byte-identical to canonical generators.
   upgrade    Refresh generated files in .cclaw. Preserves your config.yaml.
   archive    Archive the active run and reset flow state for the next run.
              Flags: --name=<slug>        Override archive folder suffix.
@@ -57,6 +58,7 @@ Examples:
   npx cclaw-cli
   npx cclaw-cli init --harnesses=claude,cursor --no-interactive
   npx cclaw-cli sync --interactive
+  npx cclaw-cli sync --check
   npx cclaw-cli archive --name=my-run
   npx cclaw-cli archive --disposition=cancelled --reason="deprioritized"
   npx cclaw-cli upgrade
@@ -334,6 +336,7 @@ function parseArgs(argv) {
             return flag.startsWith("--harnesses=") ||
                 (parsed.command === "init" && flag.startsWith("--track=")) ||
                 (parsed.command === "init" && flag.startsWith("--profile=")) ||
+                (parsed.command === "sync" && flag === "--check") ||
                 flag === "--interactive" ||
                 flag === "--no-interactive" ||
                 (parsed.command === "init" && flag === "--dry-run");
@@ -374,6 +377,10 @@ function parseArgs(argv) {
             parsed.dryRun = true;
             continue;
         }
+        if (flag === "--check") {
+            parsed.syncCheck = true;
+            continue;
+        }
         if (flag.startsWith("--name=")) {
             parsed.archiveName = flag.replace("--name=", "").trim();
             continue;
@@ -446,6 +453,11 @@ async function runCommand(parsed, ctx) {
         return 0;
     }
     if (command === "sync") {
+        if (parsed.syncCheck === true) {
+            await syncCclaw(ctx.cwd, { check: true });
+            info(ctx, "Managed hook drift check passed (no sync required).");
+            return 0;
+        }
         const resolved = await resolveSyncInputs(parsed, ctx);
         await syncCclaw(ctx.cwd, { harnesses: resolved.harnesses });
         const harnessNote = resolved.harnesses ? ` (${resolved.harnesses.join(", ")})` : "";

package/dist/config.d.ts

@@ -1,6 +1,9 @@
-import type { CclawConfig, FlowTrack, HarnessId, LanguageRulePack, TddCommitMode } from "./types.js";
+import type { CclawConfig, FlowTrack, HarnessId, LanguageRulePack, TddCommitMode, TddIsolationMode } from "./types.js";
 export declare const TDD_COMMIT_MODES: readonly ["managed-per-slice", "agent-required", "checkpoint-only", "off"];
 export declare const DEFAULT_TDD_COMMIT_MODE: TddCommitMode;
+export declare const TDD_ISOLATION_MODES: readonly ["worktree", "in-place", "auto"];
+export declare const DEFAULT_TDD_ISOLATION_MODE: TddIsolationMode;
+export declare const DEFAULT_TDD_WORKTREE_ROOT = ".cclaw/worktrees";
 export declare const DEFAULT_TDD_TEST_PATH_PATTERNS: readonly string[];
 export declare const DEFAULT_TDD_TEST_GLOBS: readonly string[];
 export declare const DEFAULT_TDD_PRODUCTION_PATH_PATTERNS: readonly string[];
@@ -19,6 +22,8 @@ export declare class InvalidConfigError extends Error {
 export declare function configPath(projectRoot: string): string;
 export declare function createDefaultConfig(harnesses?: HarnessId[], _defaultTrack?: FlowTrack): CclawConfig;
 export declare function resolveTddCommitMode(config: Pick<CclawConfig, "tdd"> | null | undefined): TddCommitMode;
+export declare function resolveTddIsolationMode(config: Pick<CclawConfig, "tdd"> | null | undefined): TddIsolationMode;
+export declare function resolveTddWorktreeRoot(config: Pick<CclawConfig, "tdd"> | null | undefined): string;
 export declare function detectLanguageRulePacks(_projectRoot: string): Promise<LanguageRulePack[]>;
 export declare function readConfig(projectRoot: string, _options?: ReadConfigOptions): Promise<CclawConfig>;
 export interface WriteConfigOptions {

package/dist/config.js

@@ -16,6 +16,10 @@ export const TDD_COMMIT_MODES = [
 ];
 const TDD_COMMIT_MODE_SET = new Set(TDD_COMMIT_MODES);
 export const DEFAULT_TDD_COMMIT_MODE = "managed-per-slice";
+export const TDD_ISOLATION_MODES = ["worktree", "in-place", "auto"];
+const TDD_ISOLATION_MODE_SET = new Set(TDD_ISOLATION_MODES);
+export const DEFAULT_TDD_ISOLATION_MODE = "worktree";
+export const DEFAULT_TDD_WORKTREE_ROOT = `${RUNTIME_ROOT}/worktrees`;
 // Kept for runtime modules that use these defaults directly.
 export const DEFAULT_TDD_TEST_PATH_PATTERNS = [
     "**/*.test.*",
@@ -40,7 +44,9 @@ function configFixExample() {
   - claude
   - cursor
 tdd:
-  commitMode: managed-per-slice`;
+  commitMode: managed-per-slice
+  isolationMode: worktree
+  worktreeRoot: .cclaw/worktrees`;
 }
 function configValidationError(configFilePath, reason) {
     return new InvalidConfigError(`Invalid cclaw config at ${configFilePath}: ${reason}\n` +
@@ -60,7 +66,9 @@ export function createDefaultConfig(harnesses = DEFAULT_HARNESSES, _defaultTrack
         flowVersion: FLOW_VERSION,
         harnesses: [...new Set(harnesses)],
         tdd: {
-            commitMode: DEFAULT_TDD_COMMIT_MODE
+            commitMode: DEFAULT_TDD_COMMIT_MODE,
+            isolationMode: DEFAULT_TDD_ISOLATION_MODE,
+            worktreeRoot: DEFAULT_TDD_WORKTREE_ROOT
         }
     };
 }
@@ -71,6 +79,20 @@ export function resolveTddCommitMode(config) {
     }
     return DEFAULT_TDD_COMMIT_MODE;
 }
+export function resolveTddIsolationMode(config) {
+    const raw = config?.tdd?.isolationMode;
+    if (typeof raw === "string" && TDD_ISOLATION_MODE_SET.has(raw)) {
+        return raw;
+    }
+    return DEFAULT_TDD_ISOLATION_MODE;
+}
+export function resolveTddWorktreeRoot(config) {
+    const raw = config?.tdd?.worktreeRoot;
+    if (typeof raw === "string" && raw.trim().length > 0) {
+        return raw.trim();
+    }
+    return DEFAULT_TDD_WORKTREE_ROOT;
+}
 function assertOnlySupportedKeys(parsed, fullPath) {
     const unknownKeys = Object.keys(parsed).filter((key) => !ALLOWED_CONFIG_KEYS.has(key));
     if (unknownKeys.length === 0)
@@ -129,19 +151,37 @@ export async function readConfig(projectRoot, _options = {}) {
         : FLOW_VERSION;
     const parsedTdd = isRecord(parsed.tdd) ? parsed.tdd : {};
     const rawCommitMode = parsedTdd.commitMode;
+    const rawIsolationMode = parsedTdd.isolationMode;
+    const rawWorktreeRoot = parsedTdd.worktreeRoot;
     if (rawCommitMode !== undefined &&
         (typeof rawCommitMode !== "string" || !TDD_COMMIT_MODE_SET.has(rawCommitMode))) {
         throw configValidationError(fullPath, `"tdd.commitMode" must be one of: ${TDD_COMMIT_MODES.join(", ")}`);
     }
+    if (rawIsolationMode !== undefined &&
+        (typeof rawIsolationMode !== "string" || !TDD_ISOLATION_MODE_SET.has(rawIsolationMode))) {
+        throw configValidationError(fullPath, `"tdd.isolationMode" must be one of: ${TDD_ISOLATION_MODES.join(", ")}`);
+    }
+    if (rawWorktreeRoot !== undefined &&
+        (typeof rawWorktreeRoot !== "string" || rawWorktreeRoot.trim().length === 0)) {
+        throw configValidationError(fullPath, `"tdd.worktreeRoot" must be a non-empty string when provided`);
+    }
     const commitMode = typeof rawCommitMode === "string"
         ? rawCommitMode
         : DEFAULT_TDD_COMMIT_MODE;
+    const isolationMode = typeof rawIsolationMode === "string"
+        ? rawIsolationMode
+        : DEFAULT_TDD_ISOLATION_MODE;
+    const worktreeRoot = typeof rawWorktreeRoot === "string" && rawWorktreeRoot.trim().length > 0
+        ? rawWorktreeRoot.trim()
+        : DEFAULT_TDD_WORKTREE_ROOT;
     return {
         version,
         flowVersion,
         harnesses: normalizedHarnesses,
         tdd: {
-            commitMode
+            commitMode,
+            isolationMode,
+            worktreeRoot
         }
     };
 }
@@ -151,7 +191,9 @@ export async function writeConfig(projectRoot, config, _options = {}) {
         flowVersion: config.flowVersion,
         harnesses: config.harnesses,
         tdd: {
-            commitMode: resolveTddCommitMode(config)
+            commitMode: resolveTddCommitMode(config),
+            isolationMode: resolveTddIsolationMode(config),
+            worktreeRoot: resolveTddWorktreeRoot(config)
         }
     };
     await writeFileSafe(configPath(projectRoot), stringify(serialisable));

package/dist/constants.d.ts

@@ -10,7 +10,7 @@ export declare const FLOW_VERSION = "1.0.0";
 export declare const SHIP_FINALIZATION_MODES: readonly ["FINALIZE_MERGE_LOCAL", "FINALIZE_OPEN_PR", "FINALIZE_KEEP_BRANCH", "FINALIZE_DISCARD_BRANCH", "FINALIZE_NO_VCS"];
 export type ShipFinalizationMode = (typeof SHIP_FINALIZATION_MODES)[number];
 export declare const DEFAULT_HARNESSES: HarnessId[];
-export declare const REQUIRED_DIRS: readonly [".cclaw", ".cclaw/commands", ".cclaw/skills", ".cclaw/templates", ".cclaw/templates/state-contracts", ".cclaw/artifacts", ".cclaw/wave-plans", ".cclaw/archive", ".cclaw/state", ".cclaw/rules", ".cclaw/agents", ".cclaw/hooks", ".cclaw/skills/review-prompts"];
+export declare const REQUIRED_DIRS: readonly [".cclaw", ".cclaw/commands", ".cclaw/skills", ".cclaw/templates", ".cclaw/templates/state-contracts", ".cclaw/artifacts", ".cclaw/wave-plans", ".cclaw/archive", ".cclaw/worktrees", ".cclaw/state", ".cclaw/rules", ".cclaw/agents", ".cclaw/hooks", ".cclaw/skills/review-prompts"];
 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", ".agents/skills/cc/SKILL.md", ".agents/skills/cc-*/SKILL.md", ".claude/hooks/hooks.json", ".cursor/hooks.json", ".codex/hooks.json", ".opencode/plugins/cclaw-plugin.mjs", ".cursor/rules/cclaw-workflow.mdc"];
 /**
  * Canonical stage -> skill folder mapping.

package/dist/constants.js

@@ -61,6 +61,7 @@ export const REQUIRED_DIRS = [
     `${RUNTIME_ROOT}/artifacts`,
     `${RUNTIME_ROOT}/wave-plans`,
     `${RUNTIME_ROOT}/archive`,
+    `${RUNTIME_ROOT}/worktrees`,
     `${RUNTIME_ROOT}/state`,
     `${RUNTIME_ROOT}/rules`,
     `${RUNTIME_ROOT}/agents`,

package/dist/content/core-agents.js

@@ -97,7 +97,7 @@ node .cclaw/hooks/delegation-record.mjs \\
   --json
 \`\`\`
 
-Reuse the same \`<spanId>\` and \`<dispatchId>\` across both rows. **GREEN evidence freshness** (slice-builder): the FIRST \`--evidence-ref\` MUST (1) reference the same test the matching \`phase=red\` row cited (basename/stem substring; reject \`green_evidence_red_test_mismatch\`), (2) include a recognized passing-runner line such as \`=> N passed; 0 failed\`, \`N passed in 0.42s\`, or \`ok pkg 0.12s\` (reject \`green_evidence_passing_assertion_missing\`), AND (3) be captured AFTER \`ackTs\` of this span — \`completedTs - ackTs\` must be ≥ \`flow-state.json::tddGreenMinElapsedMs\` (default 4000ms; reject \`green_evidence_too_fresh\`). Escape clause for legitimate observational GREEN: pass BOTH \`--allow-fast-green --green-mode=observational\`. \`--ack-ts\` and \`--completed-ts\` must be monotonic on the span (\`startTs ≤ launchedTs ≤ ackTs ≤ completedTs\`); the helper rejects out-of-order writes with \`delegation_timestamp_non_monotonic\`. If the helper rejects with \`dispatch_active_span_collision\` against a stale span, surface the conflicting \`spanId\` to the parent — do NOT silently retry with \`--allow-parallel\`.`;
+Reuse the same \`<spanId>\` and \`<dispatchId>\` across both rows. **GREEN evidence freshness** (slice-builder): the FIRST \`--evidence-ref\` MUST (1) reference the same test the matching \`phase=red\` row cited (basename/stem substring; reject \`green_evidence_red_test_mismatch\`), (2) include a recognized passing-runner line such as \`=> N passed; 0 failed\`, \`N passed in 0.42s\`, or \`ok pkg 0.12s\` (reject \`green_evidence_passing_assertion_missing\`), AND (3) be captured AFTER \`ackTs\` of this span — \`completedTs - ackTs\` must be ≥ \`flow-state.json::tddGreenMinElapsedMs\` (default 4000ms; reject \`green_evidence_too_fresh\`). Escape clause for legitimate observational GREEN: pass \`--green-mode=observational\`. \`--ack-ts\` and \`--completed-ts\` must be monotonic on the span (\`startTs ≤ launchedTs ≤ ackTs ≤ completedTs\`); the helper rejects out-of-order writes with \`delegation_timestamp_non_monotonic\`. If the helper rejects with \`dispatch_active_span_collision\` against a stale span, surface the conflicting \`spanId\` to the parent — do NOT silently retry with \`--allow-parallel\`.`;
 }
 function formatReturnSchema(schema) {
     const lines = [
@@ -156,6 +156,7 @@ export function sliceBuilderProtocol() {
         "### Invariants",
         "- Produce failing RED evidence (or cite the delegated RED artifact) **before** production edits.",
         "- Stay inside the slice contract: `claimedPaths`, acceptance mapping, and forbidden-change lists from the parent.",
+        "- When `tdd.isolationMode=worktree|auto`, run the slice inside the assigned worktree path (never in the shared repo root) so filesystem isolation enforces the claimed-path fence.",
         "- When `tdd.commitMode=managed-per-slice`, do **not** hand-edit git state for slice files (no manual `git add/commit` on claimed paths). Let `.cclaw/hooks/slice-commit.mjs` own per-slice commits.",
         "- After GREEN, refactor inline **or** record deferred refactor via the same `--refactor-outcome` mechanics the controller specifies.",
         "- Own the prose slice summary at `<artifacts-dir>/tdd-slices/S-<id>.md` yourself.",