cclaw-cli 0.55.2 → 2.0.0

package/dist/content/node-hooks.js

@@ -4,7 +4,7 @@ import { fileURLToPath } from "node:url";
 import { DEFAULT_COMPOUND_RECURRENCE_THRESHOLD, DEFAULT_EARLY_LOOP_MAX_ITERATIONS } from "../config.js";
 import { RUNTIME_ROOT } from "../constants.js";
 import { SMALL_PROJECT_ARCHIVE_RUNS_THRESHOLD, SMALL_PROJECT_RECURRENCE_THRESHOLD } from "../knowledge-store.js";
-import { HOOK_INLINE_SHARED_HELPERS, COMPOUND_READINESS_INLINE_SOURCE, RALPH_LOOP_INLINE_SOURCE, EARLY_LOOP_INLINE_SOURCE } from "./hook-inline-snippets.js";
+import { SHARED_FLOW_AND_KNOWLEDGE_SNIPPETS, SHARED_STAGE_SUPPORT_SNIPPETS } from "./runtime-shared-snippets.js";
 function normalizePatterns(patterns, fallback) {
     if (!patterns || patterns.length === 0)
         return [...fallback];
@@ -83,6 +83,13 @@ const EARLY_LOOP_ENABLED = ${JSON.stringify(earlyLoopEnabled)};
 const EARLY_LOOP_MAX_ITERATIONS = ${JSON.stringify(earlyLoopMaxIterations)};
 const CCLAW_CLI_ENTRYPOINT = ${JSON.stringify(cliRuntime.entrypoint)};
 const CCLAW_CLI_ARGS_PREFIX = ${JSON.stringify(cliRuntime.argsPrefix)};
+const SESSION_DIGEST_SCHEMA_VERSION = 1;
+const SESSION_DIGEST_CACHE_FILE = "session-digest.json";
+const SESSION_DIGEST_REFRESH_MARKER_FILE = "session-digest.refresh.json";
+const SESSION_DIGEST_REFRESH_STALE_MS = 30000;
+
+${SHARED_FLOW_AND_KNOWLEDGE_SNIPPETS}
+${SHARED_STAGE_SUPPORT_SNIPPETS}
 
 function resolveStrictness() {
   return process.env.CCLAW_STRICTNESS === "strict" ? "strict" : DEFAULT_STRICTNESS;
@@ -427,6 +434,73 @@ async function runCclawInternal(root, args, options = {}) {
   });
 }
 
