cclaw-cli 0.51.29 → 0.55.2

package/dist/run-archive.js

@@ -7,7 +7,7 @@ import { readKnowledgeSafely } from "./knowledge-store.js";
 import { evaluateRetroGate } from "./retro-gate.js";
 import { ensureRunSystem, flowStateLockPathFor, readFlowState, writeFlowState } from "./run-persistence.js";
 export const ARCHIVE_DISPOSITIONS = ["completed", "cancelled", "abandoned"];
-const RUNS_DIR_REL_PATH = `${RUNTIME_ROOT}/runs`;
+const ARCHIVE_DIR_REL_PATH = `${RUNTIME_ROOT}/archive`;
 const ACTIVE_ARTIFACTS_REL_PATH = `${RUNTIME_ROOT}/artifacts`;
 const STATE_DIR_REL_PATH = `${RUNTIME_ROOT}/state`;
 /** State filenames explicitly excluded from the archive snapshot. */
@@ -24,8 +24,8 @@ const CRITICAL_STATE_SNAPSHOT_FILES = new Set([
     TDD_CYCLE_LOG_FILE,
     RECONCILIATION_NOTICES_FILE
 ]);
-function runsRoot(projectRoot) {
-    return path.join(projectRoot, RUNS_DIR_REL_PATH);
+function archiveRoot(projectRoot) {
+    return path.join(projectRoot, ARCHIVE_DIR_REL_PATH);
 }
 function activeArtifactsPath(projectRoot) {
     return path.join(projectRoot, ACTIVE_ARTIFACTS_REL_PATH);
@@ -150,14 +150,14 @@ async function inferRunNameFromArtifacts(projectRoot) {
 async function uniqueArchiveId(projectRoot, baseId) {
     let index = 1;
     let candidate = baseId;
-    while (await exists(path.join(runsRoot(projectRoot), candidate))) {
+    while (await exists(path.join(archiveRoot(projectRoot), candidate))) {
         index += 1;
         candidate = `${baseId}-${index}`;
     }
     return candidate;
 }
 export async function listRuns(projectRoot) {
-    const root = runsRoot(projectRoot);
+    const root = archiveRoot(projectRoot);
     if (!(await exists(root))) {
         return [];
     }
@@ -194,15 +194,15 @@ export async function archiveRun(projectRoot, runName, options = {}) {
     return withDirectoryLock(archiveLockPath(projectRoot), async () => {
         return withDirectoryLock(flowStateLockPathFor(projectRoot), async () => {
             const artifactsDir = activeArtifactsPath(projectRoot);
-            const runsDir = runsRoot(projectRoot);
-            await ensureDir(runsDir);
+            const archiveDir = archiveRoot(projectRoot);
+            await ensureDir(archiveDir);
             await ensureDir(artifactsDir);
             const archiveRunName = (runName?.trim() && runName.trim().length > 0)
                 ? runName.trim()
                 : await inferRunNameFromArtifacts(projectRoot);
             const archiveBaseId = `${toArchiveDate()}-${slugifyRunName(archiveRunName)}`;
             const archiveId = await uniqueArchiveId(projectRoot, archiveBaseId);
-            const archivePath = path.join(runsDir, archiveId);
+            const archivePath = path.join(archiveDir, archiveId);
             const archiveArtifactsPath = path.join(archivePath, "artifacts");
             let sourceState = await readFlowState(projectRoot);
             const retroGate = await evaluateRetroGate(projectRoot, sourceState);
@@ -232,20 +232,20 @@ export async function archiveRun(projectRoot, runName, options = {}) {
             }
             if (!nonCompletedDisposition && inShipCloseout && skipRetro) {
                 throw new Error("Archive blocked: --skip-retro is not allowed while current stage is ship. " +
-                    "Complete closeout to ready_to_archive via /cc-next.");
+                    "Complete closeout to ready_to_archive via /cc.");
             }
             if (!nonCompletedDisposition && inShipCloseout && !readyForArchive) {
                 throw new Error("Archive blocked: closeout is not ready_to_archive. " +
-                    "Resume /cc-next until closeout reaches ready_to_archive.");
+                    "Resume /cc until closeout reaches ready_to_archive.");
             }
             if (!nonCompletedDisposition && shipCompleted && !readyForArchive && !skipRetro) {
                 throw new Error("Archive blocked: closeout is not ready_to_archive. " +
-                    "Resume /cc-next until closeout reaches ready_to_archive, " +
+                    "Resume /cc until closeout reaches ready_to_archive, " +
                     "or run `cclaw archive --skip-retro --retro-reason=<text>` for CLI-only flows.");
             }
             if (!nonCompletedDisposition && retroGate.required && !retroGate.completed && !skipRetro && !retroSkippedInCloseout) {
                 throw new Error("Archive blocked: retro gate is required after ship completion. " +
-                    "Run /cc-next (auto-runs retro) or, for CLI-only flows, re-run `cclaw archive --skip-retro --retro-reason=<text>`.");
+                    "Run /cc (auto-runs retro) or, for CLI-only flows, re-run `cclaw archive --skip-retro --retro-reason=<text>`.");
             }
             if (retroGate.completed) {
                 const completedAt = sourceState.retro.completedAt ?? new Date().toISOString();
@@ -273,7 +273,7 @@ export async function archiveRun(projectRoot, runName, options = {}) {
             await ensureDir(archivePath);
             // Drop an `.archive-in-progress` sentinel immediately so that a crash
             // between the artifact rename and the final manifest write leaves a
-            // recoverable marker (doctor surfaces these; re-running archive on an
+            // recoverable marker (sync reports these; re-running archive on an
             // orphan attempts to complete or roll back). The sentinel is removed
             // only after the manifest lands successfully.
             const sentinelPath = path.join(archivePath, ".archive-in-progress");
@@ -326,7 +326,7 @@ export async function archiveRun(projectRoot, runName, options = {}) {
                 // Best-effort rollback: if artifacts were moved but the subsequent
                 // steps failed, put artifacts back so the user is not left without
                 // a working run. The sentinel is intentionally left behind for
-                // inspection; doctor surfaces it.
+                // inspection; sync reports it.
                 if (artifactsMoved) {
                     try {
                         await fs.rm(artifactsDir, { recursive: true, force: true });
@@ -334,7 +334,7 @@ export async function archiveRun(projectRoot, runName, options = {}) {
                     }
                     catch {
                         // Rollback failed — sentinel + orphaned archive dir will be
-                        // surfaced by doctor and can be reconciled manually.
+                        // surfaced by sync and can be reconciled manually.
                     }
                 }
                 if (stateReset) {
@@ -371,7 +371,7 @@ async function readKnowledgeStats(projectRoot) {
  * 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 function countActiveKnowledgeEntries(text) {
     const allowed = new Set(["rule", "pattern", "lesson", "compound"]);

package/dist/run-persistence.js

@@ -15,8 +15,13 @@ export class InvalidStageTransitionError extends Error {
     }
 }
 const FLOW_STATE_REL_PATH = `${RUNTIME_ROOT}/state/flow-state.json`;
-const RUNS_DIR_REL_PATH = `${RUNTIME_ROOT}/runs`;
+const ARCHIVE_DIR_REL_PATH = `${RUNTIME_ROOT}/archive`;
 const ACTIVE_ARTIFACTS_REL_PATH = `${RUNTIME_ROOT}/artifacts`;
+const RECONCILIATION_NOTICES_REL_PATH = `${RUNTIME_ROOT}/state/reconciliation-notices.json`;
+const RECONCILIATION_NOTICES_LOCK_REL_PATH = `${RUNTIME_ROOT}/state/.reconciliation-notices.lock`;
+const RECONCILIATION_NOTICES_SCHEMA_VERSION = 1;
+const CLOSEOUT_SUBSTATE_DEMOTION_KIND = "closeout_substate_demotion";
+const CLOSEOUT_SUBSTATE_GATE_ID = "closeout.shipSubstate";
 const FLOW_STAGE_SET = new Set(FLOW_STAGES);
 function validateFlowTransition(prev, next) {
     if (prev.activeRunId !== next.activeRunId) {
@@ -60,7 +65,7 @@ function validateFlowTransition(prev, next) {
     const isNaturalForward = naturalForward === next.currentStage;
     const isReviewRewind = prev.currentStage === "review" && next.currentStage === "tdd";
     if (!isNaturalForward && !isReviewRewind) {
-        throw new InvalidStageTransitionError(prev.currentStage, next.currentStage, `no transition rule allows "${prev.currentStage}" -> "${next.currentStage}" for track "${prev.track}". Use /cc-next to advance stages or archive the run to reset.`);
+        throw new InvalidStageTransitionError(prev.currentStage, next.currentStage, `no transition rule allows "${prev.currentStage}" -> "${next.currentStage}" for track "${prev.track}". Use /cc to advance stages or archive the run to reset.`);
     }
 }
 function flowStatePath(projectRoot) {
@@ -69,12 +74,88 @@ function flowStatePath(projectRoot) {
 function flowStateLockPath(projectRoot) {
     return path.join(projectRoot, RUNTIME_ROOT, "state", ".flow-state.lock");
 }
-function runsRoot(projectRoot) {
-    return path.join(projectRoot, RUNS_DIR_REL_PATH);
+function reconciliationNoticesPath(projectRoot) {
+    return path.join(projectRoot, RECONCILIATION_NOTICES_REL_PATH);
+}
+function reconciliationNoticesLockPath(projectRoot) {
+    return path.join(projectRoot, RECONCILIATION_NOTICES_LOCK_REL_PATH);
+}
+function archiveRoot(projectRoot) {
+    return path.join(projectRoot, ARCHIVE_DIR_REL_PATH);
 }
 function activeArtifactsPath(projectRoot) {
     return path.join(projectRoot, ACTIVE_ARTIFACTS_REL_PATH);
 }
+function asObjectRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    return value;
+}
+async function appendCloseoutSubstateDemotionNotice(projectRoot, state, demotion) {
+    await withDirectoryLock(reconciliationNoticesLockPath(projectRoot), async () => {
+        const filePath = reconciliationNoticesPath(projectRoot);
+        const existingNotices = [];
+        if (await exists(filePath)) {
+            try {
+                const raw = JSON.parse(await fs.readFile(filePath, "utf8"));
+                const parsed = asObjectRecord(raw);
+                const noticesRaw = parsed?.notices;
+                if (Array.isArray(noticesRaw)) {
+                    for (const notice of noticesRaw) {
+                        const typed = asObjectRecord(notice);
+                        if (typed)
+                            existingNotices.push(typed);
+                    }
+                }
+            }
+            catch {
+                // Keep going with an empty payload; sync can still report parse errors.
+            }
+        }
+        const alreadyRecorded = existingNotices.some((notice) => {
+            if (notice.runId !== state.activeRunId)
+                return false;
+            if (notice.kind !== CLOSEOUT_SUBSTATE_DEMOTION_KIND)
+                return false;
+            const payload = asObjectRecord(notice.payload);
+            return payload?.previous === demotion.previous &&
+                payload?.next === demotion.next &&
+                payload?.reason === demotion.reason;
+        });
+        if (alreadyRecorded)
+            return;
+        const ts = new Date().toISOString();
+        existingNotices.push({
+            id: `${state.activeRunId}:${state.currentStage}:${CLOSEOUT_SUBSTATE_GATE_ID}:${CLOSEOUT_SUBSTATE_DEMOTION_KIND}:${ts}`,
+            runId: state.activeRunId,
+            stage: state.currentStage,
+            gateId: CLOSEOUT_SUBSTATE_GATE_ID,
+            reason: demotion.reason,
+            demotedAt: ts,
+            kind: CLOSEOUT_SUBSTATE_DEMOTION_KIND,
+            payload: {
+                previous: demotion.previous,
+                next: demotion.next,
+                reason: demotion.reason
+            }
+        });
+        existingNotices.sort((left, right) => {
+            const leftTs = typeof left.demotedAt === "string" ? left.demotedAt : "";
+            const rightTs = typeof right.demotedAt === "string" ? right.demotedAt : "";
+            if (leftTs === rightTs) {
+                const leftId = typeof left.id === "string" ? left.id : "";
+                const rightId = typeof right.id === "string" ? right.id : "";
+                return leftId.localeCompare(rightId);
+            }
+            return leftTs.localeCompare(rightTs);
+        });
+        await ensureDir(path.dirname(filePath));
+        await writeFileSafe(filePath, `${JSON.stringify({
+            schemaVersion: RECONCILIATION_NOTICES_SCHEMA_VERSION,
+            notices: existingNotices
+        }, null, 2)}\n`, { mode: 0o600 });
+    });
+}
 function isFlowStage(value) {
     return typeof value === "string" && FLOW_STAGE_SET.has(value);
 }
@@ -257,13 +338,14 @@ function sanitizeRetroState(value) {
 function isShipSubstate(value) {
     return typeof value === "string" && SHIP_SUBSTATES.includes(value);
 }
-function sanitizeCloseoutState(value) {
+function sanitizeCloseoutState(value, onDemotion) {
     const fallback = createInitialCloseoutState();
     if (!value || typeof value !== "object" || Array.isArray(value)) {
         return fallback;
     }
     const typed = value;
     let shipSubstate = isShipSubstate(typed.shipSubstate) ? typed.shipSubstate : fallback.shipSubstate;
+    const previousShipSubstate = shipSubstate;
     const retroDraftedAt = typeof typed.retroDraftedAt === "string" ? typed.retroDraftedAt : undefined;
     const retroAcceptedAt = typeof typed.retroAcceptedAt === "string" ? typed.retroAcceptedAt : undefined;
     const retroSkipReason = typeof typed.retroSkipReason === "string"
@@ -288,11 +370,21 @@ function sanitizeCloseoutState(value) {
     // the compound leg, which would let `archive` skip durable closeout proof.
     const retroDone = retroAcceptedAt !== undefined || retroSkipped === true;
     const compoundDone = compoundCompletedAt !== undefined || compoundPromoted > 0 || compoundSkipped === true;
+    let demotionReason;
     if (!retroDone && (shipSubstate === "ready_to_archive" || shipSubstate === "compound_review")) {
         shipSubstate = "retro_review";
+        demotionReason = "retro closeout leg is incomplete (missing retroAcceptedAt or explicit retro skip).";
     }
     else if (shipSubstate === "ready_to_archive" && !compoundDone) {
         shipSubstate = "compound_review";
+        demotionReason = "compound closeout leg is incomplete (missing compound proof).";
+    }
+    if (demotionReason && previousShipSubstate !== shipSubstate) {
+        onDemotion?.({
+            previous: previousShipSubstate,
+            next: shipSubstate,
+            reason: demotionReason
+        });
     }
     return {
         shipSubstate,
@@ -313,7 +405,8 @@ function coerceFlowState(parsed) {
     const activeRunId = typeof activeRunIdRaw === "string" && activeRunIdRaw.trim().length > 0
         ? activeRunIdRaw.trim()
         : next.activeRunId;
-    return {
+    let closeoutDemotion;
+    const state = {
         schemaVersion: FLOW_STATE_SCHEMA_VERSION,
         activeRunId,
         currentStage: isFlowStage(parsed.currentStage) ? parsed.currentStage : next.currentStage,
@@ -325,8 +418,11 @@ function coerceFlowState(parsed) {
         staleStages: sanitizeStaleStages(parsed.staleStages),
         rewinds: sanitizeRewinds(parsed.rewinds),
         retro: sanitizeRetroState(parsed.retro),
-        closeout: sanitizeCloseoutState(parsed.closeout)
+        closeout: sanitizeCloseoutState(parsed.closeout, (demotion) => {
+            closeoutDemotion = demotion;
+        })
     };
+    return { state, closeoutDemotion };
 }
 export class CorruptFlowStateError extends Error {
     statePath;
@@ -388,7 +484,11 @@ export async function readFlowState(projectRoot, options = {}) {
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
         await quarantineCorruptState(statePath, new Error("flow-state.json did not deserialize to a JSON object"));
     }
-    return coerceFlowState(parsed);
+    const coerced = coerceFlowState(parsed);
+    if (coerced.closeoutDemotion) {
+        await appendCloseoutSubstateDemotionNotice(projectRoot, coerced.state, coerced.closeoutDemotion);
+    }
+    return coerced.state;
 }
 export async function writeFlowState(projectRoot, state, options = {}) {
     const doWrite = async () => {
@@ -398,7 +498,7 @@ export async function writeFlowState(projectRoot, state, options = {}) {
                 const raw = await fs.readFile(statePath, "utf8");
                 const parsed = JSON.parse(raw);
                 if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-                    const prev = coerceFlowState(parsed);
+                    const prev = coerceFlowState(parsed).state;
                     validateFlowTransition(prev, state);
                 }
             }
@@ -406,10 +506,10 @@ export async function writeFlowState(projectRoot, state, options = {}) {
                 if (err instanceof InvalidStageTransitionError) {
                     throw err;
                 }
-                throw new Error(`cannot validate flow-state transition because ${FLOW_STATE_REL_PATH} is unreadable or corrupt (${err instanceof Error ? err.message : String(err)}). Run \`cclaw doctor\` and reconcile the state before retrying.`);
+                throw new Error(`cannot validate flow-state transition because ${FLOW_STATE_REL_PATH} is unreadable or corrupt (${err instanceof Error ? err.message : String(err)}). Run \`npx cclaw-cli sync\` and reconcile the state before retrying.`);
             }
         }
-        const safe = coerceFlowState({ ...state });
+        const safe = coerceFlowState({ ...state }).state;
         await writeFileSafe(statePath, `${JSON.stringify(safe, null, 2)}\n`, { mode: 0o600 });
     };
     if (options.skipLock) {
@@ -428,7 +528,7 @@ export function flowStateLockPathFor(projectRoot) {
     return flowStateLockPath(projectRoot);
 }
 export async function ensureRunSystem(projectRoot, _options = {}) {
-    await ensureDir(runsRoot(projectRoot));
+    await ensureDir(archiveRoot(projectRoot));
     await ensureDir(activeArtifactsPath(projectRoot));
     const statePath = flowStatePath(projectRoot);
     const state = await readFlowState(projectRoot);

package/dist/tdd-cycle.d.ts

@@ -30,13 +30,13 @@ export interface TddCycleParseIssue {
 export interface ParseTddCycleLogOptions {
     /**
      * Collect one issue per dropped/malformed line. Callers that care
-     * (doctor, red-evidence) can surface them; hooks keep soft-fail.
+     * (sync/runtime checks, red-evidence) can surface them; hooks keep soft-fail.
      */
     issues?: TddCycleParseIssue[];
     /**
      * When true, reject lines that omit required fields instead of
      * back-filling them with defaults. Used by validation paths
-     * (`validateTddCycleOrder`, `cclaw doctor`) to avoid silently
+     * (`validateTddCycleOrder`, `npx cclaw-cli sync` fail-fast) to avoid silently
      * bucketing unscoped rows into "runId=active, stage=tdd". Soft paths
      * (generated hooks) keep the legacy defaults so a half-written file
      * never takes the session down.
@@ -92,7 +92,7 @@ export interface RalphLoopStatus {
  * Derive a lightweight Ralph Loop summary from parsed tdd-cycle-log entries.
  * The goal is to give the model a single source of truth for "am I done
  * iterating?" — it collapses per-slice progress and distinct closed AC IDs
- * (from GREEN rows) into a single artifact the next-command contract reads.
+ * (from GREEN rows) into a single artifact the progression contract reads.
  */
 export declare function computeRalphLoopStatus(entries: TddCycleEntry[], options?: {
     runId?: string;

package/dist/tdd-cycle.js

@@ -201,7 +201,7 @@ export function pathMatchesTarget(candidate, target) {
  * Derive a lightweight Ralph Loop summary from parsed tdd-cycle-log entries.
  * The goal is to give the model a single source of truth for "am I done
  * iterating?" — it collapses per-slice progress and distinct closed AC IDs
- * (from GREEN rows) into a single artifact the next-command contract reads.
+ * (from GREEN rows) into a single artifact the progression contract reads.
  */
 export function computeRalphLoopStatus(entries, options = {}) {
     const runId = options.runId ?? "active";

package/dist/types.d.ts

@@ -71,8 +71,7 @@ export interface TrackHeuristicsConfig {
  * when the harness supports native dispatch, otherwise fulfilled via
  * an explicit in-session role switch with evidence).
  *
- * Track gating: `enforceOnTracks` lists the tracks where the doctor
- * check escalates to a warning. Tracks outside this list still see
+ * Track gating: `enforceOnTracks` lists the tracks where the sync/runtime check escalates to a warning. Tracks outside this list still see
  * the skill prose but leave the decision to the user.
  *
  * All fields optional; sensible defaults: disabled, threshold 5, no
@@ -85,7 +84,7 @@ export interface SliceReviewConfig {
     filesChangedThreshold?: number;
     /** Glob hints; any plan-task touchPath match triggers review. */
     touchTriggers?: string[];
-    /** Tracks on which missed reviews escalate to a doctor warning. */
+    /** Tracks on which missed reviews escalate to a sync/runtime warning. */
     enforceOnTracks?: FlowTrack[];
 }
 /**
@@ -116,6 +115,17 @@ export interface TddPathConfig {
 export interface CompoundConfig {
     recurrenceThreshold?: number;
 }
+/**
+ * Early-stage Ralph loop policy for brainstorm/scope/design.
+ *
+ * - enabled: when false, skip early-loop gate/diagnostics and hook writes.
+ * - maxIterations: capped producer/critic iterations before convergence
+ *   escalation. Defaults to 3.
+ */
+export interface EarlyLoopConfig {
+    enabled?: boolean;
+    maxIterations?: number;
+}
 export interface IronLawsConfig {
     /**
      * Per-law escape hatch: list the iron-law ids that must always be strict,
@@ -128,13 +138,13 @@ export interface IronLawsConfig {
 /**
  * Optional opt-in audit toggles for additional stage lint gates.
  *
- * Disabled by default so existing projects are not forced into stricter
- * checks until they explicitly enable them in config.
+ * `scopePreAudit` stays opt-in (disabled by default). `staleDiagramAudit` is
+ * default-on and can be explicitly disabled when teams intentionally skip it.
  */
 export interface OptInAuditsConfig {
     /** When true, scope lint requires a filled `Pre-Scope System Audit` section. */
     scopePreAudit?: boolean;
-    /** When true, design lint runs stale diagram drift checks against blast radius files. */
+    /** Default true; when enabled, design lint runs stale diagram drift checks against blast radius files. */
     staleDiagramAudit?: boolean;
 }
 export interface ReviewLoopExternalSecondOpinionConfig {
@@ -176,6 +186,8 @@ export interface CclawConfig {
     tdd?: TddPathConfig;
     /** Compound-stage recurrence policy overrides. */
     compound?: CompoundConfig;
+    /** Early-stage producer/critic loop policy overrides. */
+    earlyLoop?: EarlyLoopConfig;
     /** When true, cclaw installs managed git pre-commit/pre-push wrappers. */
     gitHookGuards?: boolean;
     /** Default flow track for new runs (quick = shortened path, standard = full pipeline). */
@@ -208,10 +220,6 @@ export interface CclawConfig {
     /** Optional runtime knobs for outside-voice review loops. */
     reviewLoop?: ReviewLoopConfig;
 }
-/**
- * @deprecated Use `CclawConfig` instead.
- */
-export type VibyConfig = CclawConfig;
 export interface TransitionRule {
     from: FlowStage;
     to: FlowStage;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cclaw-cli",
-  "version": "0.51.29",
+  "version": "0.55.2",
   "description": "Installer-first flow toolkit for coding agents",
   "type": "module",
   "bin": {

package/dist/content/finish-command.d.ts

@@ -1,2 +0,0 @@
-export declare function finishCommandContract(): string;
-export declare function finishCommandSkillMarkdown(): string;

package/dist/content/finish-command.js

@@ -1,26 +0,0 @@
-export function finishCommandContract() {
-    return `# /cc-finish command contract
-
-Use this command when the user says the active run is complete and wants to close it out.
-
-## Protocol
-
-1. Read \`.cclaw/state/flow-state.json\` and \`.cclaw/commands/next.md\`.
-2. Confirm ship closeout is \`ready_to_archive\`. If not, route to \`/cc-next\` until retro and compound closeout are complete or explicitly skipped there.
-3. Run \`cclaw archive --disposition=completed\` from the project root.
-4. Report the archive path, reset run id, and any knowledge curation hint printed by the CLI.
-
-Completed archives keep strict closeout gates: do not bypass retro or compound review from this command.
-`;
-}
-export function finishCommandSkillMarkdown() {
-    return `---
-name: flow-finish
-description: Finish a completed cclaw run by archiving with completed disposition. Use when the user types /cc-finish or asks to finish, close, complete, or archive a successful run.
----
-
-# Finish cclaw Run
-
-Load and follow \`.cclaw/commands/finish.md\`. This is the successful closeout path and must preserve the normal ship closeout gates before archive.
-`;
-}

package/dist/content/ideate-command.d.ts

@@ -1,8 +0,0 @@
-import { type IdeateFrameId } from "./ideate-frames.js";
-export interface IdeateCommandOptions {
-    frameIds?: readonly IdeateFrameId[];
-    mode?: "repo-grounded" | "elsewhere-software" | "elsewhere-non-software" | "narrow";
-}
-export declare function minimumDistinctIdeateFrames(frameCount: number, mode?: IdeateCommandOptions["mode"]): number;
-export declare function ideateCommandContract(options?: IdeateCommandOptions): string;
-export declare function ideateCommandSkillMarkdown(options?: IdeateCommandOptions): string;

package/dist/content/ideate-frames.d.ts

@@ -1,31 +0,0 @@
-export type IdeateFrameId = "pain-friction" | "inversion" | "assumption-break" | "leverage" | "cross-domain-analogy" | "constraint-flip";
-export interface IdeateFrame {
-    id: IdeateFrameId;
-    label: string;
-    prompt: string;
-    examplePatterns: string[];
-}
-export interface IdeateFrameDispatchInput {
-    focus: string;
-    mode: "repo-grounded" | "elsewhere-software" | "elsewhere-non-software";
-    signalSummary: string[];
-}
-export interface IdeateFrameDispatchPlanEntry {
-    frameId: IdeateFrameId;
-    label: string;
-    prompt: string;
-}
-export interface IdeateCandidateDraft {
-    title: string;
-    evidencePath: string;
-    summary: string;
-    frameId: IdeateFrameId;
-}
-export interface IdeateCandidateMerged extends Omit<IdeateCandidateDraft, "frameId"> {
-    frameIds: IdeateFrameId[];
-}
-export declare const DEFAULT_IDEATE_FRAME_IDS: readonly IdeateFrameId[];
-export declare const IDEATE_FRAMES: readonly IdeateFrame[];
-export declare function resolveIdeateFrames(frameIds?: readonly IdeateFrameId[]): IdeateFrame[];
-export declare function buildIdeateFrameDispatchPlan(input: IdeateFrameDispatchInput, frameIds?: readonly IdeateFrameId[]): IdeateFrameDispatchPlanEntry[];
-export declare function dedupeIdeateCandidates(drafts: readonly IdeateCandidateDraft[]): IdeateCandidateMerged[];

package/dist/content/ideate-ranking.d.ts

@@ -1,25 +0,0 @@
-export type IdeateImpact = "high" | "medium" | "low";
-export type IdeateEffort = "s" | "m" | "l";
-export type IdeateConfidence = "high" | "medium" | "low";
-export interface IdeateCandidateEvaluationInput {
-    id: string;
-    title: string;
-    impact: IdeateImpact;
-    effort: IdeateEffort;
-    confidence: IdeateConfidence;
-    rationaleStrength: number;
-    counterArgumentStrength: number;
-}
-export interface IdeateCandidateEvaluation extends IdeateCandidateEvaluationInput {
-    disposition: "survivor" | "critiqued-out";
-    rankingScore: number;
-}
-export interface IdeateRankingResult {
-    survivors: IdeateCandidateEvaluation[];
-    critiquedOut: IdeateCandidateEvaluation[];
-    recommendationId: string | null;
-}
-export declare function isCritiquedOut(rationaleStrength: number, counterArgumentStrength: number): boolean;
-export declare function scoreIdeateCandidate(impact: IdeateImpact, effort: IdeateEffort, confidence: IdeateConfidence): number;
-export declare function evaluateIdeateCandidate(input: IdeateCandidateEvaluationInput): IdeateCandidateEvaluation;
-export declare function rankIdeateCandidates(inputs: readonly IdeateCandidateEvaluationInput[], maxSurvivors?: number): IdeateRankingResult;

package/dist/content/next-command.d.ts

@@ -1,20 +0,0 @@
-/**
- * Single source of truth for how /cc-next should treat Ralph Loop status.
- *
- * IMPORTANT: Ralph Loop is a **progress indicator + soft pre-advance nudge**,
- * not a hard gate. Hard enforcement always flows through flow-state.json
- * gates via `stage-complete.mjs`. Both the command contract and the skill
- * document render this same paragraph to prevent drift — see
- * `tests/e2e/next-command-ralph-loop-contract.test.ts`.
- */
-export declare const RALPH_LOOP_CONTRACT_MARKER = "ralph-loop-contract:v1";
-export declare function ralphLoopContractSnippet(): string;
-/**
- * Command contract for /cc-next — the primary progression command.
- * Reads flow-state, starts the current stage if unfinished, or advances if all gates pass.
- */
-export declare function nextCommandContract(): string;
-/**
- * Skill body for /cc-next — the primary flow progression command.
- */
-export declare function nextCommandSkillMarkdown(): string;