cclaw-cli 0.51.30 → 1.0.0

package/dist/content/utility-skills.js

@@ -5,128 +5,57 @@
 export function languageTypescriptSkill() {
     return `---
 name: language-typescript
-description: "TypeScript rule pack. Opt-in language lens. Use when reviewing or writing TypeScript/JavaScript diffs during tdd or review — enforces type-safety, runtime-boundary validation, and idiomatic patterns."
+description: "TypeScript rule pack. Compact opt-in lens for tdd/review when diffs touch TS/JS files."
 ---
 
 # TypeScript Rule Pack
 
-## Quick Start
-
-> 1. Activate during tdd or review whenever the diff touches \`.ts\`, \`.tsx\`, \`.mts\`, \`.cts\`, or \`.js\` files.
-> 2. Walk the rule tiers in order. Tier-1 violations block merge. Tier-2 need a named follow-up.
-> 3. Cite each finding as \`file:line — <rule id> — <one-line remediation>\`.
-
-## HARD-GATE
-
-Do not approve a TypeScript change that ships \`any\`, \`@ts-ignore\`, or
-\`@ts-expect-error\` *without* (a) a comment explaining why, (b) a linked issue,
-and (c) an assertion that the blast radius is bounded to the current file.
-No exceptions in production code paths.
-
-## Tier 1 — blocking rules
-
-1. **No silent \`any\`.** Unknown inputs must be typed as \`unknown\` first, then narrowed.
-2. **Runtime validate trust boundaries.** HTTP bodies, env vars, file contents, and
-   IPC payloads must be parsed through a schema validator (zod, valibot, io-ts) before
-   being treated as typed data.
-3. **No \`as\` without a narrowing reason.** \`value as Foo\` is only acceptable when
-   preceded by a runtime check that proves the shape (e.g. \`if ("id" in value)\`).
-4. **Exhaustive switches on discriminated unions.** Every \`switch\` on a tagged
-   union must end with a \`default\` branch that assigns to \`never\` to surface
-   missing cases at compile time.
-5. **Promise hygiene.** No unawaited promises in \`async\` functions; no
-   \`void promise\` unless documented. Use \`@typescript-eslint/no-floating-promises\`.
-6. **Null-safety at the boundary.** Optional chaining (\`?.\`) and nullish
-   coalescing (\`??\`) must only be used when the null path is handled, not as a
-   silent default.
+Use this only when a diff includes \`.ts\`, \`.tsx\`, \`.mts\`, \`.cts\`, or \`.js\`.
 
-## Tier 2 — follow-up rules
+## Blocking rules
 
-7. Prefer \`readonly\` for arrays/object fields that are not mutated.
-8. Prefer \`type\` aliases for unions, \`interface\` for extendable object shapes.
-9. Name generic parameters descriptively once they carry semantic meaning (\`TEvent\`, \`TPayload\`).
-10. Avoid re-exporting entire namespaces; named re-exports keep bundle analysis tractable.
-11. Co-locate test fixtures with their types to keep drift visible.
+1. **No silent \`any\` or blanket \`@ts-ignore\`.** Unknown input starts as \`unknown\` and gets narrowed.
+2. **Validate trust boundaries at runtime.** HTTP/env/file/IPC payloads require schema parse before typed use.
+3. **No floating promises.** Await promises or explicitly document fire-and-forget behavior.
+4. **Exhaustive union handling.** Discriminated-union switches must fail loudly on missing branches.
 
-## Anti-patterns
+## Follow-up rules
 
-- "It compiles, ship it" — compilation is necessary, not sufficient. Runtime boundary validation is the gate.
-- Casting library return types to tighten them without reading the library's actual contract.
-- Wrapping every function in \`try/catch\` and swallowing the error — errors must either be rethrown typed or mapped to a Result/Either shape.
-- Using enums where a string-literal union would do (enums carry runtime cost and erase at tree-shaking time only when \`const\`).
+- Prefer immutable/readonly data by default.
+- Keep types local and explicit at module boundaries.
+- Add/adjust tests when changing inferred public behavior.
 
-## Review output shape
+## Output format
 
-\`\`\`
-- **Rule:** T1-2 (runtime validate trust boundaries)
-- **File:line:** src/api/users.ts:42
-- **Finding:** POST body cast directly to \`UserCreateInput\`; no schema parse.
-- **Remediation:** Parse through \`userCreateSchema\` (zod) before passing to the service layer.
-\`\`\`
+\`file:line — rule id — concise remediation\`
 `;
 }
 export function languagePythonSkill() {
     return `---
 name: language-python
-description: "Python rule pack. Opt-in language lens. Use when reviewing or writing Python diffs during tdd or review — enforces typing, exception hygiene, and idiomatic patterns."
+description: "Python rule pack. Compact opt-in lens for tdd/review when diffs touch Python files."
 ---
 
 # Python Rule Pack
 
-## Quick Start
-
-> 1. Activate during tdd or review whenever the diff touches \`.py\` / \`.pyi\` files.
-> 2. Walk the rule tiers in order. Tier-1 violations block merge. Tier-2 need a named follow-up.
-> 3. Cite each finding as \`file:line — <rule id> — <one-line remediation>\`.
-
-## HARD-GATE
-
-Do not approve a Python change that catches bare \`except:\` or \`except Exception:\`
-in production code *without* (a) re-raising, (b) logging with \`logger.exception\`, or
-(c) a comment explaining the intentional swallow. Silent broad catches are the
-single biggest source of "works on my machine" bugs in Python services.
-
-## Tier 1 — blocking rules
-
-1. **Type hints on public APIs.** Every exported function, method, and dataclass
-   must have full type hints. Use \`from __future__ import annotations\` or PEP 604 union syntax.
-2. **No mutable default arguments.** \`def f(x=[])\` is a bug. Use \`None\` + inline default.
-3. **Exception specificity.** Catch the narrowest exception class you actually handle.
-4. **Context managers for resources.** Files, sockets, DB sessions, locks — always \`with\`.
-5. **No bare \`assert\` in production code.** \`assert\` is stripped under \`python -O\`.
-   For invariants, raise \`ValueError\`/\`RuntimeError\` explicitly.
-6. **Deterministic imports.** No conditional imports at module top level except for
-   platform branches; no import-time side effects.
-
-## Tier 2 — follow-up rules
-
-7. Prefer \`@dataclass(slots=True, frozen=True)\` for value objects.
-8. Prefer \`pathlib.Path\` over \`os.path\` for new code.
-9. Use f-strings for interpolation; reserve \`%\` and \`.format\` for logger messages (lazy eval).
-10. Use \`logging.getLogger(__name__)\` per module; never the root logger.
-11. Pin dependency ranges in \`pyproject.toml\`; lock with \`uv lock\` / \`pip-compile\`.
+Use this only when a diff includes \`.py\` / \`.pyi\`.
 
-## Async-specific
+## Blocking rules
 
-- Do not mix \`requests\`/sync I/O inside \`async def\`. Use \`httpx.AsyncClient\` / \`aiofiles\`.
-- \`asyncio.gather\` with \`return_exceptions=False\` cancels siblings on first failure — be explicit.
-- Every task created with \`asyncio.create_task\` must have its reference kept and awaited.
+1. **No broad silent catches.** Avoid bare \`except\` / \`except Exception\` unless re-raised or justified.
+2. **No mutable defaults.** Use \`None\` + local initialization.
+3. **Type exported surfaces.** Public functions/classes include clear type hints.
+4. **Resource safety by default.** File/DB/network handles use context managers.
 
-## Anti-patterns
+## Follow-up rules
 
-- Using \`**kwargs\` to avoid writing a real signature.
-- Monkey-patching modules from tests without a \`contextlib.contextmanager\` cleanup.
-- Treating \`__init__.py\` as a place to run logic (imports only).
-- Re-inventing \`itertools\`/\`functools\` instead of using stdlib.
+- Prefer explicit, narrow exceptions.
+- Keep async and sync I/O models separated.
+- Add/adjust tests with behavior changes.
 
-## Review output shape
+## Output format
 
-\`\`\`
-- **Rule:** P1-3 (exception specificity)
-- **File:line:** users/service.py:88
-- **Finding:** \`except Exception\` around DB call silently drops integrity errors.
-- **Remediation:** Catch \`IntegrityError\` explicitly; re-raise everything else.
-\`\`\`
+\`file:line — rule id — concise remediation\`
 `;
 }
 export function languageGoSkill() {
@@ -211,7 +140,7 @@ export const LANGUAGE_RULE_PACK_FILES = {
 };
 /**
  * Folder (relative to runtime root) that holds every enabled language rule
- * pack. A single folder keeps discovery trivial for hooks and for `doctor`.
+ * pack. A single folder keeps discovery trivial for hooks and for `sync`.
  */
 export const LANGUAGE_RULE_PACK_DIR = ["rules", "lang"];
 export const LANGUAGE_RULE_PACK_GENERATORS = {
@@ -221,7 +150,7 @@ export const LANGUAGE_RULE_PACK_GENERATORS = {
 };
 /**
  * Legacy per-language folders under `.cclaw/skills/` used in v0.7.0. Listed
- * here so `cclaw sync` and `doctor` can surface drift and the installer can
+ * here so `cclaw sync` and `sync` can surface drift and the installer can
  * clean them up after the move to `.cclaw/rules/lang/`.
  */
 export const LEGACY_LANGUAGE_RULE_PACK_FOLDERS = [

package/dist/content/view-command.js

@@ -32,8 +32,10 @@ ${conversationLanguagePolicyMarkdown()}
    - \`diff\` -> use the **Diff Subcommand** section in \`${RUNTIME_ROOT}/skills/${VIEW_SKILL_FOLDER}/SKILL.md\`
 3. Unknown subcommand -> print supported values and stop.
 
-## Headless mode
+## Headless mode (CI/automation only)
 
+Headless envelopes are a machine-mode exception for CI/automation orchestration.
+In normal interactive runs, respond with concise read-only prose instead.
 For machine orchestration, emit one JSON envelope:
 
 \`\`\`json
@@ -43,7 +45,7 @@ For machine orchestration, emit one JSON envelope:
 Use the parsed/defaulted subcommand in both \`payload.command\` and \`payload.subcommand\`; do not collapse \`tree\` or \`diff\` responses to \`status\`.
 
 Validate envelopes with:
-\`cclaw internal envelope-validate --stdin\`
+\`npx cclaw-cli internal envelope-validate --stdin\`
 
 ## Primary skill
 

package/dist/delegation.d.ts

@@ -34,6 +34,7 @@ export interface DelegationTokenUsage {
     output: number;
     model: string;
 }
+export type DelegationWaiverAcceptedBy = "user-flag";
 export type DelegationEntry = {
     stage: string;
     agent: string;
@@ -56,6 +57,7 @@ export type DelegationEntry = {
      */
     taskId?: string;
     waiverReason?: string;
+    acceptedBy?: DelegationWaiverAcceptedBy;
     ts?: string;
     /**
      * Run id the entry belongs to. Older ledgers written before 0.5.17 may omit this;

package/dist/delegation.js

@@ -198,6 +198,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") &&
+        (o.acceptedBy === undefined || o.acceptedBy === "user-flag") &&
         waiverOk &&
         (o.runId === undefined || typeof o.runId === "string") &&
         (o.fulfillmentMode === undefined ||
@@ -269,7 +270,7 @@ function parseLedger(raw, runId) {
                 // and entry, the entry has no fulfillmentMode, and there is no
                 // dispatch-surface or dispatch-id evidence on the row. We honor
                 // that by tagging fulfillmentMode = "legacy-inferred" so callers
-                // (stage-complete, doctor) can require an explicit `--rerecord`
+                // (stage-complete, sync/runtime checks) can require an explicit `--rerecord`
                 // before the row counts as proof-era.
                 const ledgerHasNoVersion = ledgerSchemaVersion === undefined || ledgerSchemaVersion === 1;
                 const entryHasNoVersion = item.schemaVersion === undefined || item.schemaVersion === 1;

package/dist/early-loop.d.ts

@@ -0,0 +1,66 @@
+export declare const EARLY_LOOP_STAGES: readonly ["brainstorm", "scope", "design"];
+export type EarlyLoopStage = (typeof EARLY_LOOP_STAGES)[number];
+export type EarlyLoopConcernSeverity = "critical" | "important" | "suggestion";
+export interface EarlyLoopConcern {
+    id: string;
+    severity: EarlyLoopConcernSeverity;
+    locator: string;
+    summary: string;
+    firstSeenIteration: number;
+    lastSeenIteration: number;
+    resolvedAtIteration?: number;
+}
+export interface EarlyLoopStatus {
+    schemaVersion: 1;
+    stage: EarlyLoopStage;
+    runId: string;
+    iteration: number;
+    maxIterations: number;
+    openConcerns: EarlyLoopConcern[];
+    resolvedConcerns: EarlyLoopConcern[];
+    lastSeenConcernIds: string[];
+    convergenceTripped: boolean;
+    escalationReason?: string;
+    lastUpdatedAt: string;
+}
+export interface EarlyLoopLogConcern {
+    id: string;
+    severity: EarlyLoopConcernSeverity;
+    locator: string;
+    summary: string;
+}
+export interface EarlyLoopLogEntry {
+    ts: string;
+    runId: string;
+    stage: string;
+    iteration?: number;
+    concerns: EarlyLoopLogConcern[];
+    resolvedConcernIds: string[];
+}
+export interface EarlyLoopParseIssue {
+    lineNumber: number;
+    reason: string;
+    rawLine: string;
+}
+export interface ParseEarlyLoopLogOptions {
+    issues?: EarlyLoopParseIssue[];
+    strict?: boolean;
+}
+export interface DeriveEarlyLoopStatusOptions {
+    stage: EarlyLoopStage;
+    runId: string;
+    maxIterations?: number;
+    now?: Date;
+}
+export interface ComputeEarlyLoopStatusOptions {
+    maxIterations?: number;
+    now?: Date;
+    parseIssues?: EarlyLoopParseIssue[];
+    strictParse?: boolean;
+}
+export declare function isEarlyLoopStage(value: unknown): value is EarlyLoopStage;
+export declare function normalizeEarlyLoopMaxIterations(value: number | undefined): number;
+export declare function parseEarlyLoopLog(text: string, options?: ParseEarlyLoopLogOptions): EarlyLoopLogEntry[];
+export declare function deriveEarlyLoopStatus(entries: EarlyLoopLogEntry[], options: DeriveEarlyLoopStatusOptions): EarlyLoopStatus;
+export declare function computeEarlyLoopStatus(stage: EarlyLoopStage, runId: string, concernsLogPath: string, options?: ComputeEarlyLoopStatusOptions): Promise<EarlyLoopStatus>;
+export declare function formatEarlyLoopStatusLine(status: EarlyLoopStatus): string;

package/dist/early-loop.js

@@ -0,0 +1,275 @@
+import fs from "node:fs/promises";
+import { DEFAULT_EARLY_LOOP_MAX_ITERATIONS } from "./config.js";
+export const EARLY_LOOP_STAGES = ["brainstorm", "scope", "design"];
+const CONCERN_ID_PREFIX = "C-";
+function severityWeight(severity) {
+    if (severity === "critical")
+        return 3;
+    if (severity === "important")
+        return 2;
+    return 1;
+}
+function normalizeSeverity(value) {
+    if (value === "critical" || value === "important" || value === "suggestion") {
+        return value;
+    }
+    return "important";
+}
+function normalizeText(value, fallback) {
+    if (typeof value !== "string")
+        return fallback;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : fallback;
+}
+function stableConcernFallbackId(locator, summary) {
+    const seed = `${locator}::${summary}`.trim().toLowerCase();
+    let hash = 0;
+    for (let index = 0; index < seed.length; index += 1) {
+        hash = (Math.imul(31, hash) + seed.charCodeAt(index)) >>> 0;
+    }
+    return `${CONCERN_ID_PREFIX}${hash.toString(16).padStart(8, "0")}`;
+}
+function normalizeConcernId(id, locator, summary) {
+    if (typeof id === "string") {
+        const trimmed = id.trim();
+        if (trimmed.length > 0) {
+            return trimmed;
+        }
+    }
+    return stableConcernFallbackId(locator, summary);
+}
+function normalizeConcerns(value) {
+    if (!Array.isArray(value))
+        return [];
+    const concerns = [];
+    for (const row of value) {
+        if (!row || typeof row !== "object" || Array.isArray(row))
+            continue;
+        const typed = row;
+        const locator = normalizeText(typed.locator, "unknown-location");
+        const summary = normalizeText(typed.summary, "missing-summary");
+        concerns.push({
+            id: normalizeConcernId(typed.id, locator, summary),
+            severity: normalizeSeverity(typed.severity),
+            locator,
+            summary
+        });
+    }
+    return concerns;
+}
+function normalizeResolvedConcernIds(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .filter((entry) => typeof entry === "string")
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0);
+}
+export function isEarlyLoopStage(value) {
+    return typeof value === "string" && EARLY_LOOP_STAGES.includes(value);
+}
+export function normalizeEarlyLoopMaxIterations(value) {
+    if (typeof value === "number" && Number.isInteger(value) && value >= 1) {
+        return value;
+    }
+    return DEFAULT_EARLY_LOOP_MAX_ITERATIONS;
+}
+export function parseEarlyLoopLog(text, options = {}) {
+    const strict = options.strict === true;
+    const issues = options.issues;
+    const normalized = text.charCodeAt(0) === 0xfeff ? text.slice(1) : text;
+    const lines = normalized.split(/\r?\n/u);
+    const entries = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        const raw = lines[index] ?? "";
+        const line = raw.trim();
+        if (line.length === 0)
+            continue;
+        const lineNumber = index + 1;
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch (error) {
+            issues?.push({
+                lineNumber,
+                reason: `json-parse-failed: ${error instanceof Error ? error.message : String(error)}`,
+                rawLine: raw
+            });
+            continue;
+        }
+        const runId = normalizeText(parsed.runId, "");
+        const stage = normalizeText(parsed.stage, "");
+        const concerns = normalizeConcerns(parsed.concerns);
+        const resolvedConcernIds = normalizeResolvedConcernIds(parsed.resolvedConcernIds);
+        const iteration = typeof parsed.iteration === "number" &&
+            Number.isInteger(parsed.iteration) &&
+            parsed.iteration >= 1
+            ? parsed.iteration
+            : undefined;
+        if (strict) {
+            const missing = [];
+            if (runId.length === 0)
+                missing.push("runId");
+            if (stage.length === 0)
+                missing.push("stage");
+            if (concerns.length === 0 && resolvedConcernIds.length === 0) {
+                missing.push("concerns/resolvedConcernIds");
+            }
+            if (missing.length > 0) {
+                issues?.push({
+                    lineNumber,
+                    reason: `missing-required-fields: ${missing.join(",")}`,
+                    rawLine: raw
+                });
+                continue;
+            }
+        }
+        entries.push({
+            ts: normalizeText(parsed.ts, ""),
+            runId: runId.length > 0 ? runId : "active",
+            stage: stage.length > 0 ? stage : "brainstorm",
+            iteration,
+            concerns,
+            resolvedConcernIds
+        });
+    }
+    return entries;
+}
+function sortConcerns(a, b) {
+    const severityDiff = severityWeight(b.severity) - severityWeight(a.severity);
+    if (severityDiff !== 0)
+        return severityDiff;
+    if (a.firstSeenIteration !== b.firstSeenIteration) {
+        return a.firstSeenIteration - b.firstSeenIteration;
+    }
+    if (a.lastSeenIteration !== b.lastSeenIteration) {
+        return a.lastSeenIteration - b.lastSeenIteration;
+    }
+    return a.id.localeCompare(b.id, "en");
+}
+export function deriveEarlyLoopStatus(entries, options) {
+    const maxIterations = normalizeEarlyLoopMaxIterations(options.maxIterations);
+    const concerns = new Map();
+    const filtered = entries.filter((entry) => entry.runId === options.runId && entry.stage === options.stage);
+    let previousConcernSnapshotKey = "";
+    let sameConcernStreak = 0;
+    let convergenceTripped = false;
+    let escalationReason;
+    let currentIteration = 0;
+    let lastSeenConcernIds = [];
+    for (const entry of filtered) {
+        currentIteration += 1;
+        const iteration = entry.iteration ?? currentIteration;
+        const seenThisIteration = new Set();
+        for (const concern of entry.concerns) {
+            seenThisIteration.add(concern.id);
+            const existing = concerns.get(concern.id);
+            if (!existing) {
+                concerns.set(concern.id, {
+                    id: concern.id,
+                    severity: concern.severity,
+                    locator: concern.locator,
+                    summary: concern.summary,
+                    firstSeenIteration: iteration,
+                    lastSeenIteration: iteration
+                });
+                continue;
+            }
+            existing.lastSeenIteration = iteration;
+            existing.locator = concern.locator;
+            existing.summary = concern.summary;
+            if (severityWeight(concern.severity) >= severityWeight(existing.severity)) {
+                existing.severity = concern.severity;
+            }
+            delete existing.resolvedAtIteration;
+        }
+        for (const concernId of entry.resolvedConcernIds) {
+            const existing = concerns.get(concernId);
+            if (!existing)
+                continue;
+            if (seenThisIteration.has(concernId))
+                continue;
+            if (existing.resolvedAtIteration === undefined) {
+                existing.resolvedAtIteration = iteration;
+            }
+        }
+        for (const concern of concerns.values()) {
+            if (concern.resolvedAtIteration !== undefined)
+                continue;
+            if (seenThisIteration.has(concern.id))
+                continue;
+            concern.resolvedAtIteration = iteration;
+        }
+        const openConcernIds = Array.from(concerns.values())
+            .filter((concern) => concern.resolvedAtIteration === undefined)
+            .map((concern) => concern.id)
+            .sort((a, b) => a.localeCompare(b, "en"));
+        lastSeenConcernIds = openConcernIds;
+        const snapshotKey = openConcernIds.join("|");
+        if (snapshotKey.length > 0 && snapshotKey === previousConcernSnapshotKey) {
+            sameConcernStreak += 1;
+            if (!convergenceTripped && sameConcernStreak >= 2) {
+                convergenceTripped = true;
+                escalationReason = `same concerns ${sameConcernStreak} iterations in a row`;
+            }
+        }
+        else {
+            sameConcernStreak = snapshotKey.length > 0 ? 1 : 0;
+        }
+        previousConcernSnapshotKey = snapshotKey;
+    }
+    const openConcerns = Array.from(concerns.values())
+        .filter((concern) => concern.resolvedAtIteration === undefined)
+        .sort(sortConcerns);
+    const resolvedConcerns = Array.from(concerns.values())
+        .filter((concern) => concern.resolvedAtIteration !== undefined)
+        .sort((a, b) => {
+        if (a.resolvedAtIteration !== b.resolvedAtIteration) {
+            return a.resolvedAtIteration - b.resolvedAtIteration;
+        }
+        return sortConcerns(a, b);
+    });
+    if (!convergenceTripped && openConcerns.length > 0 && currentIteration >= maxIterations) {
+        convergenceTripped = true;
+        escalationReason = `max iterations ${maxIterations} reached with ${openConcerns.length} open concern(s)`;
+    }
+    return {
+        schemaVersion: 1,
+        stage: options.stage,
+        runId: options.runId,
+        iteration: currentIteration,
+        maxIterations,
+        openConcerns,
+        resolvedConcerns,
+        lastSeenConcernIds,
+        convergenceTripped,
+        ...(escalationReason ? { escalationReason } : {}),
+        lastUpdatedAt: (options.now ?? new Date()).toISOString()
+    };
+}
+export async function computeEarlyLoopStatus(stage, runId, concernsLogPath, options = {}) {
+    let raw = "";
+    try {
+        raw = await fs.readFile(concernsLogPath, "utf8");
+    }
+    catch (error) {
+        if (error.code !== "ENOENT") {
+            throw error;
+        }
+    }
+    const parsed = parseEarlyLoopLog(raw, {
+        issues: options.parseIssues,
+        strict: options.strictParse
+    });
+    return deriveEarlyLoopStatus(parsed, {
+        stage,
+        runId,
+        maxIterations: options.maxIterations,
+        now: options.now
+    });
+}
+export function formatEarlyLoopStatusLine(status) {
+    const convergence = status.convergenceTripped ? "tripped" : "clear";
+    return `Early Loop: stage=${status.stage}, iter=${status.iteration}/${status.maxIterations}, open=${status.openConcerns.length}, convergence=${convergence}`;
+}

package/dist/flow-state.d.ts

@@ -32,14 +32,13 @@ export interface RetroState {
 /**
  * Ship closeout substate machine.
  *
- * After ship completes, cclaw auto-chains retro → compound → archive.
+ * After ship completes, cclaw auto-chains post-ship review → archive.
  * Each step is interruptible: `/cc` reads `shipSubstate` and resumes
  * from the correct step even across sessions.
  *
  * - `idle` — ship not complete, or closeout not yet started.
- * - `retro_review` — 09-retro.md draft exists; awaiting user edit/accept/skip.
- * - `compound_review` — retro accepted; compound pass awaiting execution
- *   (or user skip).
+ * - `post_ship_review` — unified closeout leg: retro acceptance/edit/skip
+ *   plus compound pass execution (or explicit skip).
  * - `ready_to_archive` — retro + compound done; archive is the next
  *   automatic step.
  * - `archived` — archive completed in this session (transient — archive
@@ -53,7 +52,7 @@ export interface RetroState {
  * These are not duplicates: `done` lives in stage transitions; `archived` /
  * `idle` live in closeout lifecycle state.
  */
-export declare const SHIP_SUBSTATES: readonly ["idle", "retro_review", "compound_review", "ready_to_archive", "archived"];
+export declare const SHIP_SUBSTATES: readonly ["idle", "post_ship_review", "ready_to_archive", "archived"];
 export type ShipSubstate = (typeof SHIP_SUBSTATES)[number];
 export interface CloseoutState {
     shipSubstate: ShipSubstate;
@@ -85,7 +84,7 @@ export interface FlowState {
     rewinds: RewindRecord[];
     /** Mandatory retrospective gate status before archive. */
     retro: RetroState;
-    /** Ship → retro → compound → archive substate for resumable closeout. */
+    /** Ship → post_ship_review → archive substate for resumable closeout. */
     closeout: CloseoutState;
 }
 export interface InitialFlowStateOptions {

package/dist/flow-state.js

@@ -5,14 +5,13 @@ export const FLOW_STATE_SCHEMA_VERSION = 1;
 /**
  * Ship closeout substate machine.
  *
- * After ship completes, cclaw auto-chains retro → compound → archive.
+ * After ship completes, cclaw auto-chains post-ship review → archive.
  * Each step is interruptible: `/cc` reads `shipSubstate` and resumes
  * from the correct step even across sessions.
  *
  * - `idle` — ship not complete, or closeout not yet started.
- * - `retro_review` — 09-retro.md draft exists; awaiting user edit/accept/skip.
- * - `compound_review` — retro accepted; compound pass awaiting execution
- *   (or user skip).
+ * - `post_ship_review` — unified closeout leg: retro acceptance/edit/skip
+ *   plus compound pass execution (or explicit skip).
  * - `ready_to_archive` — retro + compound done; archive is the next
  *   automatic step.
  * - `archived` — archive completed in this session (transient — archive
@@ -28,8 +27,7 @@ export const FLOW_STATE_SCHEMA_VERSION = 1;
  */
 export const SHIP_SUBSTATES = [
     "idle",
-    "retro_review",
-    "compound_review",
+    "post_ship_review",
     "ready_to_archive",
     "archived"
 ];

package/dist/gate-evidence.d.ts

@@ -29,29 +29,6 @@ export interface CompletedStagesClosureResult {
         blocked: string[];
     }>;
 }
-export declare const RECONCILIATION_NOTICES_REL_PATH = ".cclaw/state/reconciliation-notices.json";
-export interface ReconciliationNotice {
-    id: string;
-    runId: string;
-    stage: FlowStage;
-    gateId: string;
-    reason: string;
-    demotedAt: string;
-}
-export interface ReconciliationNoticesPayload {
-    schemaVersion: number;
-    notices: ReconciliationNotice[];
-    parseOk: boolean;
-    schemaOk: boolean;
-}
-export interface ReconciliationNoticeBuckets {
-    activeBlocked: ReconciliationNotice[];
-    currentStageBlocked: ReconciliationNotice[];
-    unsynced: ReconciliationNotice[];
-    staleRun: ReconciliationNotice[];
-}
-export declare function readReconciliationNotices(projectRoot: string): Promise<ReconciliationNoticesPayload>;
-export declare function classifyReconciliationNotices(flowState: FlowState, notices: ReconciliationNotice[]): ReconciliationNoticeBuckets;
 export declare function verifyCurrentStageGateEvidence(projectRoot: string, flowState: FlowState): Promise<GateEvidenceCheckResult>;
 export declare function verifyCompletedStagesGateClosure(flowState: FlowState): CompletedStagesClosureResult;
 export interface GateReconciliationResult {