+function compactStderr(value) {
+  const raw = typeof value === "string" ? value : "";
+  return raw.replace(/\\s+/gu, " ").trim();
+}
+
+function summarizeInternalFailure(operation, result) {
+  const detail = compactStderr(result && typeof result === "object" ? result.stderr : "");
+  return detail.length > 0 ? operation + ": " + detail : operation + " failed";
+}
+
+function parseJsonStdoutObject(result) {
+  const raw = typeof (result && result.stdout) === "string" ? result.stdout.trim() : "";
+  if (raw.length === 0) return null;
+  try {
+    return toObject(JSON.parse(raw));
+  } catch {
+    return null;
+  }
+}
+
+function firstStdoutLine(value) {
+  const raw = typeof value === "string" ? value : "";
+  const lines = raw
+    .split(/\\r?\\n/gu)
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0);
+  return lines[0] || "";
+}
+
+function formatRalphLoopStatusLineFromJson(status) {
+  const redOpenSlices = Array.isArray(status.redOpenSlices)
+    ? status.redOpenSlices.filter((value) => typeof value === "string")
+    : [];
+  const redOpen = redOpenSlices.length > 0 ? redOpenSlices.join(",") : "none";
+  const loopIteration =
+    typeof status.loopIteration === "number" && Number.isFinite(status.loopIteration)
+      ? Math.trunc(status.loopIteration)
+      : 0;
+  const sliceCount =
+    typeof status.sliceCount === "number" && Number.isFinite(status.sliceCount)
+      ? Math.trunc(status.sliceCount)
+      : 0;
+  const acClosed = Array.isArray(status.acClosed) ? status.acClosed.length : 0;
+  return "Ralph Loop: iter=" + String(loopIteration) +
+    ", slices=" + String(sliceCount) +
+    ", acClosed=" + String(acClosed) +
+    ", redOpen=" + redOpen;
+}
+
+function formatEarlyLoopStatusLineFromJson(status) {
+  const stage = typeof status.stage === "string" ? status.stage : "unknown";
+  const iteration =
+    typeof status.iteration === "number" && Number.isFinite(status.iteration)
+      ? Math.trunc(status.iteration)
+      : 0;
+  const maxIterations =
+    typeof status.maxIterations === "number" && Number.isFinite(status.maxIterations)
+      ? Math.trunc(status.maxIterations)
+      : EARLY_LOOP_MAX_ITERATIONS;
+  const openConcerns = Array.isArray(status.openConcerns) ? status.openConcerns.length : 0;
+  const convergence = status.convergenceTripped === true ? "tripped" : "clear";
+  return "Early Loop: stage=" + stage +
+    ", iter=" + String(iteration) + "/" + String(maxIterations) +
+    ", open=" + String(openConcerns) +
+    ", convergence=" + convergence;
+}
+
 function detectHarness(env) {
   if (env.CLAUDE_PROJECT_DIR) return "claude";
   if (env.CURSOR_PROJECT_DIR || env.CURSOR_PROJECT_ROOT) return "cursor";
@@ -438,9 +512,10 @@ function hookEventNameForOutput(hookName) {
   if (hookName === "session-start") return "SessionStart";
   if (hookName === "prompt-guard") return "PreToolUse";
   if (hookName === "workflow-guard") return "PreToolUse";
+  if (hookName === "pre-tool-pipeline") return "PreToolUse";
+  if (hookName === "prompt-pipeline") return "UserPromptSubmit";
   if (hookName === "context-monitor") return "PostToolUse";
   if (hookName === "stop-handoff") return "Stop";
-  if (hookName === "pre-compact") return "PreCompact";
   if (hookName === "verify-current-state") return "UserPromptSubmit";
   return "SessionStart";
 }
@@ -839,16 +914,215 @@ async function readFlowState(root) {
   // empty object. Silent fallbacks used to mask stale CLI+hook drift.
   const parsed = await readJsonFile(statePath, {}, { root, stage: "read-flow-state" });
   const obj = toObject(parsed) || {};
-  const completed = Array.isArray(obj.completedStages) ? obj.completedStages : [];
+  const summary = summarizeFlowState(obj);
   return {
     filePath: statePath,
-    currentStage: typeof obj.currentStage === "string" ? obj.currentStage : "none",
-    activeRunId: typeof obj.activeRunId === "string" ? obj.activeRunId : "active",
-    completedCount: completed.length,
+    currentStage: summary.stage,
+    activeRunId: summary.activeRunId === "none" ? "active" : summary.activeRunId,
+    completedCount: summary.completed,
     raw: obj
   };
 }
 
+async function readFileMtimeMs(filePath) {
+  try {
+    const stat = await fs.stat(filePath);
+    if (!stat.isFile()) return 0;
+    return Math.trunc(stat.mtimeMs);
+  } catch {
+    return 0;
+  }
+}
+
+function parseNumericMs(value) {
+  return typeof value === "number" && Number.isFinite(value)
+    ? Math.trunc(value)
+    : -1;
+}
+
+async function readSessionDigestLines(stateDir, state, flowStateMtimeMs) {
+  const cachePath = path.join(stateDir, SESSION_DIGEST_CACHE_FILE);
+  const cache = toObject(await readJsonFile(cachePath, {})) || {};
+  const cachedMtimeMs = parseNumericMs(cache.flowStateMtimeMs);
+  const sameStage = typeof cache.currentStage === "string" ? cache.currentStage === state.currentStage : true;
+  const sameRun = typeof cache.activeRunId === "string" ? cache.activeRunId === state.activeRunId : true;
+  const fresh = cachedMtimeMs === flowStateMtimeMs && sameStage && sameRun;
+  if (!fresh) {
+    return {
+      ralphLoopLine: "",
+      earlyLoopLine: "",
+      compoundReadinessLine: "",
+      fresh: false
+    };
+  }
+  return {
+    ralphLoopLine: typeof cache.ralphLoopLine === "string" ? cache.ralphLoopLine : "",
+    earlyLoopLine: typeof cache.earlyLoopLine === "string" ? cache.earlyLoopLine : "",
+    compoundReadinessLine: typeof cache.compoundReadinessLine === "string" ? cache.compoundReadinessLine : "",
+    fresh: true
+  };
+}
+
+async function refreshSessionDigestCache(root, state, flowStateMtimeMs) {
+  const stateDir = path.join(root, RUNTIME_ROOT, "state");
+  let ralphLoopLine = "";
+  let earlyLoopLine = "";
+  let compoundReadinessLine = "";
+
+  if (state.currentStage === "tdd") {
+    try {
+      const internalRalph = await runCclawInternal(
+        root,
+        ["tdd-loop-status", "--json", "--write"],
+        { captureStdout: true }
+      );
+      if (internalRalph.code !== 0) {
+        throw new Error(summarizeInternalFailure("tdd-loop-status", internalRalph));
+      }
+      const ralphStatus = parseJsonStdoutObject(internalRalph);
+      if (!ralphStatus) {
+        throw new Error("tdd-loop-status returned empty or malformed JSON");
+      }
+      ralphLoopLine = formatRalphLoopStatusLineFromJson(ralphStatus);
+    } catch (err) {
+      await recordHookError(
+        root,
+        "session-start:ralph-loop",
+        err instanceof Error ? err.message : String(err)
+      );
+    }
+  }
+  if (
+    EARLY_LOOP_ENABLED &&
+    (state.currentStage === "brainstorm" || state.currentStage === "scope" || state.currentStage === "design")
+  ) {
+    try {
+      const internalEarly = await runCclawInternal(
+        root,
+        [
+          "early-loop-status",
+          "--json",
+          "--write",
+          "--stage",
+          state.currentStage,
+          "--run-id",
+          state.activeRunId
+        ],
+        { captureStdout: true }
+      );
+      if (internalEarly.code !== 0) {
+        throw new Error(summarizeInternalFailure("early-loop-status", internalEarly));
+      }
+      const earlyLoopStatus = parseJsonStdoutObject(internalEarly);
+      if (!earlyLoopStatus) {
+        throw new Error("early-loop-status returned empty or malformed JSON");
+      }
+      earlyLoopLine = formatEarlyLoopStatusLineFromJson(earlyLoopStatus);
+    } catch (err) {
+      await recordHookError(
+        root,
+        "session-start:early-loop",
+        err instanceof Error ? err.message : String(err)
+      );
+    }
+  }
+
+  try {
+    const shouldShowReadiness = state.currentStage === "review" || state.currentStage === "ship";
+    const internalReadiness = await runCclawInternal(
+      root,
+      shouldShowReadiness ? ["compound-readiness"] : ["compound-readiness", "--quiet"],
+      { captureStdout: true }
+    );
+    if (internalReadiness.code !== 0) {
+      throw new Error(summarizeInternalFailure("compound-readiness", internalReadiness));
+    }
+    if (shouldShowReadiness) {
+      compoundReadinessLine = firstStdoutLine(internalReadiness.stdout);
+    }
+  } catch (err) {
+    await recordHookError(
+      root,
+      "session-start:compound-readiness",
+      err instanceof Error ? err.message : String(err)
+    );
+  }
+
+  const digestPath = path.join(stateDir, SESSION_DIGEST_CACHE_FILE);
+  await writeJsonFile(digestPath, {
+    schemaVersion: SESSION_DIGEST_SCHEMA_VERSION,
+    generatedAt: new Date().toISOString(),
+    flowStateMtimeMs,
+    currentStage: state.currentStage,
+    activeRunId: state.activeRunId,
+    ralphLoopLine,
+    earlyLoopLine,
+    compoundReadinessLine
+  });
+}
+
+async function scheduleSessionDigestRefresh(runtime, state, flowStateMtimeMs) {
+  if (flowStateMtimeMs <= 0) return;
+  const stateDir = path.join(runtime.root, RUNTIME_ROOT, "state");
+  const digestPath = path.join(stateDir, SESSION_DIGEST_CACHE_FILE);
+  const markerPath = path.join(stateDir, SESSION_DIGEST_REFRESH_MARKER_FILE);
+
+  const cache = toObject(await readJsonFile(digestPath, {})) || {};
+  const cachedMtimeMs = parseNumericMs(cache.flowStateMtimeMs);
+  if (cachedMtimeMs === flowStateMtimeMs) return;
+
+  const marker = toObject(await readJsonFile(markerPath, {})) || {};
+  const markerMtimeMs = parseNumericMs(marker.flowStateMtimeMs);
+  const markerStartedAtMs = parseNumericMs(marker.startedAtMs);
+  const markerFresh =
+    markerMtimeMs === flowStateMtimeMs &&
+    markerStartedAtMs > 0 &&
+    Date.now() - markerStartedAtMs < SESSION_DIGEST_REFRESH_STALE_MS;
+  if (markerFresh) return;
+
+  await writeJsonFile(markerPath, {
+    flowStateMtimeMs,
+    startedAtMs: Date.now(),
+    currentStage: state.currentStage,
+    activeRunId: state.activeRunId
+  });
+
+  try {
+    const child = spawn(process.execPath, [process.argv[1], "session-start-refresh"], {
+      cwd: runtime.root,
+      stdio: "ignore",
+      windowsHide: true,
+      detached: true,
+      env: {
+        ...process.env,
+        CCLAW_PROJECT_ROOT: runtime.root,
+        CCLAW_BG_WORKER: "1"
+      }
+    });
+    child.unref();
+  } catch (err) {
+    await fs.rm(markerPath, { force: true }).catch(() => undefined);
+    await recordHookError(
+      runtime.root,
+      "session-start:spawn-refresh",
+      err instanceof Error ? err.message : String(err)
+    );
+  }
+}
+
+async function handleSessionStartRefresh(runtime) {
+  const state = await readFlowState(runtime.root);
+  const stateDir = path.join(runtime.root, RUNTIME_ROOT, "state");
+  const markerPath = path.join(stateDir, SESSION_DIGEST_REFRESH_MARKER_FILE);
+  try {
+    const flowStateMtimeMs = await readFileMtimeMs(state.filePath);
+    await refreshSessionDigestCache(runtime.root, state, flowStateMtimeMs);
+  } finally {
+    await fs.rm(markerPath, { force: true }).catch(() => undefined);
+  }
+  return 0;
+}
+
 
 async function buildKnowledgeDigest(root, currentStage, prereadRaw) {
   const knowledgeFile = path.join(root, RUNTIME_ROOT, "knowledge.jsonl");
@@ -857,44 +1131,16 @@ async function buildKnowledgeDigest(root, currentStage, prereadRaw) {
   const raw = typeof prereadRaw === "string"
     ? prereadRaw
     : await readTextFile(knowledgeFile, "");
-  const lines = raw.split(/\\r?\\n/gu).map((line) => line.trim()).filter((line) => line.length > 0);
-  let learningsCount = 0;
-  const parsedRows = [];
-  for (const line of lines) {
-    if (line.startsWith("{")) learningsCount += 1;
-    try {
-      const parsed = JSON.parse(line);
-      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) continue;
-      parsedRows.push(parsed);
-    } catch {
-      // ignore malformed knowledge line in digest
-    }
-  }
-  const relevant = parsedRows
-    .filter((row) => {
-      const stage = typeof row.stage === "string" ? row.stage : null;
-      return stage === null || stage === currentStage;
-    })
-    .slice(-6)
-    .reverse()
-    .map((row) => {
-      const confidence = typeof row.confidence === "string" ? row.confidence : "unknown";
-      const stage = typeof row.stage === "string" ? row.stage : "global";
-      const domain = typeof row.domain === "string" ? row.domain : "general";
-      const trigger = typeof row.trigger === "string" ? row.trigger : "trigger";
-      const action = typeof row.action === "string" ? row.action : "action";
-      return "- [" + confidence + " • " + stage + " • " + domain + "] " + trigger + " -> " + action;
-    });
+  const digest = parseKnowledgeDigest(raw, currentStage, 6);
   return {
-    digestLines: relevant,
-    learningsCount
+    digestLines: digest.lines,
+    learningsCount: digest.learningsCount
   };
 }
 
 async function readStageSupportContext(root, currentStage) {
-  const stage = typeof currentStage === "string" ? currentStage : "";
-  const validStages = new Set(["brainstorm", "scope", "design", "spec", "plan", "tdd", "review", "ship"]);
-  if (!validStages.has(stage)) return [];
+  if (!isKnownStageId(currentStage)) return [];
+  const stage = currentStage;
 
   const parts = [];
   const contractPath = path.join(root, RUNTIME_ROOT, "templates", "state-contracts", stage + ".json");
@@ -906,12 +1152,7 @@ async function readStageSupportContext(root, currentStage) {
     );
   }
 
-  const reviewPromptByStage = {
-    brainstorm: "brainstorm-self-review.md",
-    scope: "scope-ceo-review.md",
-    design: "design-eng-review.md"
-  };
-  const promptName = reviewPromptByStage[stage];
+  const promptName = reviewPromptFileName(stage);
   if (typeof promptName === "string") {
     const promptPath = path.join(root, RUNTIME_ROOT, "skills", "review-prompts", promptName);
     const prompt = (await readTextFile(promptPath, "")).trim();
@@ -945,99 +1186,23 @@ async function handleSessionStart(runtime) {
   );
   const knowledge = await buildKnowledgeDigest(runtime.root, state.currentStage, knowledgeRaw);
 
-  // Refresh Ralph Loop status each session-start so /cc and the model
-  // both read a consistent "iter=N, acClosed=[...]" snapshot. Runs only when
-  // we are in tdd — other stages skip the write to keep the file stable.
-  let ralphLoopLine = "";
-  let earlyLoopLine = "";
-  if (state.currentStage === "tdd") {
-    try {
-      const ralphStatus = await computeRalphLoopStatusInline(stateDir, state.activeRunId);
-      await writeJsonFile(path.join(stateDir, "ralph-loop.json"), ralphStatus);
-      const redOpen = ralphStatus.redOpenSlices.length > 0
-        ? ralphStatus.redOpenSlices.join(",")
-        : "none";
-      ralphLoopLine = "Ralph Loop: iter=" + String(ralphStatus.loopIteration) +
-        ", slices=" + String(ralphStatus.sliceCount) +
-        ", acClosed=" + String(ralphStatus.acClosed.length) +
-        ", redOpen=" + redOpen;
-    } catch (err) {
-      // Best-effort — a malformed cycle log should never break
-      // session-start. But we DO leave a breadcrumb in
-      // hook-errors.jsonl so \`npx cclaw-cli sync\` can surface chronic
-      // failures (previously this was a silent swallow).
-      await recordHookError(
-        runtime.root,
-        "session-start:ralph-loop",
-        err instanceof Error ? err.message : String(err)
-      );
-    }
-  }
-  if (
-    EARLY_LOOP_ENABLED &&
-    (state.currentStage === "brainstorm" || state.currentStage === "scope" || state.currentStage === "design")
-  ) {
-    try {
-      const earlyLoopStatus = await computeEarlyLoopStatusInline(
-        stateDir,
-        state.currentStage,
-        state.activeRunId,
-        EARLY_LOOP_MAX_ITERATIONS
-      );
-      await writeJsonFile(path.join(stateDir, "early-loop.json"), earlyLoopStatus);
-      earlyLoopLine = formatEarlyLoopStatusLineInline(earlyLoopStatus);
-    } catch (err) {
-      await recordHookError(
-        runtime.root,
-        "session-start:early-loop",
-        err instanceof Error ? err.message : String(err)
-      );
-    }
-  }
-
-  // Keep compound-readiness.json fresh on every session-start (cheap derived
-  // summary). Surface a one-line nudge only from review and ship stages
-  // where lifting becomes relevant; earlier stages update the file silently.
-  let compoundReadinessLine = "";
-  try {
-    let readiness = null;
-    const internalReadiness = await runCclawInternal(
-      runtime.root,
-      ["compound-readiness", "--json"],
-      { captureStdout: true }
-    );
-    if (internalReadiness.code === 0 && internalReadiness.stdout.trim().length > 0) {
-      try {
-        const parsed = JSON.parse(internalReadiness.stdout);
-        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-          readiness = parsed;
-        }
-      } catch {
-        readiness = null;
-      }
-    }
-    if (!readiness) {
-      const archivedRunsCount = await countArchivedRunsInline(runtime.root);
-      readiness = await computeCompoundReadinessInline(runtime.root, {
-        prereadRaw: knowledgeRaw,
-        ...(typeof archivedRunsCount === "number" ? { archivedRunsCount } : {})
-      });
-      await writeJsonFile(path.join(stateDir, "compound-readiness.json"), readiness);
-    }
-    if (state.currentStage === "review" || state.currentStage === "ship") {
-      compoundReadinessLine = formatCompoundReadinessLineInline(toObject(readiness) || {});
-    }
-  } catch (err) {
-    // Best-effort — a malformed knowledge.jsonl must never break
-    // session-start. But we DO leave a breadcrumb in
-    // hook-errors.jsonl so config/IO problems become visible in
-    // \`npx cclaw-cli sync\` instead of silently degrading readiness output.
-    await recordHookError(
-      runtime.root,
-      "session-start:compound-readiness",
-      err instanceof Error ? err.message : String(err)
-    );
-  }
+  // Fast path: read precomputed status lines from session-digest cache.
+  // If cache is stale, schedule a debounced background refresh so this hook
+  // returns quickly inside harness startup.
+  const flowStateMtimeMs = await readFileMtimeMs(state.filePath);
+  const forceSyncRefresh =
+    normalizeText(process.env.CCLAW_SESSION_START_BG_SYNC).toLowerCase() === "1" ||
+    ["1", "true", "yes"].includes(normalizeText(process.env.VITEST).toLowerCase());
+  let sessionDigest = await readSessionDigestLines(stateDir, state, flowStateMtimeMs);
+  if (forceSyncRefresh && flowStateMtimeMs > 0) {
+    await refreshSessionDigestCache(runtime.root, state, flowStateMtimeMs);
+    sessionDigest = await readSessionDigestLines(stateDir, state, flowStateMtimeMs);
+  } else if (!sessionDigest.fresh) {
+    await scheduleSessionDigestRefresh(runtime, state, flowStateMtimeMs);
+  }
+  const ralphLoopLine = sessionDigest.ralphLoopLine;
+  const earlyLoopLine = sessionDigest.earlyLoopLine;
+  const compoundReadinessLine = sessionDigest.compoundReadinessLine;
 
   const ironLawsObj = toObject(await readJsonFile(ironLawsFile, {})) || {};
   const laws = Array.isArray(ironLawsObj.laws) ? ironLawsObj.laws : [];
@@ -1052,6 +1217,15 @@ async function handleSessionStart(runtime) {
     });
   const staleStages = toObject(state.raw.staleStages) || {};
   const staleStageNames = Object.keys(staleStages);
