cclaw-cli 7.7.0 → 8.1.0

package/dist/managed-resources.js

@@ -1,313 +0,0 @@
-import crypto from "node:crypto";
-import fs from "node:fs/promises";
-import path from "node:path";
-import { CCLAW_VERSION, RUNTIME_ROOT } from "./constants.js";
-import { HARNESS_IDS } from "./types.js";
-export const MANAGED_RESOURCE_MANIFEST_REL_PATH = `${RUNTIME_ROOT}/state/managed-resources.json`;
-const MANAGED_RESOURCE_HARNESSES = new Set(["core", ...HARNESS_IDS]);
-const SHA256_HEX_PATTERN = /^[a-f0-9]{64}$/iu;
-let activeSession = null;
-function sha256(content) {
-    return crypto.createHash("sha256").update(content).digest("hex");
-}
-function normalizeRelPath(projectRoot, filePath) {
-    const rel = path.relative(projectRoot, filePath).replace(/\\/gu, "/");
-    if (rel.startsWith("../") || rel === ".." || path.isAbsolute(rel))
-        return null;
-    return rel;
-}
-async function exists(filePath) {
-    try {
-        await fs.access(filePath);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function ensureDir(dirPath) {
-    await fs.mkdir(dirPath, { recursive: true });
-}
-async function atomicWrite(filePath, content, options = {}) {
-    await ensureDir(path.dirname(filePath));
-    const tempPath = path.join(path.dirname(filePath), `.${path.basename(filePath)}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
-    await fs.writeFile(tempPath, content, {
-        encoding: "utf8",
-        ...(options.mode !== undefined ? { mode: options.mode } : {})
-    });
-    await fs.rename(tempPath, filePath);
-    if (options.mode !== undefined) {
-        await fs.chmod(filePath, options.mode).catch(() => undefined);
-    }
-}
-function inferHarness(relPath) {
-    if (relPath.startsWith(".claude/"))
-        return "claude";
-    if (relPath.startsWith(".cursor/"))
-        return "cursor";
-    if (relPath.startsWith(".opencode/"))
-        return "opencode";
-    if (relPath.startsWith(".codex/") || relPath.startsWith(".agents/skills/"))
-        return "codex";
-    return "core";
-}
-export function isManagedGeneratedPath(relPath) {
-    if (relPath === MANAGED_RESOURCE_MANIFEST_REL_PATH)
-        return false;
-    if (relPath === `${RUNTIME_ROOT}/config.yaml`)
-        return false;
-    if (relPath === `${RUNTIME_ROOT}/knowledge.jsonl`)
-        return false;
-    if (relPath.startsWith(`${RUNTIME_ROOT}/artifacts/`))
-        return false;
-    if (relPath.startsWith(`${RUNTIME_ROOT}/worktrees/`))
-        return false;
-    if (relPath.startsWith(`${RUNTIME_ROOT}/archive/`))
-        return false;
-    if (relPath === `${RUNTIME_ROOT}/state/flow-state.json`)
-        return false;
-    if (relPath === `${RUNTIME_ROOT}/state/.init-in-progress`)
-        return false;
-    if (relPath.startsWith(`${RUNTIME_ROOT}/state/upgrade-backups/`))
-        return false;
-    if (relPath.startsWith(`${RUNTIME_ROOT}/state/sync-backups/`))
-        return false;
-    if (relPath === "AGENTS.md" || relPath === "CLAUDE.md")
-        return true;
-    if (relPath === `${RUNTIME_ROOT}/state/iron-laws.json`)
-        return true;
-    for (const prefix of [
-        `${RUNTIME_ROOT}/commands/`,
-        `${RUNTIME_ROOT}/skills/`,
-        `${RUNTIME_ROOT}/templates/`,
-        `${RUNTIME_ROOT}/rules/`,
-        `${RUNTIME_ROOT}/agents/`,
-        `${RUNTIME_ROOT}/hooks/`,
-        ".claude/commands/",
-        ".cursor/commands/",
-        ".opencode/commands/",
-        ".opencode/agents/",
-        ".codex/agents/",
-        ".agents/skills/"
-    ]) {
-        if (relPath.startsWith(prefix))
-            return true;
-    }
-    return relPath === ".claude/hooks/hooks.json" ||
-        relPath === ".cursor/hooks.json" ||
-        relPath === ".cursor/rules/cclaw-workflow.mdc" ||
-        relPath === ".codex/hooks.json" ||
-        relPath === ".opencode/plugins/cclaw-plugin.mjs";
-}
-function validationIssue(index, field, message, pathValue) {
-    return {
-        ...(index !== undefined ? { index } : {}),
-        ...(typeof pathValue === "string" ? { path: pathValue } : {}),
-        field,
-        message
-    };
-}
-function validateSha256(value) {
-    return typeof value === "string" && SHA256_HEX_PATTERN.test(value);
-}
-export function validateManagedResourceEntry(value, index) {
-    const issues = [];
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-        return [validationIssue(index, "entry", "entry must be an object")];
-    }
-    const entry = value;
-    if (typeof entry.path !== "string" || entry.path.trim().length === 0) {
-        issues.push(validationIssue(index, "path", "path must be a non-empty string", entry.path));
-    }
-    else if (entry.path.startsWith("../") || entry.path === ".." || path.isAbsolute(entry.path)) {
-        issues.push(validationIssue(index, "path", "path must be project-relative", entry.path));
-    }
-    else if (!isManagedGeneratedPath(entry.path)) {
-        issues.push(validationIssue(index, "path", "path must be a known generated cclaw surface", entry.path));
-    }
-    if (!validateSha256(entry.sha256)) {
-        issues.push(validationIssue(index, "sha256", "sha256 must be a 64-character hex digest", entry.path));
-    }
-    if (entry.owner !== "cclaw") {
-        issues.push(validationIssue(index, "owner", 'owner must be "cclaw"', entry.path));
-    }
-    if (typeof entry.harness !== "string" || !MANAGED_RESOURCE_HARNESSES.has(entry.harness)) {
-        issues.push(validationIssue(index, "harness", `harness must be one of: core, ${HARNESS_IDS.join(", ")}`, entry.path));
-    }
-    if (typeof entry.packageVersion !== "string" || entry.packageVersion.trim().length === 0) {
-        issues.push(validationIssue(index, "packageVersion", "packageVersion must be a non-empty string", entry.path));
-    }
-    if (typeof entry.prunable !== "boolean") {
-        issues.push(validationIssue(index, "prunable", "prunable must be a boolean", entry.path));
-    }
-    if (typeof entry.safeToOverwrite !== "boolean") {
-        issues.push(validationIssue(index, "safeToOverwrite", "safeToOverwrite must be a boolean", entry.path));
-    }
-    if (typeof entry.updatedAt !== "string" || entry.updatedAt.trim().length === 0) {
-        issues.push(validationIssue(index, "updatedAt", "updatedAt must be a non-empty string", entry.path));
-    }
-    if (entry.lastBackupPath !== undefined && (typeof entry.lastBackupPath !== "string" || entry.lastBackupPath.trim().length === 0)) {
-        issues.push(validationIssue(index, "lastBackupPath", "lastBackupPath must be a non-empty string when present", entry.path));
-    }
-    if (entry.previousSha256 !== undefined && !validateSha256(entry.previousSha256)) {
-        issues.push(validationIssue(index, "previousSha256", "previousSha256 must be a 64-character hex digest when present", entry.path));
-    }
-    return issues;
-}
-export function validateManagedResourceManifest(value) {
-    const issues = [];
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-        return [validationIssue(undefined, "manifest", "manifest must be an object")];
-    }
-    const manifest = value;
-    if (manifest.version !== 1) {
-        issues.push(validationIssue(undefined, "version", "version must be 1"));
-    }
-    if (typeof manifest.generatedAt !== "string" || manifest.generatedAt.trim().length === 0) {
-        issues.push(validationIssue(undefined, "generatedAt", "generatedAt must be a non-empty string"));
-    }
-    if (typeof manifest.packageVersion !== "string" || manifest.packageVersion.trim().length === 0) {
-        issues.push(validationIssue(undefined, "packageVersion", "packageVersion must be a non-empty string"));
-    }
-    if (!Array.isArray(manifest.resources)) {
-        issues.push(validationIssue(undefined, "resources", "resources must be an array"));
-        return issues;
-    }
-    manifest.resources.forEach((entry, index) => {
-        issues.push(...validateManagedResourceEntry(entry, index));
-    });
-    return issues;
-}
-export function isValidManagedResourceEntry(value) {
-    return validateManagedResourceEntry(value).length === 0;
-}
-export async function readManagedResourceManifest(projectRoot) {
-    const manifestPath = path.join(projectRoot, MANAGED_RESOURCE_MANIFEST_REL_PATH);
-    if (!(await exists(manifestPath)))
-        return null;
-    const parsed = JSON.parse(await fs.readFile(manifestPath, "utf8"));
-    if (parsed.version !== 1 || !Array.isArray(parsed.resources))
-        return null;
-    const resources = parsed.resources.filter(isValidManagedResourceEntry);
-    return {
-        version: 1,
-        generatedAt: typeof parsed.generatedAt === "string" ? parsed.generatedAt : new Date(0).toISOString(),
-        packageVersion: typeof parsed.packageVersion === "string" ? parsed.packageVersion : "unknown",
-        resources
-    };
-}
-export class ManagedResourceSession {
-    projectRoot;
-    operation;
-    timestamp;
-    previous = new Map();
-    touched = new Map();
-    constructor(options, previous) {
-        this.projectRoot = options.projectRoot;
-        this.operation = options.operation;
-        this.timestamp = new Date().toISOString().replace(/[:.]/gu, "-");
-        for (const entry of previous?.resources ?? []) {
-            this.previous.set(entry.path, entry);
-        }
-    }
-    static async create(options) {
-        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) {
-        const rel = normalizeRelPath(this.projectRoot, filePath);
-        return rel !== null && isManagedGeneratedPath(rel);
-    }
-    async writeFileSafe(filePath, content, options = {}) {
-        const rel = normalizeRelPath(this.projectRoot, filePath);
-        if (rel === null || !isManagedGeneratedPath(rel)) {
-            await atomicWrite(filePath, content, options);
-            return;
-        }
-        const nextHash = sha256(content);
-        const previous = this.previous.get(rel);
-        let previousSha256;
-        let lastBackupPath;
-        if (await exists(filePath)) {
-            const current = await fs.readFile(filePath);
-            const currentHash = sha256(current);
-            previousSha256 = currentHash;
-            const knownPrevious = previous?.sha256;
-            if (currentHash !== nextHash && (knownPrevious === undefined || currentHash !== knownPrevious)) {
-                const backupRoot = path.join(this.projectRoot, RUNTIME_ROOT, "state", this.operation === "upgrade" ? "upgrade-backups" : "sync-backups", this.timestamp);
-                const backupPath = path.join(backupRoot, rel);
-                await ensureDir(path.dirname(backupPath));
-                await fs.copyFile(filePath, backupPath);
-                lastBackupPath = normalizeRelPath(this.projectRoot, backupPath) ?? undefined;
-            }
-        }
-        await atomicWrite(filePath, content, options);
-        this.touched.set(rel, {
-            path: rel,
-            sha256: nextHash,
-            owner: "cclaw",
-            harness: inferHarness(rel),
-            packageVersion: CCLAW_VERSION,
-            prunable: true,
-            safeToOverwrite: true,
-            updatedAt: new Date().toISOString(),
-            ...(lastBackupPath ? { lastBackupPath } : {}),
-            ...(previousSha256 && previousSha256 !== nextHash ? { previousSha256 } : {})
-        });
-    }
-    async commit() {
-        const resourcesByPath = new Map(this.previous);
-        for (const [rel, entry] of this.touched) {
-            resourcesByPath.set(rel, entry);
-        }
-        const resources = [];
-        for (const entry of resourcesByPath.values()) {
-            if (await exists(path.join(this.projectRoot, entry.path))) {
-                resources.push(entry);
-            }
-        }
-        const manifest = {
-            version: 1,
-            generatedAt: new Date().toISOString(),
-            packageVersion: CCLAW_VERSION,
-            resources: resources.sort((a, b) => a.path.localeCompare(b.path))
-        };
-        await atomicWrite(path.join(this.projectRoot, MANAGED_RESOURCE_MANIFEST_REL_PATH), `${JSON.stringify(manifest, null, 2)}\n`, { mode: 0o600 });
-        return manifest;
-    }
-}
-export function getActiveManagedResourceSession() {
-    return activeSession;
-}
-export function setActiveManagedResourceSession(session) {
-    activeSession = session;
-}
-export function isManagedResourcePath(projectRoot, filePath) {
-    const rel = normalizeRelPath(projectRoot, filePath);
-    return rel !== null && isManagedGeneratedPath(rel);
-}
-export function hashManagedResourceContent(content) {
-    return sha256(content);
-}

package/dist/policy.d.ts

@@ -1,10 +0,0 @@
-import type { HarnessId } from "./types.js";
-export interface PolicyCheck {
-    name: string;
-    ok: boolean;
-    details: string;
-}
-export interface PolicyOptions {
-    harnesses?: HarnessId[];
-}
-export declare function policyChecks(projectRoot: string, options?: PolicyOptions): Promise<PolicyCheck[]>;

package/dist/policy.js

@@ -1,167 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { RUNTIME_ROOT } from "./constants.js";
-import { FLOW_STAGES } from "./types.js";
-import { stageSchema } from "./content/stage-schema.js";
-import { stageSkillFolder } from "./content/skills.js";
-import { exists } from "./fs-utils.js";
-const POLICY_RULES = [];
-const ALL_HARNESSES = ["claude", "cursor", "opencode", "codex"];
-export async function policyChecks(projectRoot, options = {}) {
-    const checks = [];
-    const rules = [...POLICY_RULES];
-    const activeHarnesses = new Set(options.harnesses && options.harnesses.length > 0 ? options.harnesses : ALL_HARNESSES);
-    for (const stage of FLOW_STAGES) {
-        const folder = stageSkillFolder(stage);
-        const schema = stageSchema(stage);
-        const skillFile = `${RUNTIME_ROOT}/skills/${folder}/SKILL.md`;
-        // --- skill mandatory sections ---
-        for (const heading of [
-            "## Process",
-            "## Exit Criteria",
-            "## Interaction Protocol",
-            "## Anti-Patterns & Red Flags",
-            "## HARD-GATE",
-            "## Checklist",
-            "## Context Loading",
-            "## Automatic Subagent Dispatch",
-            "## Cross-Stage Traceability",
-            "## Artifact Validation",
-            "## Completion Parameters",
-            "## Shared Stage Guidance"
-        ]) {
-            rules.push({
-                filePath: skillFile,
-                needle: heading,
-                name: `skill:${stage}:section:${heading.replace(/^## /, "").toLowerCase().replace(/[^a-z0-9]+/g, "_")}`
-            });
-        }
-        // --- gate IDs in skills ---
-        for (const gate of schema.requiredGates) {
-            rules.push({
-                filePath: skillFile,
-                needle: `\`${gate.id}\``,
-                name: `skill:${stage}:gate:${gate.id}`
-            });
-        }
-        // --- verification section for build/review/ship skills ---
-        if (["tdd", "review", "ship"].includes(stage)) {
-            rules.push({
-                filePath: skillFile,
-                needle: "## Verification Before Completion",
-                name: `skill:${stage}:section:verification_before_completion`
-            });
-        }
-    }
-    // --- utility skill checks ---
-    const runtimeFile = (relativePath) => `${RUNTIME_ROOT}/${relativePath}`;
-    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, stage, origin_stage, frequency, created, first_seen_ts, last_seen_ts, project", name: "utility_skill:learnings:field_order" },
-        { 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/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" },
-        { file: runtimeFile("skills/flow-view/SKILL.md"), needle: "## Diff Subcommand", name: "utility_skill:view:diff_section" },
-        { file: runtimeFile("skills/subagent-dev/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:sdd:hard_gate" },
-        { file: runtimeFile("skills/subagent-dev/SKILL.md"), needle: "## Status Contract", name: "utility_skill:sdd:status_contract" },
-        { file: runtimeFile("skills/subagent-dev/SKILL.md"), needle: "slice-builder", name: "utility_skill:sdd:implementer_template" },
-        { file: runtimeFile("skills/subagent-dev/SKILL.md"), needle: "## Model & Harness Routing Notes", name: "utility_skill:sdd:routing_notes" },
-        { file: runtimeFile("skills/parallel-dispatch/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:parallel:hard_gate" },
-        { file: runtimeFile("skills/parallel-dispatch/SKILL.md"), needle: "Review Army", name: "utility_skill:parallel:review_army" },
-        { file: runtimeFile("skills/parallel-dispatch/SKILL.md"), needle: "Reconciliation", name: "utility_skill:parallel:reconciliation" },
-        { file: runtimeFile("skills/parallel-dispatch/SKILL.md"), needle: "## Model & Harness Routing Notes", name: "utility_skill:parallel:routing_notes" },
-        { file: runtimeFile("skills/research/repo-scan.md"), needle: "# Repo Scan Playbook", name: "utility_skill:research:repo_scan" },
-        { file: runtimeFile("skills/research/learnings-lookup.md"), needle: "# Learnings Lookup Playbook", name: "utility_skill:research:learnings_lookup" },
-        { file: runtimeFile("skills/research/framework-docs-lookup.md"), needle: "# Framework Docs Lookup Playbook", name: "utility_skill:research:framework_docs_lookup" },
-        { file: runtimeFile("skills/research/best-practices-lookup.md"), needle: "# Best Practices Lookup Playbook", name: "utility_skill:research:best_practices_lookup" },
-        { file: runtimeFile("skills/research/git-history.md"), needle: "# Git History Playbook", name: "utility_skill:research:git_history" },
-        { file: runtimeFile("skills/session/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:session:hard_gate" },
-        { file: runtimeFile("skills/session/SKILL.md"), needle: "## Session Start Protocol", name: "utility_skill:session:start" },
-        { file: runtimeFile("skills/session/SKILL.md"), needle: "## Session Stop Protocol", name: "utility_skill:session:stop" },
-        { file: runtimeFile("skills/using-cclaw/SKILL.md"), needle: "## Routing flow", name: "meta_skill:routing_flow" },
-        { file: runtimeFile("skills/using-cclaw/SKILL.md"), needle: "## Task classification", name: "meta_skill:task_classification" },
-        { file: runtimeFile("skills/using-cclaw/SKILL.md"), needle: "## Stage quick map", name: "meta_skill:stage_quick_map" },
-        { file: runtimeFile("skills/using-cclaw/SKILL.md"), needle: "## Whole flow map", name: "meta_skill:whole_flow_map" },
-        { file: runtimeFile("skills/using-cclaw/SKILL.md"), needle: "post_ship_review -> archive", name: "meta_skill:closeout_chain" },
-        { file: runtimeFile("skills/using-cclaw/SKILL.md"), needle: "## Contextual Skill Activation", name: "meta_skill:contextual_skills" },
-        { 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/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: "session-start", name: "hooks:session_start:wired" },
-        { file: runtimeFile("hooks/run-hook.mjs"), needle: "stop-handoff", name: "hooks:stop_handoff:wired" },
-        { file: runtimeFile("hooks/opencode-plugin.mjs"), needle: "activeRunId", name: "hooks:opencode:active_run" },
-        { file: runtimeFile("hooks/run-hook.mjs"), needle: "Knowledge digest", name: "hooks:session_start:knowledge_digest" },
-        { file: runtimeFile("hooks/opencode-plugin.mjs"), needle: "Knowledge digest", name: "hooks:opencode:knowledge_digest" }
-    ];
-    if (activeHarnesses.has("opencode")) {
-        utilitySkillChecks.push({
-            file: ".opencode/plugins/cclaw-plugin.mjs",
-            needle: "session-start",
-            name: "hooks:opencode:deployed_session_start_hook"
-        });
-        utilitySkillChecks.push({
-            file: ".opencode/plugins/cclaw-plugin.mjs",
-            needle: "stop-handoff",
-            name: "hooks:opencode:deployed_stop_handoff_hook"
-        });
-    }
-    if (activeHarnesses.has("cursor")) {
-        utilitySkillChecks.push({
-            file: ".cursor/rules/cclaw-workflow.mdc",
-            needle: "cclaw-managed-cursor-workflow-rule",
-            name: "rules:cursor:managed_marker"
-        });
-        utilitySkillChecks.push({
-            file: ".cursor/rules/cclaw-workflow.mdc",
-            needle: "/cc",
-            name: "rules:cursor:next_command_guidance"
-        });
-    }
-    for (const check of utilitySkillChecks) {
-        rules.push({
-            filePath: check.file,
-            needle: check.needle,
-            name: check.name
-        });
-    }
-    const contentCache = new Map();
-    const readCached = async (filePath) => {
-        if (contentCache.has(filePath)) {
-            return contentCache.get(filePath) ?? null;
-        }
-        if (!(await exists(filePath))) {
-            contentCache.set(filePath, null);
-            return null;
-        }
-        const content = await fs.readFile(filePath, "utf8");
-        contentCache.set(filePath, content);
-        return content;
-    };
-    for (const rule of rules) {
-        const filePath = path.join(projectRoot, rule.filePath);
-        const content = await readCached(filePath);
-        if (content === null) {
-            checks.push({
-                name: rule.name,
-                ok: false,
-                details: `${filePath} not found`
-            });
-            continue;
-        }
-        checks.push({
-            name: rule.name,
-            ok: content.includes(rule.needle),
-            details: `expect "${rule.needle}" in ${filePath}`
-        });
-    }
-    return checks;
-}

package/dist/retro-gate.d.ts

@@ -1,9 +0,0 @@
-import type { FlowState } from "./flow-state.js";
-export interface RetroGateStatus {
-    required: boolean;
-    completed: boolean;
-    compoundEntries: number;
-    hasRetroArtifact: boolean;
-    skipped: boolean;
-}
-export declare function evaluateRetroGate(projectRoot: string, state: FlowState): Promise<RetroGateStatus>;

package/dist/retro-gate.js

@@ -1,47 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { RUNTIME_ROOT } from "./constants.js";
-import { exists } from "./fs-utils.js";
-function activeArtifactsPath(projectRoot) {
-    return path.join(projectRoot, RUNTIME_ROOT, "artifacts");
-}
-function retroArtifactPath(projectRoot) {
-    return path.join(activeArtifactsPath(projectRoot), "09-retro.md");
-}
-function parseIsoTimestamp(value) {
-    if (!value || value.trim().length === 0)
-        return null;
-    const parsed = Date.parse(value);
-    return Number.isFinite(parsed) ? parsed : null;
-}
-export async function evaluateRetroGate(projectRoot, state) {
-    const required = state.completedStages.includes("ship");
-    const artifactFile = retroArtifactPath(projectRoot);
-    let hasRetroArtifact = false;
-    if (await exists(artifactFile)) {
-        try {
-            const raw = await fs.readFile(artifactFile, "utf8");
-            hasRetroArtifact = raw.trim().length > 0;
-        }
-        catch {
-            hasRetroArtifact = false;
-        }
-    }
-    const retroSkipReason = state.closeout.retroSkipReason?.trim() ?? "";
-    const retroSkipped = state.closeout.retroSkipped === true && retroSkipReason.length > 0;
-    const retroAccepted = hasRetroArtifact && parseIsoTimestamp(state.closeout.retroAcceptedAt) !== null;
-    const compoundSkipped = state.closeout.compoundSkipped === true;
-    const compoundReviewed = parseIsoTimestamp(state.closeout.compoundCompletedAt) !== null ||
-        state.closeout.compoundPromoted > 0;
-    const compoundEntries = compoundReviewed ? Math.max(0, Math.floor(state.closeout.compoundPromoted)) : 0;
-    // Keep retro-gate deterministic from closeout state only:
-    // retroComplete = (retroAccepted || retroSkipped) && (compoundReviewed || compoundSkipped)
-    const completed = required ? (retroAccepted || retroSkipped) && (compoundReviewed || compoundSkipped) : true;
-    return {
-        required,
-        completed,
-        compoundEntries,
-        hasRetroArtifact,
-        skipped: retroSkipped
-    };
-}

package/dist/run-archive.d.ts

@@ -1,61 +0,0 @@
-import { type FlowState } from "./flow-state.js";
-import type { FlowStage } from "./types.js";
-export declare const ARCHIVE_DISPOSITIONS: readonly ["completed", "cancelled", "abandoned"];
-export type ArchiveDisposition = (typeof ARCHIVE_DISPOSITIONS)[number];
-export interface CclawRunMeta {
-    id: string;
-    title: string;
-    createdAt: string;
-}
-export interface ArchiveRunResult {
-    archiveId: string;
-    archivePath: string;
-    archivedAt: string;
-    runName: string;
-    resetState: FlowState;
-    snapshottedStateFiles: string[];
-    disposition: ArchiveDisposition;
-    dispositionReason?: string;
-    /** Knowledge curation hint: total active entries + soft threshold (50). */
-    knowledge: {
-        activeEntryCount: number;
-        softThreshold: number;
-        overThreshold: boolean;
-        knowledgePath: string;
-    };
-    retro: {
-        required: boolean;
-        completed: boolean;
-        skipped: boolean;
-        skipReason?: string;
-        compoundEntries: number;
-    };
-}
-export interface ArchiveManifest {
-    version: 2;
-    archiveId: string;
-    archivedAt: string;
-    runName: string;
-    sourceRunId: string;
-    sourceCurrentStage: FlowStage;
-    sourceCompletedStages: FlowStage[];
-    snapshottedStateFiles: string[];
-    disposition: ArchiveDisposition;
-    dispositionReason?: string;
-    retro: ArchiveRunResult["retro"];
-}
-export interface ArchiveRunOptions {
-    skipRetro?: boolean;
-    skipRetroReason?: string;
-    disposition?: ArchiveDisposition;
-    dispositionReason?: string;
-}
-export declare function listRuns(projectRoot: string): Promise<CclawRunMeta[]>;
-export declare function archiveRun(projectRoot: string, runName?: string, options?: ArchiveRunOptions): Promise<ArchiveRunResult>;
-/**
- * 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 sync/archive flows.
- */
-export declare function countActiveKnowledgeEntries(text: string): number;