cclaw-cli 0.51.29 → 0.55.2

package/dist/internal/compound-readiness.d.ts

@@ -5,7 +5,7 @@ interface InternalIo {
     stderr: Writable;
 }
 /**
- * Count archived runs as sub-directories under `.cclaw/runs/`. Missing
+ * Count archived runs as sub-directories under `.cclaw/archive/`. Missing
  * dir / ENOENT is interpreted as zero — callers should NOT conflate
  * that with "unknown" (undefined); we only return undefined on
  * unexpected errors so the caller can choose to skip the relaxation

package/dist/internal/compound-readiness.js

@@ -42,10 +42,10 @@ function stateDir(projectRoot) {
     return path.join(projectRoot, RUNTIME_ROOT, "state");
 }
 function archiveRunsDir(projectRoot) {
-    return path.join(projectRoot, RUNTIME_ROOT, "runs");
+    return path.join(projectRoot, RUNTIME_ROOT, "archive");
 }
 /**
- * Count archived runs as sub-directories under `.cclaw/runs/`. Missing
+ * Count archived runs as sub-directories under `.cclaw/archive/`. Missing
  * dir / ENOENT is interpreted as zero — callers should NOT conflate
  * that with "unknown" (undefined); we only return undefined on
  * unexpected errors so the caller can choose to skip the relaxation

package/dist/internal/early-loop-status.d.ts

@@ -0,0 +1,7 @@
+import type { Writable } from "node:stream";
+interface InternalIo {
+    stdout: Writable;
+    stderr: Writable;
+}
+export declare function runEarlyLoopStatusCommand(projectRoot: string, argv: string[], io: InternalIo): Promise<number>;
+export {};

package/dist/internal/early-loop-status.js

@@ -0,0 +1,90 @@
+import path from "node:path";
+import { readConfig } from "../config.js";
+import { RUNTIME_ROOT } from "../constants.js";
+import { computeEarlyLoopStatus, formatEarlyLoopStatusLine, isEarlyLoopStage } from "../early-loop.js";
+import { writeFileSafe } from "../fs-utils.js";
+import { readFlowState } from "../runs.js";
+function parseArgs(tokens) {
+    const args = { json: false, quiet: false, write: true };
+    for (let index = 0; index < tokens.length; index += 1) {
+        const token = tokens[index];
+        const nextToken = tokens[index + 1];
+        if (token === "--json") {
+            args.json = true;
+            continue;
+        }
+        if (token === "--quiet") {
+            args.quiet = true;
+            continue;
+        }
+        if (token === "--write") {
+            args.write = true;
+            continue;
+        }
+        if (token === "--no-write") {
+            args.write = false;
+            continue;
+        }
+        if (token === "--stage") {
+            if (!nextToken || nextToken.startsWith("--")) {
+                throw new Error("--stage requires a value: brainstorm | scope | design");
+            }
+            if (!isEarlyLoopStage(nextToken)) {
+                throw new Error("--stage must be one of: brainstorm, scope, design");
+            }
+            args.stage = nextToken;
+            index += 1;
+            continue;
+        }
+        if (token.startsWith("--stage=")) {
+            const stageRaw = token.slice("--stage=".length);
+            if (!isEarlyLoopStage(stageRaw)) {
+                throw new Error("--stage must be one of: brainstorm, scope, design");
+            }
+            args.stage = stageRaw;
+            continue;
+        }
+        if (token === "--run-id") {
+            if (!nextToken || nextToken.startsWith("--")) {
+                throw new Error("--run-id requires a value.");
+            }
+            args.runId = nextToken.trim();
+            index += 1;
+            continue;
+        }
+        if (token.startsWith("--run-id=")) {
+            args.runId = token.slice("--run-id=".length).trim();
+            continue;
+        }
+        throw new Error(`Unknown early-loop-status flag: ${token}`);
+    }
+    return args;
+}
+function stateDir(projectRoot) {
+    return path.join(projectRoot, RUNTIME_ROOT, "state");
+}
+export async function runEarlyLoopStatusCommand(projectRoot, argv, io) {
+    const args = parseArgs(argv);
+    const flow = await readFlowState(projectRoot).catch(() => null);
+    const config = await readConfig(projectRoot).catch(() => null);
+    const stage = args.stage ?? flow?.currentStage;
+    if (!isEarlyLoopStage(stage)) {
+        io.stderr.write("cclaw internal early-loop-status: current stage is not an early-loop stage. Pass --stage=brainstorm|scope|design.\n");
+        return 1;
+    }
+    const runId = (args.runId ?? flow?.activeRunId ?? "active").trim() || "active";
+    const status = await computeEarlyLoopStatus(stage, runId, path.join(stateDir(projectRoot), "early-loop-log.jsonl"), { maxIterations: config?.earlyLoop?.maxIterations });
+    if (args.write) {
+        const target = path.join(stateDir(projectRoot), "early-loop.json");
+        await writeFileSafe(target, `${JSON.stringify(status, null, 2)}\n`);
+    }
+    if (!args.quiet) {
+        if (args.json) {
+            io.stdout.write(`${JSON.stringify(status, null, 2)}\n`);
+        }
+        else {
+            io.stdout.write(`${formatEarlyLoopStatusLine(status)}\n`);
+        }
+    }
+    return 0;
+}

package/dist/internal/runtime-integrity.d.ts

@@ -0,0 +1,7 @@
+import type { Writable } from "node:stream";
+interface InternalIo {
+    stdout: Writable;
+    stderr: Writable;
+}
+export declare function runRuntimeIntegrityCommand(projectRoot: string, argv: string[], io: InternalIo): Promise<number>;
+export {};

package/dist/internal/runtime-integrity.js

@@ -0,0 +1,288 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { readConfig } from "../config.js";
+import { RUNTIME_ROOT } from "../constants.js";
+import { classifyCodexHooksFlag, codexConfigPath, readCodexConfig } from "../codex-feature-flag.js";
+import { exists } from "../fs-utils.js";
+import { HARNESS_ADAPTERS, harnessShimFileNames, harnessShimSkillNames } from "../harness-adapters.js";
+import { validateHookDocument } from "../hook-schema.js";
+import { MANAGED_RESOURCE_MANIFEST_REL_PATH, validateManagedResourceManifest } from "../managed-resources.js";
+import { CorruptFlowStateError, readFlowState } from "../runs.js";
+function parseArgs(tokens) {
+    const args = { json: false, quiet: false };
+    for (const token of tokens) {
+        if (token === "--json") {
+            args.json = true;
+            continue;
+        }
+        if (token === "--quiet") {
+            args.quiet = true;
+            continue;
+        }
+        throw new Error(`Unknown runtime-integrity flag: ${token}`);
+    }
+    return args;
+}
+function stripJsonCommentsOutsideStrings(input) {
+    let out = "";
+    let i = 0;
+    let inString = false;
+    let escape = false;
+    while (i < input.length) {
+        const c = input[i];
+        if (inString) {
+            out += c;
+            if (escape) {
+                escape = false;
+            }
+            else if (c === "\\") {
+                escape = true;
+            }
+            else if (c === "\"") {
+                inString = false;
+            }
+            i += 1;
+            continue;
+        }
+        if (c === "\"") {
+            inString = true;
+            out += c;
+            i += 1;
+            continue;
+        }
+        const next = input[i + 1];
+        if (c === "/" && next === "/") {
+            while (i < input.length && input[i] !== "\n" && input[i] !== "\r")
+                i += 1;
+            continue;
+        }
+        if (c === "/" && next === "*") {
+            i += 2;
+            while (i < input.length - 1 && !(input[i] === "*" && input[i + 1] === "/"))
+                i += 1;
+            i = Math.min(i + 2, input.length);
+            continue;
+        }
+        out += c;
+        i += 1;
+    }
+    return out;
+}
+function parseJsonWithRecovery(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        // Continue with comment/trailing-comma recovery.
+    }
+    try {
+        const normalized = stripJsonCommentsOutsideStrings(raw).replace(/,\s*([}\]])/gu, "$1");
+        return JSON.parse(normalized);
+    }
+    catch {
+        return null;
+    }
+}
+function okFinding(id, message) {
+    return {
+        id,
+        severity: "error",
+        ok: true,
+        message
+    };
+}
+function errorFinding(id, message, details) {
+    return {
+        id,
+        severity: "error",
+        ok: false,
+        message,
+        ...(details && details.length > 0 ? { details } : {})
+    };
+}
+function warningFinding(id, ok, message, details) {
+    return {
+        id,
+        severity: "warning",
+        ok,
+        message,
+        ...(details && details.length > 0 ? { details } : {})
+    };
+}
+async function checkStaleSentinel(projectRoot) {
+    const sentinelPath = path.join(projectRoot, RUNTIME_ROOT, "state", ".init-in-progress");
+    if (!(await exists(sentinelPath))) {
+        return warningFinding("stale_init_sentinel", true, "No stale init sentinel detected.");
+    }
+    let startedAt = "unknown time";
+    try {
+        const raw = await fs.readFile(sentinelPath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed.startedAt === "string" && parsed.startedAt.trim().length > 0) {
+            startedAt = parsed.startedAt;
+        }
+    }
+    catch {
+        // best-effort parse only
+    }
+    return warningFinding("stale_init_sentinel", false, "Detected stale .init-in-progress sentinel from a previous interrupted sync/init run.", [`startedAt: ${startedAt}`, `path: ${sentinelPath}`]);
+}
+async function checkFlowState(projectRoot) {
+    try {
+        await readFlowState(projectRoot);
+        return okFinding("flow_state", "Flow state is readable.");
+    }
+    catch (error) {
+        if (error instanceof CorruptFlowStateError) {
+            return errorFinding("flow_state", "Corrupt flow-state detected.", [error.message]);
+        }
+        return errorFinding("flow_state", "Flow-state read failed.", [
+            error instanceof Error ? error.message : String(error)
+        ]);
+    }
+}
+async function checkManagedManifest(projectRoot) {
+    const manifestPath = path.join(projectRoot, MANAGED_RESOURCE_MANIFEST_REL_PATH);
+    if (!(await exists(manifestPath))) {
+        return errorFinding("managed_manifest", "Managed resource manifest is missing.", [`missing: ${manifestPath}`]);
+    }
+    const rawText = await fs.readFile(manifestPath, "utf8");
+    let parsed;
+    try {
+        parsed = JSON.parse(rawText);
+    }
+    catch (error) {
+        return errorFinding("managed_manifest", "Managed resource manifest is not valid JSON.", [error instanceof Error ? error.message : String(error)]);
+    }
+    const issues = validateManagedResourceManifest(parsed);
+    if (issues.length > 0) {
+        const detail = issues.slice(0, 12).map((issue) => {
+            const scope = issue.path ?? (issue.index !== undefined ? `resources[${issue.index}]` : "manifest");
+            return `${scope}.${issue.field}: ${issue.message}`;
+        });
+        return errorFinding("managed_manifest", "Managed resource manifest schema validation failed.", detail);
+    }
+    return okFinding("managed_manifest", "Managed resource manifest is valid.");
+}
+function hookFilePath(projectRoot, harness) {
+    if (harness === "claude")
+        return path.join(projectRoot, ".claude/hooks/hooks.json");
+    if (harness === "cursor")
+        return path.join(projectRoot, ".cursor/hooks.json");
+    return path.join(projectRoot, ".codex/hooks.json");
+}
+async function checkHookDocument(projectRoot, harness) {
+    const hookPath = hookFilePath(projectRoot, harness);
+    if (!(await exists(hookPath))) {
+        return errorFinding(`hook_document_${harness}`, `Hook document is missing for ${harness}.`, [`missing: ${hookPath}`]);
+    }
+    const raw = await fs.readFile(hookPath, "utf8");
+    const parsed = parseJsonWithRecovery(raw);
+    if (parsed === null) {
+        return errorFinding(`hook_document_${harness}`, `Hook document for ${harness} is unparseable JSON.`, [`path: ${hookPath}`]);
+    }
+    const validation = validateHookDocument(harness, parsed);
+    if (!validation.ok) {
+        return errorFinding(`hook_document_${harness}`, `Hook document for ${harness} is invalid.`, validation.errors);
+    }
+    return okFinding(`hook_document_${harness}`, `Hook document for ${harness} is valid.`);
+}
+async function checkHarnessShims(projectRoot, harnesses) {
+    const findings = [];
+    const expectedFiles = harnessShimFileNames();
+    const expectedSkillFolders = harnessShimSkillNames();
+    for (const harness of harnesses) {
+        const adapter = HARNESS_ADAPTERS[harness];
+        const base = path.join(projectRoot, adapter.commandDir);
+        const missing = [];
+        for (const fileName of expectedFiles) {
+            const target = adapter.shimKind === "skill"
+                ? path.join(base, fileName.replace(/\.md$/u, ""), "SKILL.md")
+                : path.join(base, fileName);
+            if (!(await exists(target))) {
+                missing.push(target);
+            }
+        }
+        if (adapter.shimKind === "skill") {
+            for (const folder of expectedSkillFolders) {
+                const target = path.join(base, folder, "SKILL.md");
+                if (!(await exists(target))) {
+                    missing.push(target);
+                }
+            }
+        }
+        if (missing.length > 0) {
+            findings.push(errorFinding(`shim_drift_${harness}`, `Harness shim drift detected for ${harness}.`, missing));
+        }
+        else {
+            findings.push(okFinding(`shim_drift_${harness}`, `Harness shims for ${harness} are present.`));
+        }
+    }
+    return findings;
+}
+async function checkCodexHooksFlag(harnesses) {
+    if (!harnesses.includes("codex")) {
+        return warningFinding("codex_hooks_flag", true, "Codex harness is not enabled.");
+    }
+    const configTomlPath = codexConfigPath();
+    let existing;
+    try {
+        existing = await readCodexConfig(configTomlPath);
+    }
+    catch (error) {
+        return warningFinding("codex_hooks_flag", false, "Could not read Codex config.toml to validate codex_hooks.", [error instanceof Error ? error.message : String(error)]);
+    }
+    const state = classifyCodexHooksFlag(existing);
+    if (state === "enabled") {
+        return warningFinding("codex_hooks_flag", true, "Codex hooks feature flag is enabled.");
+    }
+    return warningFinding("codex_hooks_flag", false, "Codex hooks file is present, but [features] codex_hooks is not true in Codex config.", [`configPath: ${configTomlPath}`, `state: ${state}`]);
+}
+function buildReport(findings) {
+    const errors = findings.filter((finding) => !finding.ok && finding.severity === "error").length;
+    const warnings = findings.filter((finding) => !finding.ok && finding.severity === "warning").length;
+    return {
+        ok: errors === 0,
+        generatedAt: new Date().toISOString(),
+        findings,
+        summary: { errors, warnings }
+    };
+}
+function writeTextReport(io, report) {
+    io.stdout.write(`runtime-integrity: ${report.ok ? "ok" : "failed"}\n`);
+    io.stdout.write(`errors=${report.summary.errors} warnings=${report.summary.warnings}\n`);
+    for (const finding of report.findings) {
+        if (finding.ok)
+            continue;
+        io.stdout.write(`[${finding.severity}] ${finding.id}: ${finding.message}\n`);
+        for (const detail of finding.details ?? []) {
+            io.stdout.write(`  - ${detail}\n`);
+        }
+    }
+}
+export async function runRuntimeIntegrityCommand(projectRoot, argv, io) {
+    const args = parseArgs(argv);
+    const config = await readConfig(projectRoot);
+    const harnesses = config.harnesses;
+    const findings = [];
+    findings.push(await checkStaleSentinel(projectRoot));
+    findings.push(await checkFlowState(projectRoot));
+    findings.push(await checkManagedManifest(projectRoot));
+    findings.push(...await checkHarnessShims(projectRoot, harnesses));
+    for (const harness of harnesses) {
+        if (harness === "claude" || harness === "cursor" || harness === "codex") {
+            findings.push(await checkHookDocument(projectRoot, harness));
+        }
+    }
+    findings.push(await checkCodexHooksFlag(harnesses));
+    const report = buildReport(findings);
+    if (!args.quiet) {
+        if (args.json) {
+            io.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+        }
+        else {
+            writeTextReport(io, report);
+        }
+    }
+    return report.ok ? 0 : 1;
+}

package/dist/internal/tdd-red-evidence.js

@@ -95,7 +95,7 @@ export async function runTddRedEvidenceCommand(projectRoot, tokens, io) {
     if (!effectiveRunId || effectiveRunId.trim().length === 0) {
         const reason = "tdd-red-evidence: cannot scope check — no --runId provided and " +
             "flow-state.json has no activeRunId. Pass --runId=<id> explicitly " +
-            "or run `cclaw doctor` to reconcile state.";
+            "or run `npx cclaw-cli sync` to reconcile state.";
         if (!args.quiet) {
             io.stdout.write(`${JSON.stringify({
                 ok: false,

package/dist/knowledge-store.d.ts

@@ -4,7 +4,7 @@ export type KnowledgeEntryConfidence = "high" | "medium" | "low";
 export type KnowledgeEntrySeverity = "critical" | "important" | "suggestion";
 export type KnowledgeEntryUniversality = "project" | "personal" | "universal";
 export type KnowledgeEntryMaturity = "raw" | "lifted-to-rule" | "lifted-to-enforcement";
-export type KnowledgeEntrySource = "stage" | "retro" | "compound" | "ideate" | "manual";
+export type KnowledgeEntrySource = "stage" | "retro" | "compound" | "idea" | "manual";
 export interface KnowledgeEntry {
     type: KnowledgeEntryType;
     trigger: string;
@@ -36,8 +36,6 @@ export interface KnowledgeSeedEntry {
     stage?: FlowStage | null;
     origin_stage?: FlowStage | null;
     origin_run?: string | null;
-    /** @deprecated Use `origin_run`. Accepted only for legacy JSONL/backfill inputs. */
-    origin_feature?: string | null;
     frequency?: number;
     universality?: KnowledgeEntryUniversality;
     maturity?: KnowledgeEntryMaturity;
