cclaw-cli 0.55.2 → 2.0.0

package/dist/run-persistence.js

@@ -17,11 +17,6 @@ export class InvalidStageTransitionError extends Error {
 const FLOW_STATE_REL_PATH = `${RUNTIME_ROOT}/state/flow-state.json`;
 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) {
@@ -74,88 +69,12 @@ function flowStatePath(projectRoot) {
 function flowStateLockPath(projectRoot) {
     return path.join(projectRoot, RUNTIME_ROOT, "state", ".flow-state.lock");
 }
-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);
 }
@@ -313,6 +232,31 @@ function sanitizeRewinds(value) {
     }
     return out;
 }
+function sanitizeInteractionHints(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return {};
+    }
+    const out = {};
+    for (const [stage, raw] of Object.entries(value)) {
+        if (!isFlowStage(stage))
+            continue;
+        if (!raw || typeof raw !== "object" || Array.isArray(raw))
+            continue;
+        const typed = raw;
+        const skipQuestions = typed.skipQuestions === true ? true : undefined;
+        const sourceStage = isFlowStage(typed.sourceStage) ? typed.sourceStage : undefined;
+        const recordedAt = typeof typed.recordedAt === "string" ? typed.recordedAt : undefined;
+        if (skipQuestions !== true && !sourceStage && !recordedAt) {
+            continue;
+        }
+        out[stage] = {
+            ...(skipQuestions ? { skipQuestions } : {}),
+            ...(sourceStage ? { sourceStage } : {}),
+            ...(recordedAt ? { recordedAt } : {})
+        };
+    }
+    return out;
+}
 function sanitizeRetroState(value) {
     const fallback = {
         required: false,
@@ -338,14 +282,20 @@ function sanitizeRetroState(value) {
 function isShipSubstate(value) {
     return typeof value === "string" && SHIP_SUBSTATES.includes(value);
 }
-function sanitizeCloseoutState(value, onDemotion) {
+function sanitizeCloseoutState(value) {
     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 rawShipSubstate = typeof typed.shipSubstate === "string" ? typed.shipSubstate : undefined;
+    let shipSubstate;
+    if (rawShipSubstate === "retro_review" || rawShipSubstate === "compound_review") {
+        shipSubstate = "post_ship_review";
+    }
+    else {
+        shipSubstate = isShipSubstate(rawShipSubstate) ? rawShipSubstate : fallback.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"
@@ -370,21 +320,8 @@ function sanitizeCloseoutState(value, onDemotion) {
     // 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
-        });
+    if (shipSubstate === "ready_to_archive" && (!retroDone || !compoundDone)) {
+        shipSubstate = "post_ship_review";
     }
     return {
         shipSubstate,
@@ -405,7 +342,6 @@ function coerceFlowState(parsed) {
     const activeRunId = typeof activeRunIdRaw === "string" && activeRunIdRaw.trim().length > 0
         ? activeRunIdRaw.trim()
         : next.activeRunId;
-    let closeoutDemotion;
     const state = {
         schemaVersion: FLOW_STATE_SCHEMA_VERSION,
         activeRunId,
@@ -417,12 +353,11 @@ function coerceFlowState(parsed) {
         skippedStages: sanitizeSkippedStages(parsed.skippedStages, track),
         staleStages: sanitizeStaleStages(parsed.staleStages),
         rewinds: sanitizeRewinds(parsed.rewinds),
+        interactionHints: sanitizeInteractionHints(parsed.interactionHints),
         retro: sanitizeRetroState(parsed.retro),
-        closeout: sanitizeCloseoutState(parsed.closeout, (demotion) => {
-            closeoutDemotion = demotion;
-        })
+        closeout: sanitizeCloseoutState(parsed.closeout)
     };
-    return { state, closeoutDemotion };
+    return { state };
 }
 export class CorruptFlowStateError extends Error {
     statePath;
@@ -484,11 +419,7 @@ 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"));
     }
-    const coerced = coerceFlowState(parsed);
-    if (coerced.closeoutDemotion) {
-        await appendCloseoutSubstateDemotionNotice(projectRoot, coerced.state, coerced.closeoutDemotion);
-    }
-    return coerced.state;
+    return coerceFlowState(parsed).state;
 }
 export async function writeFlowState(projectRoot, state, options = {}) {
     const doWrite = async () => {
@@ -527,12 +458,13 @@ export async function writeFlowState(projectRoot, state, options = {}) {
 export function flowStateLockPathFor(projectRoot) {
     return flowStateLockPath(projectRoot);
 }
-export async function ensureRunSystem(projectRoot, _options = {}) {
+export async function ensureRunSystem(projectRoot, options = {}) {
     await ensureDir(archiveRoot(projectRoot));
     await ensureDir(activeArtifactsPath(projectRoot));
     const statePath = flowStatePath(projectRoot);
     const state = await readFlowState(projectRoot);
-    if (!(await exists(statePath))) {
+    const createIfMissing = options.createIfMissing !== false;
+    if (createIfMissing && !(await exists(statePath))) {
         await writeFlowState(projectRoot, state, { allowReset: true });
     }
     return state;

package/dist/runtime/run-hook.entry.d.ts

@@ -0,0 +1,3 @@
+import { type NodeHookRuntimeOptions } from "../content/node-hooks.js";
+export declare function buildRunHookRuntimeScript(options?: NodeHookRuntimeOptions): string;
+export default buildRunHookRuntimeScript;

package/dist/runtime/run-hook.entry.js

@@ -0,0 +1,5 @@
+import { nodeHookRuntimeScript } from "../content/node-hooks.js";
+export function buildRunHookRuntimeScript(options = {}) {
+    return nodeHookRuntimeScript(options);
+}
+export default buildRunHookRuntimeScript;