cclaw-cli 2.0.0 → 3.0.0

package/dist/content/hook-events.js

@@ -8,9 +8,6 @@ export { HOOK_SEMANTIC_EVENTS } from "./hook-manifest.js";
  */
 const OPENCODE_SEMANTIC_COVERAGE = {
     session_rehydrate: "plugin event handlers + transform rehydration",
-    pre_tool_prompt_guard: "plugin tool.execute.before -> prompt-guard",
-    pre_tool_workflow_guard: "plugin tool.execute.before -> workflow-guard",
-    post_tool_context_monitor: "plugin tool.execute.after -> context-monitor",
     stop_handoff: "plugin session.idle -> stop-handoff"
 };
 /**

package/dist/content/hook-manifest.d.ts

@@ -21,7 +21,7 @@
  */
 export declare const HOOK_MANIFEST_HARNESSES: readonly ["claude", "cursor", "codex"];
 export type HookManifestHarness = (typeof HOOK_MANIFEST_HARNESSES)[number];
-export declare const HOOK_HANDLERS: readonly ["session-start", "prompt-guard", "workflow-guard", "pre-tool-pipeline", "prompt-pipeline", "context-monitor", "stop-handoff", "verify-current-state"];
+export declare const HOOK_HANDLERS: readonly ["session-start", "stop-handoff"];
 export type HookHandlerId = (typeof HOOK_HANDLERS)[number];
 export interface HookBinding {
     /**
@@ -31,6 +31,8 @@ export interface HookBinding {
     event: string;
     matcher?: string;
     timeout?: number;
+    /** Optional harness UI status line while this hook runs. */
+    statusMessage?: string;
     /**
      * Within a single (harness, event) group, entries are sorted by
      * `priority` ASC, ties broken by manifest-declaration order. Use
@@ -49,7 +51,7 @@ export interface HookHandlerSpec {
     semantic: HookSemanticEvent | null;
     bindings: Partial<Record<HookManifestHarness, HookBinding[]>>;
 }
-export declare const HOOK_SEMANTIC_EVENTS: readonly ["session_rehydrate", "pre_tool_prompt_guard", "pre_tool_workflow_guard", "post_tool_context_monitor", "stop_handoff", "strict_state_verify"];
+export declare const HOOK_SEMANTIC_EVENTS: readonly ["session_rehydrate", "stop_handoff"];
 export type HookSemanticEvent = (typeof HOOK_SEMANTIC_EVENTS)[number];
 export declare const HOOK_MANIFEST: readonly HookHandlerSpec[];
 export interface EventGroup {
@@ -62,6 +64,7 @@ export interface EventGroup {
         handler: HookHandlerId;
         matcher?: string;
         timeout?: number;
+        statusMessage?: string;
     }>;
 }
 /**

package/dist/content/hook-manifest.js

@@ -22,26 +22,16 @@
 export const HOOK_MANIFEST_HARNESSES = ["claude", "cursor", "codex"];
 export const HOOK_HANDLERS = [
     "session-start",
-    "prompt-guard",
-    "workflow-guard",
-    "pre-tool-pipeline",
-    "prompt-pipeline",
-    "context-monitor",
-    "stop-handoff",
-    "verify-current-state"
+    "stop-handoff"
 ];
 export const HOOK_SEMANTIC_EVENTS = [
     "session_rehydrate",
-    "pre_tool_prompt_guard",
-    "pre_tool_workflow_guard",
-    "post_tool_context_monitor",
-    "stop_handoff",
-    "strict_state_verify"
+    "stop_handoff"
 ];
 export const HOOK_MANIFEST = [
     {
         handler: "session-start",
-        description: "Rehydrate flow state, refresh Ralph Loop + compound readiness, emit bootstrap digest.",
+        description: "Rehydrate flow state and emit bootstrap digest.",
         semantic: "session_rehydrate",
         bindings: {
             claude: [{ event: "SessionStart", matcher: "startup|resume|clear|compact" }],
@@ -51,50 +41,13 @@ export const HOOK_MANIFEST = [
                 { event: "sessionClear" },
                 { event: "sessionCompact" }
             ],
-            codex: [{ event: "SessionStart", matcher: "startup|resume" }]
-        }
-    },
-    {
-        handler: "prompt-guard",
-        description: "Stage-aware prompt gate (iron-laws + strictness).",
-        semantic: "pre_tool_prompt_guard",
-        bindings: {
-            claude: [{ event: "PreToolUse", matcher: "*" }]
-        }
-    },
-    {
-        handler: "workflow-guard",
-        description: "TDD and workflow gate on Write/Edit/Bash style tool invocations.",
-        semantic: "pre_tool_workflow_guard",
-        bindings: {
-            claude: [{ event: "PreToolUse", matcher: "Write|Edit|MultiEdit|NotebookEdit|Bash" }]
-        }
-    },
-    {
-        handler: "pre-tool-pipeline",
-        description: "In-process pre-tool pipeline for harnesses that would otherwise spawn prompt/workflow guards separately.",
-        semantic: null,
-        bindings: {
-            cursor: [{ event: "preToolUse", matcher: "*" }],
-            codex: [{ event: "PreToolUse", matcher: "Bash|bash" }]
-        }
-    },
-    {
-        handler: "prompt-pipeline",
-        description: "In-process prompt pipeline for Codex UserPromptSubmit (prompt-guard + verify-current-state).",
-        semantic: "strict_state_verify",
-        bindings: {
-            codex: [{ event: "UserPromptSubmit" }]
-        }
-    },
-    {
-        handler: "context-monitor",
-        description: "Post-tool context usage + stage signal monitor.",
-        semantic: "post_tool_context_monitor",
-        bindings: {
-            claude: [{ event: "PostToolUse", matcher: "*" }],
-            cursor: [{ event: "postToolUse", matcher: "*" }],
-            codex: [{ event: "PostToolUse", matcher: "Bash|bash" }]
+            codex: [
+                {
+                    event: "SessionStart",
+                    matcher: "startup|resume",
+                    statusMessage: "Running cclaw session startup checks"
+                }
+            ]
         }
     },
     {
@@ -104,14 +57,14 @@ export const HOOK_MANIFEST = [
         bindings: {
             claude: [{ event: "Stop", timeout: 10 }],
             cursor: [{ event: "stop", timeout: 10 }],
-            codex: [{ event: "Stop", timeout: 10 }]
+            codex: [
+                {
+                    event: "Stop",
+                    timeout: 10,
+                    statusMessage: "Preparing cclaw handoff checklist"
+                }
+            ]
         }
-    },
-    {
-        handler: "verify-current-state",
-        description: "Supplementary strict-mode guard callable from in-process pipelines to assert live state matches flow.",
-        semantic: null,
-        bindings: {}
     }
 ];
 /** Sanity: every harness in HOOK_MANIFEST_HARNESSES must be a HarnessId. */
@@ -141,6 +94,7 @@ export function groupBindingsByEvent(harness) {
                 handler: spec.handler,
                 ...(binding.matcher !== undefined ? { matcher: binding.matcher } : {}),
                 ...(binding.timeout !== undefined ? { timeout: binding.timeout } : {}),
+                ...(binding.statusMessage !== undefined ? { statusMessage: binding.statusMessage } : {}),
                 priority: binding.priority ?? 0,
                 seq: seq++
             });

