cclaw-cli 0.51.21 → 0.51.22

package/dist/delegation.js

@@ -103,6 +103,9 @@ async function detectReviewTriggers(projectRoot) {
         return empty;
     }
 }
+function hasValidWaiverReason(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
 function isDelegationTokenUsage(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))
         return false;
@@ -130,6 +133,7 @@ function isDelegationEntry(value) {
             Number.isFinite(o.retryCount) &&
             Number.isInteger(o.retryCount) &&
             o.retryCount >= 0);
+    const waiverOk = o.status !== "waived" || hasValidWaiverReason(o.waiverReason);
     return (typeof o.stage === "string" &&
         typeof o.agent === "string" &&
         modeOk &&
@@ -141,6 +145,7 @@ function isDelegationEntry(value) {
         (o.endTs === undefined || typeof o.endTs === "string") &&
         (o.taskId === undefined || typeof o.taskId === "string") &&
         (o.waiverReason === undefined || typeof o.waiverReason === "string") &&
+        waiverOk &&
         (o.runId === undefined || typeof o.runId === "string") &&
         (o.fulfillmentMode === undefined ||
             o.fulfillmentMode === "isolated" ||
@@ -165,8 +170,10 @@ function parseLedger(raw, runId) {
         for (const item of entriesRaw) {
             if (isDelegationEntry(item)) {
                 const ts = item.startTs ?? item.ts ?? new Date().toISOString();
-                const inferredFulfillmentMode = item.fulfillmentMode
-                    ?? (item.status === "completed" ? "isolated" : undefined);
+                const isLegacyCompletion = item.fulfillmentMode === undefined &&
+                    item.schemaVersion === undefined &&
+                    item.status === "completed";
+                const inferredFulfillmentMode = item.fulfillmentMode ?? (isLegacyCompletion ? "isolated" : undefined);
                 entries.push({
                     ...item,
                     spanId: item.spanId ?? createSpanId(),
@@ -205,6 +212,9 @@ export async function appendDelegation(projectRoot, entry) {
         const filePath = delegationLogPath(projectRoot);
         const prior = await readDelegationLedger(projectRoot);
         const startTs = entry.startTs ?? entry.ts ?? new Date().toISOString();
+        if (entry.status === "waived" && !hasValidWaiverReason(entry.waiverReason)) {
+            throw new Error("waived delegation entries require a non-empty waiverReason");
+        }
         const stamped = { ...entry, runId: entry.runId ?? activeRunId };
         stamped.spanId = entry.spanId ?? createSpanId();
         stamped.startTs = startTs;
@@ -219,10 +229,19 @@ export async function appendDelegation(projectRoot, entry) {
             stamped.evidenceRefs = [];
         }
         if (stamped.status === "completed" && stamped.fulfillmentMode === undefined) {
-            const config = await readConfig(projectRoot).catch(() => null);
-            const harnesses = config?.harnesses ?? [];
-            const fallbacks = harnesses.map((h) => HARNESS_ADAPTERS[h].capabilities.subagentFallback);
-            stamped.fulfillmentMode = expectedFulfillmentMode(fallbacks);
+            const activeFallback = process.env.CCLAW_ACTIVE_HARNESS
+                ? HARNESS_ADAPTERS[process.env.CCLAW_ACTIVE_HARNESS]
+                    ?.capabilities.subagentFallback
+                : undefined;
+            if (activeFallback) {
+                stamped.fulfillmentMode = expectedFulfillmentMode([activeFallback]);
+            }
+            else {
+                const config = await readConfig(projectRoot).catch(() => null);
+                const harnesses = config?.harnesses ?? [];
+                const fallbacks = harnesses.map((h) => HARNESS_ADAPTERS[h].capabilities.subagentFallback);
+                stamped.fulfillmentMode = expectedFulfillmentMode(fallbacks);
+            }
         }
         // Idempotency: if a caller (or a retried hook) tries to append a row
         // with a spanId that already exists in the ledger, treat it as a no-op
@@ -256,10 +275,11 @@ export function expectedFulfillmentMode(fallbacks) {
     return "harness-waiver";
 }
 export async function checkMandatoryDelegations(projectRoot, stage, options = {}) {
-    const mandatory = stageSchema(stage).mandatoryDelegations;
-    const { activeRunId } = await readFlowState(projectRoot, {
+    const flowState = await readFlowState(projectRoot, {
         repairFeatureSystem: options.repairFeatureSystem
     });
+    const mandatory = stageSchema(stage, flowState.track).mandatoryDelegations;
+    const { activeRunId } = flowState;
     const ledger = await readDelegationLedger(projectRoot);
     const forStage = ledger.entries.filter((e) => e.stage === stage);
     const forRun = forStage.filter((e) => e.runId === activeRunId);

package/dist/doctor.js

@@ -25,6 +25,7 @@ import { LANGUAGE_RULE_PACK_DIR, LANGUAGE_RULE_PACK_FILES, LEGACY_LANGUAGE_RULE_
 import { validateHookDocument } from "./hook-schema.js";
 import { validateKnowledgeEntry } from "./knowledge-store.js";
 import { readSeedShelf } from "./content/seed-shelf.js";
+import { evaluateRetroGate } from "./retro-gate.js";
 const execFileAsync = promisify(execFile);
 async function isGitRepo(projectRoot) {
     try {
@@ -149,18 +150,30 @@ function knowledgeRoutingSurfaceIsDiscoverable(content) {
     return ["trigger", "action", "origin_run"].every((term) => normalized.includes(term));
 }
 async function commandAvailable(command) {
+    const version = await commandVersion(command);
+    return version.available;
+}
+async function commandVersion(command, args = ["--version"]) {
     try {
         if (process.platform === "win32") {
             await execFileAsync("where", [command]);
-            return true;
         }
-        await execFileAsync(command, ["--version"]);
-        return true;
+        const { stdout, stderr } = await execFileAsync(command, args);
+        return { available: true, output: `${stdout}${stderr}`.trim() };
     }
     catch {
-        return false;
+        return { available: false, output: "" };
     }
 }
+function parseNodeMajor(versionOutput) {
+    const match = /v?(\d+)\./u.exec(versionOutput);
+    if (!match)
+        return null;
+    return Number(match[1]);
+}
+function gitVersionLooksUsable(versionOutput) {
+    return /git version \d+\.\d+/iu.test(versionOutput);
+}
 function stripJsonCommentsOutsideStrings(input) {
     let out = "";
     let i = 0;
@@ -308,6 +321,87 @@ async function opencodeRegistrationCheck(projectRoot) {
     }
     return { ok: false, details: `No opencode.json/opencode.jsonc found with plugin ${expected}` };
 }
+async function initRecoveryCheck(projectRoot) {
+    const sentinelPath = path.join(projectRoot, RUNTIME_ROOT, "state", ".init-in-progress");
+    if (!(await exists(sentinelPath))) {
+        return { ok: true, details: "no partial init/sync sentinel found" };
+    }
+    let summary = `${RUNTIME_ROOT}/state/.init-in-progress sentinel present`;
+    try {
+        const parsed = JSON.parse(await fs.readFile(sentinelPath, "utf8"));
+        const operation = typeof parsed.operation === "string" ? parsed.operation : "unknown";
+        const startedAt = typeof parsed.startedAt === "string" ? parsed.startedAt : "unknown";
+        summary = `${summary} (operation=${operation}, startedAt=${startedAt})`;
+    }
+    catch {
+        summary = `${summary} (unreadable sentinel payload)`;
+    }
+    return {
+        ok: false,
+        details: `${summary}. Fix: inspect generated runtime files, then rerun cclaw sync or remove the sentinel only after confirming the runtime is complete.`
+    };
+}
+async function archiveIntegrityCheck(projectRoot) {
+    const runsDir = path.join(projectRoot, RUNTIME_ROOT, "runs");
+    if (!(await exists(runsDir))) {
+        return { ok: true, details: `${RUNTIME_ROOT}/runs is absent; no archives to inspect yet` };
+    }
+    let entries;
+    try {
+        entries = await fs.readdir(runsDir, { withFileTypes: true });
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        return { ok: false, details: `unable to inspect ${RUNTIME_ROOT}/runs (${reason})` };
+    }
+    const problems = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const runId = entry.name;
+        const runPath = path.join(runsDir, runId);
+        const relRunPath = `${RUNTIME_ROOT}/runs/${runId}`;
+        if (await exists(path.join(runPath, ".archive-in-progress"))) {
+            problems.push(`${relRunPath}/.archive-in-progress sentinel present`);
+        }
+        const manifestPath = path.join(runPath, "archive-manifest.json");
+        if (!(await exists(manifestPath))) {
+            problems.push(`${relRunPath} missing archive-manifest.json`);
+            continue;
+        }
+        let manifest;
+        try {
+            manifest = JSON.parse(await fs.readFile(manifestPath, "utf8"));
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            problems.push(`${relRunPath}/archive-manifest.json unreadable (${reason})`);
+            continue;
+        }
+        const stateFiles = Array.isArray(manifest.snapshottedStateFiles)
+            ? manifest.snapshottedStateFiles.filter((value) => typeof value === "string")
+            : [];
+        const stateDir = path.join(runPath, "state");
+        if (stateFiles.length > 0 && !(await exists(stateDir))) {
+            problems.push(`${relRunPath} manifest lists state snapshot files but state/ is missing`);
+            continue;
+        }
+        for (const stateFile of stateFiles) {
+            if (stateFile.endsWith("/"))
+                continue;
+            if (!(await exists(path.join(stateDir, stateFile)))) {
+                problems.push(`${relRunPath}/state missing ${stateFile} listed in manifest`);
+            }
+        }
+    }
+    if (problems.length === 0) {
+        return { ok: true, details: "no partial archive sentinels or incomplete archive snapshots found" };
+    }
+    return {
+        ok: false,
+        details: `${problems.join("; ")}. Fix: inspect the archive directory, retry archive if the active run was restored, or recover/rollback artifacts and state from the snapshot before removing the sentinel.`
+    };
+}
 async function opencodePluginRuntimeShapeCheck(projectRoot) {
     const pluginPath = path.join(projectRoot, ".opencode/plugins/cclaw-plugin.mjs");
     if (!(await exists(pluginPath))) {
@@ -981,11 +1075,36 @@ export async function doctorChecks(projectRoot, options = {}) {
             details: registration.details
         });
     }
-    const hasNode = await commandAvailable("node");
+    const nodeVersion = await commandVersion("node");
+    const nodeMajor = parseNodeMajor(nodeVersion.output);
     checks.push({
         name: "capability:required:node",
-        ok: hasNode,
-        details: "node is required for cclaw runtime scripts and CLI wiring"
+        ok: nodeVersion.available,
+        details: nodeVersion.available
+            ? `node binary available (${nodeVersion.output || "version unknown"})`
+            : "node is required for cclaw runtime scripts and CLI wiring"
+    });
+    checks.push({
+        name: "capability:required:node_version",
+        ok: nodeVersion.available && nodeMajor !== null && nodeMajor >= 20,
+        details: nodeVersion.available
+            ? `node >=20 required; detected ${nodeVersion.output || "unknown version"}`
+            : "node version check skipped because node binary is unavailable"
+    });
+    const gitVersion = await commandVersion("git");
+    checks.push({
+        name: "capability:required:git",
+        ok: gitVersion.available,
+        details: gitVersion.available
+            ? `git binary available (${gitVersion.output || "version unknown"})`
+            : "git is required for repository detection, hook setup, and doctor checks"
+    });
+    checks.push({
+        name: "capability:required:git_version",
+        ok: gitVersion.available && gitVersionLooksUsable(gitVersion.output),
+        details: gitVersion.available
+            ? `git version output: ${gitVersion.output || "unknown version"}`
+            : "git version check skipped because git binary is unavailable"
     });
     const windowsHookConfigCandidates = [
         path.join(projectRoot, ".claude/hooks/hooks.json"),
@@ -1083,12 +1202,7 @@ export async function doctorChecks(projectRoot, options = {}) {
                         const key = `${trigger} => ${action}`;
                         triggerActionCounts.set(key, (triggerActionCounts.get(key) ?? 0) + 1);
                     }
-                    const missing = requiredV2Fields.some((field) => {
-                        if (field === "origin_run" && Object.prototype.hasOwnProperty.call(parsed, "origin_feature")) {
-                            return false;
-                        }
-                        return !Object.prototype.hasOwnProperty.call(parsed, field);
-                    });
+                    const missing = requiredV2Fields.some((field) => !Object.prototype.hasOwnProperty.call(parsed, field));
                     if (missing) {
                         missingSchemaV2Fields += 1;
                     }
@@ -1388,17 +1502,17 @@ export async function doctorChecks(projectRoot, options = {}) {
             ? "no stale stages pending acknowledgement"
             : `stale stages pending acknowledgement: ${staleStages.join(", ")}`
     });
-    const retroRequired = flowState.completedStages.includes("ship");
-    const retroComplete = !retroRequired ||
-        (typeof flowState.retro.completedAt === "string" && flowState.retro.compoundEntries > 0);
+    const retroGateStatus = await evaluateRetroGate(projectRoot, flowState);
     checks.push({
         name: "state:retro_gate",
-        ok: retroComplete,
-        details: retroComplete
-            ? retroRequired
-                ? `retro gate complete (${flowState.retro.compoundEntries} compound entries)`
+        ok: retroGateStatus.completed,
+        details: retroGateStatus.completed
+            ? retroGateStatus.required
+                ? retroGateStatus.skipped
+                    ? "retro gate complete (retro skipped with recorded closeout decision)"
+                    : `retro gate complete (${retroGateStatus.compoundEntries} compound entries)`
                 : "retro gate not required yet (ship not completed)"
-            : "retro gate incomplete: ship flow requires recorded retrospective evidence."
+            : "retro gate incomplete: ship flow requires recorded retrospective evidence or an explicit retro skip."
     });
     const tddLogPath = path.join(projectRoot, RUNTIME_ROOT, "state", "tdd-cycle-log.jsonl");
     const tddLogExists = await exists(tddLogPath);
@@ -1444,6 +1558,18 @@ export async function doctorChecks(projectRoot, options = {}) {
         ok: await exists(path.join(projectRoot, RUNTIME_ROOT, "runs")),
         details: `${RUNTIME_ROOT}/runs must exist for archived run snapshots`
     });
+    const initRecovery = await initRecoveryCheck(projectRoot);
+    checks.push({
+        name: "state:init_recovery",
+        ok: initRecovery.ok,
+        details: initRecovery.details
+    });
+    const archiveIntegrity = await archiveIntegrityCheck(projectRoot);
+    checks.push({
+        name: "runs:archive_integrity",
+        ok: archiveIntegrity.ok,
+        details: archiveIntegrity.details
+    });
     const delegation = await checkMandatoryDelegations(projectRoot, flowState.currentStage, {
         repairFeatureSystem: false
     });

package/dist/gate-evidence.js

@@ -336,11 +336,27 @@ export async function verifyCurrentStageGateEvidence(projectRoot, flowState) {
         if (stage === "design") {
             const researchGateRequired = schema.requiredGates.some((gate) => gate.id === "design_research_complete" && gate.tier === "required");
             if (researchGateRequired) {
+                const designMarkdown = await readArtifactMarkdown(projectRoot, "03-design.md");
+                const inlineResearchBody = designMarkdown
+                    ? extractMarkdownSectionBody(designMarkdown, "Research Fleet Synthesis")
+                    : null;
+                const inlineResearchLines = inlineResearchBody
+                    ? inlineResearchBody
+                        .split(/\r?\n/gu)
+                        .map((line) => line.trim())
+                        .filter((line) => line.length > 0)
+                        .filter((line) => !/^\|?(?:[-:\s|])+$/u.test(line))
+                        .filter((line) => !/\b(?:TODO|TBD|FIXME|pending)\b/iu.test(line) &&
+                        !/<fill-in>/iu.test(line) &&
+                        !/^>\s*Default path:/iu.test(line) &&
+                        !/^\|\s*compact inline synthesis\s*\|\s*\|\s*\|\s*\|?\s*$/iu.test(line))
+                    : [];
+                const inlineResearchComplete = inlineResearchLines.length > 0;
                 const researchMarkdown = await readArtifactMarkdown(projectRoot, "02a-research.md");
-                if (!researchMarkdown) {
-                    issues.push("design research gate blocked (design_research_complete): missing `.cclaw/artifacts/02a-research.md`.");
+                if (!inlineResearchComplete && !researchMarkdown) {
+                    issues.push("design research gate blocked (design_research_complete): fill `Research Fleet Synthesis` in `.cclaw/artifacts/03-design.md`, or write `.cclaw/artifacts/02a-research.md` for deep/high-risk research.");
                 }
-                else {
+                else if (researchMarkdown) {
                     const missingSections = [];
                     for (const section of DESIGN_RESEARCH_REQUIRED_SECTIONS) {
                         const body = extractMarkdownSectionBody(researchMarkdown, section);
@@ -353,10 +369,6 @@ export async function verifyCurrentStageGateEvidence(projectRoot, flowState) {
                             .map((line) => line.trim())
                             .filter((line) => line.length > 0)
                             .filter((line) => !/^\|?(?:[-:\s|])+$/u.test(line));
-                        // `<fill-in>` needs its own check because `\b` does not match
-                        // around `<`/`>` (non-word characters), so the previous combined
-                        // pattern `\b(?:...|<fill-in>)\b` silently never matched placeholder
-                        // templates that used angle-bracket form.
                         const nonPlaceholder = meaningfulLines.filter((line) => !/\b(?:TODO|TBD|FIXME|pending)\b/iu.test(line) &&
                             !/<fill-in>/iu.test(line));
                         if (nonPlaceholder.length === 0) {

package/dist/harness-adapters.js

@@ -134,11 +134,7 @@ export function harnessTier(harnessId) {
         capabilities.hookSurface === "full") {
         return "tier1";
     }
-    if (capabilities.hookSurface === "full" ||
-        capabilities.hookSurface === "plugin" ||
-        capabilities.hookSurface === "limited" ||
-        capabilities.nativeSubagentDispatch === "generic" ||
-        capabilities.nativeSubagentDispatch === "partial") {
+    if (capabilities.hookSurface !== "none" || capabilities.nativeSubagentDispatch !== "none") {
         return "tier2";
     }
     return "tier3";

package/dist/install.js

@@ -34,10 +34,17 @@ const OPENCODE_PLUGIN_REL_PATH = ".opencode/plugins/cclaw-plugin.mjs";
 const CURSOR_RULE_REL_PATH = ".cursor/rules/cclaw-workflow.mdc";
 const GIT_HOOK_MANAGED_MARKER = "cclaw-managed-git-hook";
 const GIT_HOOK_RUNTIME_REL_DIR = `${RUNTIME_ROOT}/hooks/git`;
+const INIT_SENTINEL_FILE = ".init-in-progress";
 const execFileAsync = promisify(execFile);
 function runtimePath(projectRoot, ...segments) {
     return path.join(projectRoot, RUNTIME_ROOT, ...segments);
 }
+async function writeInitSentinel(projectRoot, operation) {
+    const sentinelPath = runtimePath(projectRoot, "state", INIT_SENTINEL_FILE);
+    await ensureDir(path.dirname(sentinelPath));
+    await writeFileSafe(sentinelPath, `${JSON.stringify({ operation, startedAt: new Date().toISOString() }, null, 2)}\n`);
+    return sentinelPath;
+}
 async function removeBestEffort(targetPath, recursive = false) {
     try {
         await fs.rm(targetPath, { recursive, force: true });
@@ -653,6 +660,54 @@ async function backupHookFile(projectRoot, hookFilePath, rawContent) {
     await pruneOldHookBackups(backupsDir);
     return backupPath;
 }
+function normalizeHookCommandForDedupe(command) {
+    return command.trim().replace(/\s+/gu, " ").replace(/\\/gu, "/");
+}
+function dedupeHookEntryByCommand(entry, seenCommands) {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+        return entry;
+    }
+    const obj = entry;
+    let changed = false;
+    if (typeof obj.command === "string") {
+        const normalized = normalizeHookCommandForDedupe(obj.command);
+        if (seenCommands.has(normalized)) {
+            return undefined;
+        }
+        seenCommands.add(normalized);
+    }
+    if (Array.isArray(obj.hooks)) {
+        const hooks = [];
+        for (const nested of obj.hooks) {
+            const deduped = dedupeHookEntryByCommand(nested, seenCommands);
+            if (deduped !== undefined) {
+                hooks.push(deduped);
+            }
+            else {
+                changed = true;
+            }
+        }
+        if (hooks.length !== obj.hooks.length) {
+            changed = true;
+        }
+        if (hooks.length === 0 && typeof obj.command !== "string") {
+            return undefined;
+        }
+        return changed ? { ...obj, hooks } : entry;
+    }
+    return entry;
+}
+function dedupeHookEntriesByCommand(entries) {
+    const seenCommands = new Set();
+    const deduped = [];
+    for (const entry of entries) {
+        const next = dedupeHookEntryByCommand(entry, seenCommands);
+        if (next !== undefined) {
+            deduped.push(next);
+        }
+    }
+    return deduped;
+}
 function mergeHookDocuments(existingDoc, generatedDoc) {
     const generatedRoot = toObject(generatedDoc) ?? {};
     const generatedHooks = toObject(generatedRoot.hooks) ?? {};
@@ -664,7 +719,7 @@ function mergeHookDocuments(existingDoc, generatedDoc) {
         const existingEntries = existingHooks[eventName];
         if (Array.isArray(generatedEntries)) {
             const preservedEntries = Array.isArray(existingEntries) ? existingEntries : [];
-            mergedHooks[eventName] = [...generatedEntries, ...preservedEntries];
+            mergedHooks[eventName] = dedupeHookEntriesByCommand([...generatedEntries, ...preservedEntries]);
             continue;
         }
         // Defensive: malformed generated event payload must not wipe user hooks.
@@ -944,26 +999,34 @@ async function cleanStaleFiles(projectRoot) {
     // Keep user-owned custom assets under .cclaw/agents and .cclaw/skills.
     // Legacy managed removals happen in cleanLegacyArtifacts() with explicit paths.
 }
-async function materializeRuntime(projectRoot, config, forceStateReset) {
-    const harnesses = config.harnesses;
-    await ensureStructure(projectRoot);
-    await cleanLegacyArtifacts(projectRoot);
-    await cleanStaleFiles(projectRoot);
-    await Promise.all([
-        writeEntryCommands(projectRoot),
-        writeSkills(projectRoot, config),
-        writeArtifactTemplates(projectRoot),
-        writeRulebook(projectRoot)
-    ]);
-    await writeState(projectRoot, config, forceStateReset);
-    await ensureRunSystem(projectRoot, { createIfMissing: false });
-    await ensureKnowledgeStore(projectRoot);
-    await writeHooks(projectRoot, config);
-    await syncDisabledHarnessArtifacts(projectRoot, harnesses);
-    await syncManagedGitHooks(projectRoot, config);
-    await syncHarnessShims(projectRoot, harnesses);
-    await writeCursorWorkflowRule(projectRoot, harnesses);
-    await ensureGitignore(projectRoot);
+async function materializeRuntime(projectRoot, config, forceStateReset, operation = "sync") {
+    const sentinelPath = await writeInitSentinel(projectRoot, operation);
+    try {
+        const harnesses = config.harnesses;
+        await ensureStructure(projectRoot);
+        await cleanLegacyArtifacts(projectRoot);
+        await cleanStaleFiles(projectRoot);
+        await Promise.all([
+            writeEntryCommands(projectRoot),
+            writeSkills(projectRoot, config),
+            writeArtifactTemplates(projectRoot),
+            writeRulebook(projectRoot)
+        ]);
+        await writeState(projectRoot, config, forceStateReset);
+        await ensureRunSystem(projectRoot, { createIfMissing: false });
+        await ensureKnowledgeStore(projectRoot);
+        await writeHooks(projectRoot, config);
+        await syncDisabledHarnessArtifacts(projectRoot, harnesses);
+        await syncManagedGitHooks(projectRoot, config);
+        await syncHarnessShims(projectRoot, harnesses);
+        await writeCursorWorkflowRule(projectRoot, harnesses);
+        await ensureGitignore(projectRoot);
+        await fs.unlink(sentinelPath).catch(() => undefined);
+    }
+    catch (error) {
+        // Leave the sentinel in place so doctor can surface the interrupted run.
+        throw error;
+    }
 }
 export async function initCclaw(options) {
     const baseConfig = createDefaultConfig(options.harnesses, options.track);
@@ -978,7 +1041,7 @@ export async function initCclaw(options) {
     // and only appear in the on-disk file when the user sets them explicitly
     // or a non-default value was detected (e.g. languageRulePacks).
     await writeConfig(options.projectRoot, config, { mode: "minimal" });
-    await materializeRuntime(options.projectRoot, config, true);
+    await materializeRuntime(options.projectRoot, config, true, "init");
 }
 export async function syncCclaw(projectRoot) {
     const configExists = await exists(configPath(projectRoot));
@@ -996,7 +1059,7 @@ export async function syncCclaw(projectRoot) {
         await writeConfig(projectRoot, defaultConfig);
         config = defaultConfig;
     }
-    await materializeRuntime(projectRoot, config, false);
+    await materializeRuntime(projectRoot, config, false, "sync");
 }
 /**
  * Refresh generated files in `.cclaw/` without touching user-authored
@@ -1020,7 +1083,7 @@ export async function upgradeCclaw(projectRoot) {
         mode: "minimal",
         advancedKeysPresent
     });
-    await materializeRuntime(projectRoot, upgraded, false);
+    await materializeRuntime(projectRoot, upgraded, false, "upgrade");
 }
 function stripManagedHookCommands(value) {
     if (!value || typeof value !== "object" || Array.isArray(value)) {