@@ -143,7 +141,7 @@ export interface ComputeCompoundReadinessOptions {
     maxReady?: number;
     now?: Date;
     /**
-     * Count of archived runs under `.cclaw/runs/`. When supplied and
+     * Count of archived runs under `.cclaw/archive/`. When supplied and
      * `< SMALL_PROJECT_ARCHIVE_RUNS_THRESHOLD`, the effective threshold
      * is lowered to `min(threshold, SMALL_PROJECT_RECURRENCE_THRESHOLD)`.
      * Matches the rule documented in `docs/config.md`.
@@ -174,10 +172,7 @@ export declare function effectiveCompoundThreshold(baseThreshold: number, archiv
  * as ready.
  */
 export declare function computeCompoundReadiness(entries: KnowledgeEntry[], options?: ComputeCompoundReadinessOptions): CompoundReadiness;
-export interface ValidateKnowledgeEntryOptions {
-    allowLegacyOriginFeature?: boolean;
-}
-export declare function validateKnowledgeEntry(entry: unknown, options?: ValidateKnowledgeEntryOptions): {
+export declare function validateKnowledgeEntry(entry: unknown): {
     ok: boolean;
     errors: string[];
 };

package/dist/knowledge-store.js

@@ -149,7 +149,7 @@ const KNOWLEDGE_SOURCE_SET = new Set([
     "stage",
     "retro",
     "compound",
-    "ideate",
+    "idea",
     "manual"
 ]);
 const FLOW_STAGE_SET = new Set(FLOW_STAGES);
@@ -175,8 +175,8 @@ KNOWLEDGE_ALLOWED_KEYS.add("source");
 KNOWLEDGE_ALLOWED_KEYS.add("severity");
 KNOWLEDGE_ALLOWED_KEYS.add("supersedes");
 KNOWLEDGE_ALLOWED_KEYS.add("superseded_by");
-function keyAllowedInKnowledgeEntry(key, options) {
-    return KNOWLEDGE_ALLOWED_KEYS.has(key) || (options.allowLegacyOriginFeature === true && key === "origin_feature");
+function keyAllowedInKnowledgeEntry(key) {
+    return KNOWLEDGE_ALLOWED_KEYS.has(key);
 }
 function knowledgePath(projectRoot) {
     return path.join(projectRoot, RUNTIME_ROOT, "knowledge.jsonl");
@@ -219,13 +219,6 @@ function emptyKnowledgeSnapshot() {
         entryByIndex: new Map()
     };
 }
-function normalizeLegacyKnowledgeEntry(entry) {
-    const { origin_feature: legacyOriginRun, ...rest } = entry;
-    return {
-        ...rest,
-        origin_run: entry.origin_run ?? legacyOriginRun ?? null
-    };
-}
 function parseKnowledgeSnapshot(raw) {
     const lines = stripBom(raw).split(/\r?\n/u);
     const entries = [];
@@ -238,12 +231,12 @@ function parseKnowledgeSnapshot(raw) {
             continue;
         try {
             const parsed = JSON.parse(trimmed);
-            const validated = validateKnowledgeEntry(parsed, { allowLegacyOriginFeature: true });
+            const validated = validateKnowledgeEntry(parsed);
             if (!validated.ok) {
                 malformedLines += 1;
                 continue;
             }
-            const entry = normalizeLegacyKnowledgeEntry(parsed);
+            const entry = parsed;
             entries.push(entry);
             const key = dedupeKey(entry);
             if (!keyToIndex.has(key)) {
@@ -296,24 +289,20 @@ function isNullableString(value) {
 function isNullableStage(value) {
     return value === null || (typeof value === "string" && FLOW_STAGE_SET.has(value));
 }
-export function validateKnowledgeEntry(entry, options = {}) {
+export function validateKnowledgeEntry(entry) {
     const errors = [];
     if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
         return { ok: false, errors: ["Knowledge entry must be a JSON object."] };
     }
     const obj = entry;
     for (const key of Object.keys(obj)) {
-        if (!keyAllowedInKnowledgeEntry(key, options)) {
+        if (!keyAllowedInKnowledgeEntry(key)) {
             errors.push(`Unknown key "${key}" in knowledge entry.`);
         }
     }
     for (const key of KNOWLEDGE_REQUIRED_KEYS) {
         if (!Object.prototype.hasOwnProperty.call(obj, key)) {
-            if (key !== "origin_run" ||
-                options.allowLegacyOriginFeature !== true ||
-                !Object.prototype.hasOwnProperty.call(obj, "origin_feature")) {
-                errors.push(`Missing required key "${key}".`);
-            }
+            errors.push(`Missing required key "${key}".`);
         }
     }
     if (!KNOWLEDGE_TYPE_SET.has(obj.type)) {
@@ -341,11 +330,7 @@ export function validateKnowledgeEntry(entry, options = {}) {
     if (!isNullableStage(obj.origin_stage)) {
         errors.push(`origin_stage must be one of ${FLOW_STAGES.join(", ")} or null.`);
     }
-    const originRun = Object.prototype.hasOwnProperty.call(obj, "origin_run")
-        ? obj.origin_run
-        : options.allowLegacyOriginFeature === true
-            ? obj.origin_feature
-            : undefined;
+    const originRun = obj.origin_run;
     if (!isNullableString(originRun)) {
         errors.push("origin_run must be string or null.");
     }
@@ -380,10 +365,12 @@ export function validateKnowledgeEntry(entry, options = {}) {
         (typeof obj.superseded_by !== "string" || obj.superseded_by.trim().length === 0)) {
         errors.push("superseded_by must be a non-empty string when present.");
     }
-    if (obj.source !== undefined &&
-        obj.source !== null &&
-        (typeof obj.source !== "string" || !KNOWLEDGE_SOURCE_SET.has(obj.source))) {
-        errors.push("source must be one of: stage, retro, compound, ideate, manual, or null.");
+    const sourceAllowed = obj.source === undefined ||
+        obj.source === null ||
+        (typeof obj.source === "string" &&
+            KNOWLEDGE_SOURCE_SET.has(obj.source));
+    if (!sourceAllowed) {
+        errors.push("source must be one of: stage, retro, compound, idea, manual, or null.");
     }
     return { ok: errors.length === 0, errors };
 }
@@ -391,7 +378,7 @@ export function materializeKnowledgeEntry(seed, defaults = {}) {
     const now = normalizeUtcIso(defaults.nowIso ?? nowUtcIso());
     const stage = seed.stage ?? defaults.stage ?? null;
     const originStage = seed.origin_stage ?? defaults.originStage ?? stage ?? null;
-    const originRun = seed.origin_run ?? seed.origin_feature ?? defaults.originRun ?? null;
+    const originRun = seed.origin_run ?? defaults.originRun ?? null;
     const source = seed.source ?? defaults.source ?? null;
     const entry = {
         type: seed.type,

package/dist/managed-resources.js

@@ -60,7 +60,7 @@ export function isManagedGeneratedPath(relPath) {
         return false;
     if (relPath.startsWith(`${RUNTIME_ROOT}/artifacts/`))
         return false;
-    if (relPath.startsWith(`${RUNTIME_ROOT}/runs/`))
+    if (relPath.startsWith(`${RUNTIME_ROOT}/archive/`))
         return false;
     if (relPath === `${RUNTIME_ROOT}/state/flow-state.json`)
         return false;
@@ -209,7 +209,29 @@ export class ManagedResourceSession {
         }
     }
     static async create(options) {
-        const previous = await readManagedResourceManifest(options.projectRoot).catch(() => null);
+        const manifestPath = path.join(options.projectRoot, MANAGED_RESOURCE_MANIFEST_REL_PATH);
+        let previous = null;
+        if (await exists(manifestPath)) {
+            let raw;
+            try {
+                raw = JSON.parse(await fs.readFile(manifestPath, "utf8"));
+            }
+            catch (error) {
+                throw new Error(`[sync fail-fast] Managed resource manifest is corrupt JSON (${MANAGED_RESOURCE_MANIFEST_REL_PATH}): ${error instanceof Error ? error.message : String(error)}. Fix/remove the manifest and rerun \`npx cclaw-cli sync\`.`);
+            }
+            const issues = validateManagedResourceManifest(raw);
+            if (issues.length > 0) {
+                const detail = issues.slice(0, 12)
+                    .map((issue) => {
+                    const scope = issue.path ?? (issue.index !== undefined ? `resources[${issue.index}]` : "manifest");
+                    return `${scope}.${issue.field}: ${issue.message}`;
+                })
+                    .join("; ");
+                throw new Error(`[sync fail-fast] Managed resource manifest is malformed (${MANAGED_RESOURCE_MANIFEST_REL_PATH}): ${detail}. ` +
+                    `Fix/remove the manifest and rerun \`npx cclaw-cli sync\`.`);
+            }
+            previous = await readManagedResourceManifest(options.projectRoot).catch(() => null);
+        }
         return new ManagedResourceSession(options, previous);
     }
     shouldManage(filePath) {

package/dist/policy.js

@@ -62,11 +62,9 @@ export async function policyChecks(projectRoot, options = {}) {
         { file: runtimeFile("skills/learnings/SKILL.md"), needle: "## Manual Actions", name: "utility_skill:learnings:manual_actions" },
         { file: runtimeFile("skills/learnings/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:learnings:hard_gate" },
         { file: runtimeFile("commands/start.md"), needle: "## Algorithm", name: "utility_command:start:algorithm" },
-        { file: runtimeFile("commands/next.md"), needle: "## Algorithm", name: "utility_command:next:algorithm" },
-        { file: runtimeFile("commands/next.md"), needle: "closeout.shipSubstate", name: "utility_command:next:closeout_chain" },
-        { 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/idea.md"), needle: "## Algorithm", name: "utility_command:idea:algorithm" },
+        { file: runtimeFile("skills/flow-idea/SKILL.md"), needle: "## Protocol", name: "utility_skill:idea:protocol" },
+        { file: runtimeFile("skills/flow-idea/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:idea:hard_gate" },
         { file: runtimeFile("commands/view.md"), needle: "## Routing", name: "utility_command:view:routing" },
         { file: runtimeFile("skills/flow-view/SKILL.md"), needle: "## Status Subcommand", name: "utility_skill:view:status_section" },
         { file: runtimeFile("skills/flow-view/SKILL.md"), needle: "## Tree Subcommand", name: "utility_skill:view:tree_section" },
@@ -96,7 +94,7 @@ export async function policyChecks(projectRoot, options = {}) {
         { file: runtimeFile("skills/using-cclaw/SKILL.md"), needle: "## Protocol Behavior", name: "meta_skill:protocol_behavior" },
         { file: runtimeFile("skills/using-cclaw/SKILL.md"), needle: "## Failure guardrails", name: "meta_skill:failure_guardrails" },
         { file: runtimeFile("skills/session/SKILL.md"), needle: "## Session Resume Protocol", name: "utility_skill:session:resume" },
-        { file: runtimeFile("skills/brainstorming/SKILL.md"), needle: "## Shared Stage Guidance", name: "stage_skill:shared_guidance_inline" },
+        { file: runtimeFile("skills/brainstorm/SKILL.md"), needle: "## Shared Stage Guidance", name: "stage_skill:shared_guidance_inline" },
         { file: runtimeFile("hooks/run-hook.mjs"), needle: "activeRunId", name: "hooks:session_start:active_run" },
         { file: runtimeFile("hooks/run-hook.mjs"), needle: "write_to_cclaw_runtime", name: "hooks:guard:risky_write_advisory" },
         { file: runtimeFile("hooks/run-hook.mjs"), needle: "stage_invocation_without_recent_flow_read", name: "hooks:workflow_guard:flow_read_reason" },
@@ -127,7 +125,7 @@ export async function policyChecks(projectRoot, options = {}) {
         });
         utilitySkillChecks.push({
             file: ".cursor/rules/cclaw-workflow.mdc",
-            needle: "/cc-next",
+            needle: "/cc",
             name: "rules:cursor:next_command_guidance"
         });
     }

package/dist/run-archive.d.ts

@@ -56,6 +56,6 @@ export declare function archiveRun(projectRoot: string, runName?: string, option
  * Counts entries in the canonical JSONL knowledge store. An "active" entry is one
  * non-empty line that parses as JSON with the required `type` field belonging to the
  * allowed set. Malformed lines are ignored (not counted) but do not throw so that a
- * hand-edited file cannot break doctor/archive flows.
+ * hand-edited file cannot break sync/archive flows.
  */
 export declare function countActiveKnowledgeEntries(text: string): number;