package/dist/content/node-hooks.d.ts

@@ -1,30 +1,4 @@
 export interface NodeHookRuntimeOptions {
-    /**
-     * Single enforcement knob derived from `config.strictness`. Generated hooks
-     * embed this value as the default for every guard (prompt, workflow, TDD,
-     * iron-laws-coupled blocks). `CCLAW_STRICTNESS` env var overrides at run
-     * time; per-law strictness still flows through `iron-laws.json`.
-     */
-    strictness?: "advisory" | "strict";
-    tddTestPathPatterns?: string[];
-    tddProductionPathPatterns?: string[];
-    /**
-     * Baked-in default recurrence threshold for compound-readiness computed
-     * by the session-start hook. Derived from
-     * `config.compound.recurrenceThreshold` at install time; re-run
-     * `cclaw sync` after changing the config value so hook and CLI agree.
-     */
-    compoundRecurrenceThreshold?: number;
-    /**
-     * Enables early-stage producer/critic loop diagnostics in session-start.
-     * Defaults to true.
-     */
-    earlyLoopEnabled?: boolean;
-    /**
-     * Baked-in max iterations for brainstorm/scope/design early-loop status.
-     * Derived from `config.earlyLoop.maxIterations`.
-     */
-    earlyLoopMaxIterations?: number;
 }
 /**
  * Node-only hook runtime (single entrypoint).

package/dist/content/node-hooks.js

@@ -5,11 +5,6 @@ import { DEFAULT_COMPOUND_RECURRENCE_THRESHOLD, DEFAULT_EARLY_LOOP_MAX_ITERATION
 import { RUNTIME_ROOT } from "../constants.js";
 import { SMALL_PROJECT_ARCHIVE_RUNS_THRESHOLD, SMALL_PROJECT_RECURRENCE_THRESHOLD } from "../knowledge-store.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];
-    return patterns.map((value) => value.trim()).filter((value) => value.length > 0);
-}
 function resolveCliRuntimeForGeneratedHook() {
     const here = fileURLToPath(import.meta.url);
     const candidates = [
@@ -39,24 +34,19 @@ function resolveCliRuntimeForGeneratedHook() {
  * bash/python/jq runtime dependencies.
  */
 export function nodeHookRuntimeScript(options = {}) {
-    const strictness = options.strictness === "strict" ? "strict" : "advisory";
-    const tddTestPathPatterns = normalizePatterns(options.tddTestPathPatterns, [
+    void options;
+    const strictness = "advisory";
+    const tddTestPathPatterns = [
         "**/*.test.*",
         "**/tests/**",
         "**/__tests__/**"
-    ]);
-    const tddProductionPathPatterns = normalizePatterns(options.tddProductionPathPatterns, []);
-    const compoundRecurrenceThreshold = typeof options.compoundRecurrenceThreshold === "number" &&
-        Number.isInteger(options.compoundRecurrenceThreshold) &&
-        options.compoundRecurrenceThreshold >= 1
-        ? options.compoundRecurrenceThreshold
-        : DEFAULT_COMPOUND_RECURRENCE_THRESHOLD;
-    const earlyLoopEnabled = options.earlyLoopEnabled !== false;
-    const earlyLoopMaxIterations = typeof options.earlyLoopMaxIterations === "number" &&
-        Number.isInteger(options.earlyLoopMaxIterations) &&
-        options.earlyLoopMaxIterations >= 1
-        ? options.earlyLoopMaxIterations
-        : DEFAULT_EARLY_LOOP_MAX_ITERATIONS;
+    ];
+    const tddProductionPathPatterns = [];
+    const compoundRecurrenceThreshold = DEFAULT_COMPOUND_RECURRENCE_THRESHOLD;
+    const earlyLoopEnabled = true;
+    const earlyLoopMaxIterations = DEFAULT_EARLY_LOOP_MAX_ITERATIONS;
+    const defaultHookProfile = "standard";
+    const defaultDisabledHooks = [];
     const cliRuntime = resolveCliRuntimeForGeneratedHook();
     return `#!/usr/bin/env node
 import fs from "node:fs/promises";
@@ -83,6 +73,14 @@ 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 DEFAULT_HOOK_PROFILE = ${JSON.stringify(defaultHookProfile)};
+const DEFAULT_DISABLED_HOOKS = ${JSON.stringify(defaultDisabledHooks)};
+const HOOK_PROFILE_VALUES = new Set(["minimal", "standard", "strict"]);
+const MINIMAL_PROFILE_ALLOWED_HOOKS = new Set([
+  "session-start",
+  "session-start-refresh",
+  "stop-handoff"
+]);
 const SESSION_DIGEST_SCHEMA_VERSION = 1;
 const SESSION_DIGEST_CACHE_FILE = "session-digest.json";
 const SESSION_DIGEST_REFRESH_MARKER_FILE = "session-digest.refresh.json";
@@ -91,7 +89,119 @@ const SESSION_DIGEST_REFRESH_STALE_MS = 30000;
 ${SHARED_FLOW_AND_KNOWLEDGE_SNIPPETS}
 ${SHARED_STAGE_SUPPORT_SNIPPETS}
 
+let ACTIVE_HOOK_PROFILE = DEFAULT_HOOK_PROFILE;
+
+function normalizeHookToken(value) {
+  return String(value == null ? "" : value).trim().toLowerCase();
+}
+
+function parseHookProfile(rawValue, fallback = "standard") {
+  const normalized = normalizeHookToken(rawValue);
+  if (HOOK_PROFILE_VALUES.has(normalized)) return normalized;
+  return fallback;
+}
+
+function parseDisabledHooksCsv(rawValue) {
+  const raw = typeof rawValue === "string" ? rawValue : "";
+  if (raw.trim().length === 0) return [];
+  const out = [];
+  for (const token of raw.split(",")) {
+    const normalized = normalizeHookToken(token);
+    if (normalized.length === 0) continue;
+    if (!out.includes(normalized)) out.push(normalized);
+  }
+  return out;
+}
+
+function parseInlineYamlList(rawValue) {
+  const raw = typeof rawValue === "string" ? rawValue.trim() : "";
+  if (!raw.startsWith("[") || !raw.endsWith("]")) return [];
+  const inside = raw.slice(1, -1).trim();
+  if (inside.length === 0) return [];
+  return inside.split(",").map((token) => normalizeHookToken(token.replace(/^['"]|['"]$/g, ""))).filter((token) => token.length > 0);
+}
+
+function parseConfigHookProfile(rawYaml) {
+  if (typeof rawYaml !== "string" || rawYaml.trim().length === 0) {
+    return "";
+  }
+  const match = rawYaml.match(/^\\s*hookProfile\\s*:\\s*([A-Za-z0-9_-]+)\\s*$/m);
+  if (!match || typeof match[1] !== "string") return "";
+  return parseHookProfile(match[1], "");
+}
+
+function parseConfigDisabledHooks(rawYaml) {
+  if (typeof rawYaml !== "string" || rawYaml.trim().length === 0) {
+    return [];
+  }
+  const lines = rawYaml.split(/\\r?\\n/u);
+  const out = [];
+  for (let i = 0; i < lines.length; i += 1) {
+    const line = lines[i];
+    const inlineMatch = line.match(/^\\s*disabledHooks\\s*:\\s*(\\[[^\\]]*\\])\\s*$/u);
+    if (inlineMatch) {
+      for (const value of parseInlineYamlList(inlineMatch[1])) {
+        if (!out.includes(value)) out.push(value);
+      }
+      continue;
+    }
+    const blockMatch = line.match(/^(\\s*)disabledHooks\\s*:\\s*$/u);
+    if (!blockMatch) continue;
+    const baseIndent = blockMatch[1] ? blockMatch[1].length : 0;
+    for (let j = i + 1; j < lines.length; j += 1) {
+      const nextLine = lines[j];
+      const indent = (nextLine.match(/^(\\s*)/u)?.[1].length ?? 0);
+      const trimmed = nextLine.trim();
+      if (trimmed.length === 0) continue;
+      if (indent <= baseIndent) break;
+      const itemMatch = nextLine.match(/^\\s*-\\s*(.+?)\\s*$/u);
+      if (!itemMatch) continue;
+      const normalized = normalizeHookToken(itemMatch[1].replace(/^['"]|['"]$/g, ""));
+      if (normalized.length === 0) continue;
+      if (!out.includes(normalized)) out.push(normalized);
+    }
+  }
+  return out;
+}
+
+async function readConfigHookPolicy(root) {
+  const configPath = path.join(root, RUNTIME_ROOT, "config.yaml");
+  const raw = await readTextFile(configPath, "");
+  const profile = parseConfigHookProfile(raw);
+  const disabledHooks = parseConfigDisabledHooks(raw);
+  return { profile, disabledHooks };
+}
+
+async function resolveHookPolicy(root) {
+  const fromConfig = await readConfigHookPolicy(root);
+  const configProfile = parseHookProfile(fromConfig.profile, DEFAULT_HOOK_PROFILE);
+  const configDisabledHooks = Array.isArray(fromConfig.disabledHooks) && fromConfig.disabledHooks.length > 0
+    ? fromConfig.disabledHooks
+    : DEFAULT_DISABLED_HOOKS;
+
+  const envProfileRaw = process.env.CCLAW_HOOK_PROFILE;
+  const envProfile = parseHookProfile(envProfileRaw, "");
+  const profile = envProfile.length > 0 ? envProfile : configProfile;
+
+  const envDisabledRaw = process.env.CCLAW_DISABLED_HOOKS;
+  const envDisabledHooks = parseDisabledHooksCsv(envDisabledRaw);
+  const disabledHooks = envDisabledHooks.length > 0 ? envDisabledHooks : configDisabledHooks;
+  const disabled = new Set(disabledHooks.map((value) => normalizeHookToken(value)));
+  return { profile, disabled };
+}
+
+function hookDisabledByProfile(profile, hookName) {
+  if (profile !== "minimal") return false;
+  return !MINIMAL_PROFILE_ALLOWED_HOOKS.has(hookName);
+}
+
+function isHookDisabled(policy, hookName) {
+  if (policy.disabled.has(hookName)) return true;
+  return hookDisabledByProfile(policy.profile, hookName);
+}
+
 function resolveStrictness() {
+  if (ACTIVE_HOOK_PROFILE === "strict") return "strict";
   return process.env.CCLAW_STRICTNESS === "strict" ? "strict" : DEFAULT_STRICTNESS;
 }
 
@@ -1169,8 +1279,6 @@ async function readStageSupportContext(root, currentStage) {
 
 async function handleSessionStart(runtime) {
   const state = await readFlowState(runtime.root);
-  const stateDir = path.join(runtime.root, RUNTIME_ROOT, "state");
-  const ironLawsFile = path.join(stateDir, "iron-laws.json");
   const metaSkillFile = path.join(runtime.root, RUNTIME_ROOT, "skills", "using-cclaw", "SKILL.md");
 
 
@@ -1186,35 +1294,11 @@ async function handleSessionStart(runtime) {
   );
   const knowledge = await buildKnowledgeDigest(runtime.root, state.currentStage, knowledgeRaw);
 
-  // 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 : [];
-  const ironLawLines = laws
-    .filter((row) => row && typeof row === "object")
-    .slice(0, 6)
-    .map((row) => {
-      const strict = row.strict === true ? "strict" : "advisory";
-      const id = typeof row.id === "string" && row.id.length > 0 ? row.id : "law";
-      const rule = typeof row.rule === "string" ? row.rule : "";
-      return "- [" + strict + "] " + id + " -> " + rule;
-    });
+  // Wave 21 honest-core: session-start no longer runs background helper
+  // pipelines or digest caches. It rehydrates flow + knowledge only.
+  const ralphLoopLine = "";
+  const earlyLoopLine = "";
+  const compoundReadinessLine = "";
   const staleStages = toObject(state.raw.staleStages) || {};
   const staleStageNames = Object.keys(staleStages);
   const interactionHints = toObject(state.raw.interactionHints) || {};
@@ -1275,9 +1359,6 @@ async function handleSessionStart(runtime) {
   if (stageSupportContext.length > 0) {
     parts.push(...stageSupportContext);
   }
-  if (ironLawLines.length > 0) {
-    parts.push("Iron laws (enforced policy highlights):\\n" + ironLawLines.join("\\n"));
-  }
   if (metaContent.length > 0) {
     parts.push(metaContent);
   }
@@ -1316,22 +1397,80 @@ async function isGitDirty(root) {
   });
 }
 
-function stopLawIsStrict(ironLawsObj) {
-  if ((ironLawsObj.mode || "advisory") === "strict") return true;
-  const laws = Array.isArray(ironLawsObj.laws) ? ironLawsObj.laws : [];
-  return laws.some(
-    (row) =>
-      row &&
-      typeof row === "object" &&
-      (row.id === "stop-clean-or-handoff" || row.id === "stop-clean-or-checkpointed") &&
-      row.strict === true
-  );
+const STOP_BLOCK_LIMIT_PER_TRANSCRIPT = 2;
+
+function asBoolean(value) {
+  if (value === true || value === false) return value;
+  if (typeof value === "number") return Number.isFinite(value) && value !== 0;
+  if (typeof value !== "string") return false;
+  const normalized = value.trim().toLowerCase();
+  if (normalized.length === 0) return false;
+  return ["1", "true", "yes", "on"].includes(normalized);
+}
+
+function stringTokenHit(value, tokens) {
+  const normalized = normalizeText(value).toLowerCase();
+  if (normalized.length === 0) return false;
+  return tokens.some((token) => normalized.includes(token));
+}
+
+function sanitizeStopSessionKey(raw) {
+  const normalized = normalizeText(raw)
+    .toLowerCase()
+    .replace(/[^a-z0-9._-]+/gu, "-")
+    .replace(/^-+|-+$/gu, "");
+  return normalized.length > 0 ? normalized.slice(0, 96) : "global";
+}
+
+function extractStopSignals(input, fallbackSessionKey) {
+  const event = toObject(input.event) || {};
+  const session = toObject(input.session) || {};
+  const contextLimit =
+    asBoolean(input.context_limit) ||
+    asBoolean(input.contextLimit) ||
+    asBoolean(event.context_limit) ||
+    asBoolean(event.contextLimit) ||
+    stringTokenHit(input.reason, ["context_limit", "context limit"]) ||
+    stringTokenHit(event.reason, ["context_limit", "context limit"]) ||
+    stringTokenHit(input.stop_reason, ["context_limit", "context limit"]) ||
+    stringTokenHit(event.stop_reason, ["context_limit", "context limit"]);
+  const userAbort =
+    asBoolean(input.user_abort) ||
+    asBoolean(input.userAbort) ||
+    asBoolean(input.user_cancelled) ||
+    asBoolean(input.userCancelled) ||
+    asBoolean(event.user_abort) ||
+    asBoolean(event.userAbort) ||
+    stringTokenHit(input.reason, ["user_abort", "user abort", "cancelled by user", "stop button", "ctrl+c"]) ||
+    stringTokenHit(event.reason, ["user_abort", "user abort", "cancelled by user", "stop button", "ctrl+c"]) ||
+    stringTokenHit(input.stop_reason, ["user_abort", "user abort", "cancelled by user", "stop button", "ctrl+c"]) ||
+    stringTokenHit(event.stop_reason, ["user_abort", "user abort", "cancelled by user", "stop button", "ctrl+c"]);
+  const stopHookActive =
+    asBoolean(input.stop_hook_active) ||
+    asBoolean(input.stopHookActive) ||
+    asBoolean(event.stop_hook_active) ||
+    asBoolean(event.stopHookActive);
+
+  const sessionKeyCandidate =
+    (typeof input.transcript_id === "string" && input.transcript_id) ||
+    (typeof input.transcriptId === "string" && input.transcriptId) ||
+    (typeof input.session_id === "string" && input.session_id) ||
+    (typeof input.sessionId === "string" && input.sessionId) ||
+    (typeof session.id === "string" && session.id) ||
+    fallbackSessionKey;
+  const sessionKey = sanitizeStopSessionKey(sessionKeyCandidate);
+
+  return {
+    contextLimit,
+    userAbort,
+    stopHookActive,
+    sessionKey
+  };
 }
 
 async function handleStopHandoff(runtime) {
   const state = await readFlowState(runtime.root);
   const stateDir = path.join(runtime.root, RUNTIME_ROOT, "state");
-  const ironLawsFile = path.join(stateDir, "iron-laws.json");
   const input = toObject(runtime.inputData) || {};
   const loopCount =
     typeof input.loop_count === "number" && Number.isFinite(input.loop_count)
@@ -1339,12 +1478,40 @@ async function handleStopHandoff(runtime) {
       : 0;
 
   const dirtyState = await isGitDirty(runtime.root);
-  const strictStop = stopLawIsStrict(toObject(await readJsonFile(ironLawsFile, {})) || {});
-  if (dirtyState === "dirty" && strictStop) {
+  const stopSignals = extractStopSignals(input, "run-" + state.activeRunId);
+  const safetyBypassActive = stopSignals.stopHookActive || stopSignals.userAbort || stopSignals.contextLimit;
+  if (dirtyState === "dirty" && !safetyBypassActive) {
+    const stopBlocksPath = path.join(stateDir, "stop-blocks-" + stopSignals.sessionKey + ".json");
+    const prior = toObject(await readJsonFile(stopBlocksPath, {})) || {};
+    const priorCount =
+      typeof prior.blockCount === "number" && Number.isFinite(prior.blockCount)
+        ? Math.max(0, Math.trunc(prior.blockCount))
+        : 0;
+    if (priorCount < STOP_BLOCK_LIMIT_PER_TRANSCRIPT) {
+      const nextCount = priorCount + 1;
+      await writeJsonFile(stopBlocksPath, {
+        schemaVersion: 1,
+        sessionKey: stopSignals.sessionKey,
+        blockCount: nextCount,
+        updatedAt: new Date().toISOString()
+      });
+      process.stderr.write(
+        '[cclaw] Stop blocked by iron law "stop-clean-or-handoff": working tree is dirty. Commit/revert changes or record blockers in the current artifact before ending the session.\\n'
+      );
+      return 1;
+    }
     process.stderr.write(
-      '[cclaw] Stop blocked by iron law "stop-clean-or-handoff": working tree is dirty. Commit/revert changes or record blockers in the current artifact before ending the session.\\n'
+      '[cclaw] Stop advisory: dirty working tree detected, but block limit reached for this transcript (max 2). Continuing with handoff reminder only.\\n'
+    );
+  } else if (dirtyState === "dirty" && safetyBypassActive) {
+    const reason = stopSignals.stopHookActive
+      ? "stop_hook_active"
+      : stopSignals.userAbort
+        ? "user_abort"
+        : "context_limit";
+    process.stderr.write(
+      "[cclaw] Stop advisory: bypassing strict stop block due to safety rule (" + reason + ").\\n"
     );
-    return 1;
   }
 
   const closeoutObj = toObject(state.raw.closeout) || {};
@@ -1903,16 +2070,9 @@ async function handlePromptPipeline(runtime) {
 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 === "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 "";
 }
 
@@ -1922,7 +2082,7 @@ async function main() {
     process.stderr.write(
       "[cclaw] run-hook: usage: node " +
         RUNTIME_ROOT +
-        "/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"
+        "/hooks/run-hook.mjs <session-start|stop-handoff>\\n"
     );
     process.exitCode = 1;
     return;
@@ -1954,38 +2114,10 @@ async function main() {
       process.exitCode = await handleSessionStart(runtime);
       return;
     }
-    if (hookName === "session-start-refresh") {
-      process.exitCode = await handleSessionStartRefresh(runtime);
-      return;
-    }
     if (hookName === "stop-handoff") {
       process.exitCode = await handleStopHandoff(runtime);
       return;
     }
-    if (hookName === "prompt-guard") {
-      process.exitCode = await handlePromptGuard(runtime);
-      return;
-    }
-    if (hookName === "workflow-guard") {
-      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;
-    }
-    if (hookName === "verify-current-state") {
-      process.exitCode = await handleVerifyCurrentState(runtime);
-      return;
-    }
     process.stderr.write("[cclaw] run-hook: unsupported hook " + hookName + "\\n");
     process.exitCode = 1;
   } catch (error) {

package/dist/content/observe.js

@@ -31,7 +31,8 @@ function buildClaudeLikeEvents(harness) {
             const hookEntry = {
                 type: "command",
                 command: hookDispatcherCommand(entry.handler),
-                ...(entry.timeout !== undefined ? { timeout: entry.timeout } : {})
+                ...(entry.timeout !== undefined ? { timeout: entry.timeout } : {}),
+                ...(entry.statusMessage !== undefined ? { statusMessage: entry.statusMessage } : {})
             };
             bucket.hooks.push(hookEntry);
         }