+  const interactionHints = toObject(state.raw.interactionHints) || {};
+  const stageInteractionHint = toObject(interactionHints[state.currentStage]);
+  const skipQuestionsHintActive = stageInteractionHint?.skipQuestions === true;
+  const skipQuestionsSource = typeof stageInteractionHint?.sourceStage === "string"
+    ? stageInteractionHint.sourceStage
+    : "";
+  const skipQuestionsRecordedAt = typeof stageInteractionHint?.recordedAt === "string"
+    ? stageInteractionHint.recordedAt
+    : "";
   const metaContent = (await readTextFile(metaSkillFile, "")).trim();
   const stageSupportContext = await readStageSupportContext(runtime.root, state.currentStage);
 
@@ -1063,8 +1237,8 @@ async function handleSessionStart(runtime) {
       "/8 completed, run=" +
       state.activeRunId +
       "). Active artifacts: " +
-      RUNTIME_ROOT +
-      "/artifacts/. Learnings: " +
+      activeArtifactsPathLabel(RUNTIME_ROOT) +
+      " Learnings: " +
       String(knowledge.learningsCount) +
       " entries."
   ];
@@ -1084,6 +1258,14 @@ async function handleSessionStart(runtime) {
         " (use npx cclaw-cli internal rewind --ack <stage> after redo)."
     );
   }
