cclaw-cli 0.51.30 → 1.0.0

package/dist/run-persistence.js

@@ -15,7 +15,7 @@ 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 FLOW_STAGE_SET = new Set(FLOW_STAGES);
 function validateFlowTransition(prev, next) {
@@ -69,8 +69,8 @@ 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 archiveRoot(projectRoot) {
+    return path.join(projectRoot, ARCHIVE_DIR_REL_PATH);
 }
 function activeArtifactsPath(projectRoot) {
     return path.join(projectRoot, ACTIVE_ARTIFACTS_REL_PATH);
@@ -263,7 +263,14 @@ function sanitizeCloseoutState(value) {
         return fallback;
     }
     const typed = value;
-    let shipSubstate = isShipSubstate(typed.shipSubstate) ? typed.shipSubstate : fallback.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"
@@ -288,11 +295,8 @@ 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;
-    if (!retroDone && (shipSubstate === "ready_to_archive" || shipSubstate === "compound_review")) {
-        shipSubstate = "retro_review";
-    }
-    else if (shipSubstate === "ready_to_archive" && !compoundDone) {
-        shipSubstate = "compound_review";
+    if (shipSubstate === "ready_to_archive" && (!retroDone || !compoundDone)) {
+        shipSubstate = "post_ship_review";
     }
     return {
         shipSubstate,
@@ -313,7 +317,7 @@ function coerceFlowState(parsed) {
     const activeRunId = typeof activeRunIdRaw === "string" && activeRunIdRaw.trim().length > 0
         ? activeRunIdRaw.trim()
         : next.activeRunId;
-    return {
+    const state = {
         schemaVersion: FLOW_STATE_SCHEMA_VERSION,
         activeRunId,
         currentStage: isFlowStage(parsed.currentStage) ? parsed.currentStage : next.currentStage,
@@ -327,6 +331,7 @@ function coerceFlowState(parsed) {
         retro: sanitizeRetroState(parsed.retro),
         closeout: sanitizeCloseoutState(parsed.closeout)
     };
+    return { state };
 }
 export class CorruptFlowStateError extends Error {
     statePath;
@@ -388,7 +393,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"));
     }
-    return coerceFlowState(parsed);
+    return coerceFlowState(parsed).state;
 }
 export async function writeFlowState(projectRoot, state, options = {}) {
     const doWrite = async () => {
@@ -398,7 +403,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 +411,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 +433,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/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;