+  if (skipQuestionsHintActive) {
+    parts.push(
+      "Adaptive elicitation hint: this stage inherits a prior user stop signal (--skip-questions" +
+        (skipQuestionsSource ? " from " + skipQuestionsSource : "") +
+        (skipQuestionsRecordedAt ? " at " + skipQuestionsRecordedAt : "") +
+        "). Draft with available context unless irreversible/security override checks still require explicit confirmation."
+    );
+  }
   if (knowledge.digestLines.length > 0) {
     parts.push(
       "Knowledge digest (top relevant entries):\\n" +
@@ -1169,7 +1351,7 @@ async function handleStopHandoff(runtime) {
   const shipSubstate = typeof closeoutObj.shipSubstate === "string" ? closeoutObj.shipSubstate : "idle";
   const closeoutContext =
     state.currentStage === "ship" || shipSubstate !== "idle"
-      ? " closeout.shipSubstate=" + shipSubstate + "; closeout chain=retro -> compound -> archive; continue closeout with /cc."
+      ? " closeout.shipSubstate=" + shipSubstate + "; closeout chain=post_ship_review -> archive; continue closeout with /cc."
       : "";
 
   const message =
@@ -1196,10 +1378,6 @@ async function handleStopHandoff(runtime) {
   return 0;
 }
 
-async function handlePreCompact(_runtime) {
-  return 0;
-}
-
 async function handlePromptGuard(runtime) {
   const mode = resolveStrictness();
   const stateDir = path.join(runtime.root, RUNTIME_ROOT, "state");
@@ -1246,17 +1424,6 @@ async function handlePromptGuard(runtime) {
   return 0;
 }
 
-// Inline mirrors of canonical CLI computations (compound-readiness,
-// ralph-loop, early-loop) are factored into
-// src/content/hook-inline-snippets.ts so
-// this 2000+-line file no longer owns their bodies. Each snippet carries
-// an explicit "mirrors X, parity enforced by Y" comment in the snippets
-// module. Parity is enforced by tests/unit/ralph-loop-parity.test.ts.
-${HOOK_INLINE_SHARED_HELPERS}
-${COMPOUND_READINESS_INLINE_SOURCE}
-${RALPH_LOOP_INLINE_SOURCE}
-${EARLY_LOOP_INLINE_SOURCE}
-
 async function hasFailingRedEvidenceForPath(stateDir, runId, rawPath) {
   const cycleRaw = await readTextFile(path.join(stateDir, "tdd-cycle-log.jsonl"), "");
   for (const line of cycleRaw.split(/\\r?\\n/gu)) {
@@ -1468,8 +1635,14 @@ async function handleWorkflowGuard(runtime) {
       // writes that actually belonged to a new, not-yet-red S-2. Now
       // we reuse the canonical Ralph Loop status: if NO slice has an
       // open RED, we block.
-      const ralphStatus = await computeRalphLoopStatusInline(stateDir, currentRun);
-      if (!ralphStatus.redOpen) {
+      const internalRalph = await runCclawInternal(
+        runtime.root,
+        ["tdd-loop-status", "--json", "--no-write"],
+        { captureStdout: true }
+      );
+      const ralphStatus = parseJsonStdoutObject(internalRalph);
+      const redOpen = internalRalph.code === 0 && ralphStatus?.redOpen === true;
+      if (!redOpen) {
         reasons.push("tdd_write_without_open_red");
       }
     }
@@ -1706,15 +1879,38 @@ async function handleVerifyCurrentState(runtime) {
   return 0;
 }
 
+async function handlePreToolPipeline(runtime) {
+  const promptExitCode = await handlePromptGuard(runtime);
+  if (promptExitCode !== 0) {
+    return promptExitCode;
+  }
+  return await handleWorkflowGuard(runtime);
+}
+
+async function handlePromptPipeline(runtime) {
+  const promptExitCode = await handlePromptGuard(runtime);
+  if (promptExitCode !== 0) {
+    return promptExitCode;
+  }
+  const verifyExitCode = await handleVerifyCurrentState(runtime);
+  if (verifyExitCode !== 0) {
+    return verifyExitCode;
+  }
+  runtime.writeJson({ ok: true });
+  return 0;
+}
+
 function normalizeHookName(rawName) {
   const value = normalizeText(rawName).toLowerCase();
   if (value === "session-start") return "session-start";
+  if (value === "session-start-refresh") return "session-start-refresh";
   if (value === "stop-handoff" || value === "stop") return "stop-handoff";
   if (value === "stop-checkpoint") return "stop-handoff";
-  if (value === "pre-compact" || value === "precompact") return "pre-compact";
   if (value === "session-rehydrate") return "session-start";
   if (value === "prompt-guard") return "prompt-guard";
   if (value === "workflow-guard") return "workflow-guard";
+  if (value === "pre-tool-pipeline" || value === "pretool-pipeline") return "pre-tool-pipeline";
+  if (value === "prompt-pipeline" || value === "promptpipeline") return "prompt-pipeline";
   if (value === "context-monitor") return "context-monitor";
   if (value === "verify-current-state") return "verify-current-state";
   return "";
@@ -1726,7 +1922,7 @@ async function main() {
     process.stderr.write(
       "[cclaw] run-hook: usage: node " +
         RUNTIME_ROOT +
-        "/hooks/run-hook.mjs <session-start|stop-handoff|pre-compact|prompt-guard|workflow-guard|context-monitor|verify-current-state>\\n"
+        "/hooks/run-hook.mjs <session-start|session-start-refresh|stop-handoff|prompt-guard|workflow-guard|pre-tool-pipeline|prompt-pipeline|context-monitor|verify-current-state>\\n"
     );
     process.exitCode = 1;
     return;
@@ -1758,12 +1954,12 @@ async function main() {
       process.exitCode = await handleSessionStart(runtime);
       return;
     }
-    if (hookName === "stop-handoff") {
-      process.exitCode = await handleStopHandoff(runtime);
+    if (hookName === "session-start-refresh") {
+      process.exitCode = await handleSessionStartRefresh(runtime);
       return;
     }
-    if (hookName === "pre-compact") {
-      process.exitCode = await handlePreCompact(runtime);
+    if (hookName === "stop-handoff") {
+      process.exitCode = await handleStopHandoff(runtime);
       return;
     }
     if (hookName === "prompt-guard") {
@@ -1774,6 +1970,14 @@ async function main() {
       process.exitCode = await handleWorkflowGuard(runtime);
       return;
     }
+    if (hookName === "pre-tool-pipeline") {
+      process.exitCode = await handlePreToolPipeline(runtime);
+      return;
+    }
+    if (hookName === "prompt-pipeline") {
+      process.exitCode = await handlePromptPipeline(runtime);
+      return;
+    }
     if (hookName === "context-monitor") {
       process.exitCode = await handleContextMonitor(runtime);
       return;