oris-skills 2.0.0

package/scripts/loop/oris-loop-stop.mjs

@@ -0,0 +1,319 @@
+#!/usr/bin/env node
+
+/**
+ * Shared stop hook for same-chat Oris loops.
+ *
+ * Platforms:
+ * - cursor: reads Cursor stop-hook JSON on stdin, answers { followup_message }.
+ * - claude: reads Claude Code Stop-hook JSON on stdin, answers
+ *   { decision: "block", reason } to continue the same session.
+ *
+ * The platform comes from --platform, else it is detected from input keys.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { ORIS_FLOW_RUNTIME } from "../flow/oris-flow-layout.mjs";
+import { readTemplate, stripTemplateHeading, substitutePlaceholders } from "./oris-loop-templates.mjs";
+
+const terminalStates = new Set(["complete", "blocked", "cancelled"]);
+const resumableStates = new Set(["continue", "advance", "running"]);
+
+function emit(value) {
+  process.stdout.write(`${JSON.stringify(value)}\n`);
+}
+
+/** Windows may pipe hook stdin with a UTF-8 BOM; JSON.parse rejects it. */
+function stripUtf8Bom(text) {
+  return text.charCodeAt(0) === 0xfeff ? text.slice(1) : text;
+}
+
+function parseJsonText(text) {
+  const trimmed = stripUtf8Bom(String(text ?? "").trim());
+  return trimmed ? JSON.parse(trimmed) : {};
+}
+
+function readInput() {
+  return new Promise((resolve, reject) => {
+    let raw = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+      raw += chunk;
+    });
+    process.stdin.on("end", () => {
+      try {
+        resolve(parseJsonText(raw));
+      } catch (error) {
+        reject(error);
+      }
+    });
+    process.stdin.on("error", reject);
+  });
+}
+
+function writeStateAtomic(statePath, state) {
+  const directory = path.dirname(statePath);
+  fs.mkdirSync(directory, { recursive: true });
+  const temporary = `${statePath}.${process.pid}.tmp`;
+  fs.writeFileSync(temporary, `${JSON.stringify(state, null, 2)}\n`, {
+    encoding: "utf8",
+    mode: 0o600,
+  });
+  fs.renameSync(temporary, statePath);
+}
+
+function stopState(statePath, state, reason) {
+  writeStateAtomic(statePath, {
+    ...state,
+    active: false,
+    state: "blocked",
+    stopReason: reason,
+    updatedAt: new Date().toISOString(),
+  });
+}
+
+function normalizeState(state) {
+  if (!state || typeof state !== "object") return null;
+  const normalized = { ...state };
+  const version = Number(normalized.schemaVersion ?? 0);
+  if (version !== 1) return null;
+  return normalized;
+}
+
+function detectPlatform(argv, raw) {
+  const explicit = argv.find((arg) => arg.startsWith("--platform="))?.slice("--platform=".length)
+    ?? (argv.includes("--platform") ? argv[argv.indexOf("--platform") + 1] : "");
+  if (explicit === "cursor" || explicit === "claude") return explicit;
+  if (String(raw.hook_event_name ?? "") === "Stop" || raw.session_id !== undefined || raw.stop_hook_active !== undefined) {
+    return "claude";
+  }
+  return "cursor";
+}
+
+/** Normalize Cursor and Claude hook payloads to one shape. */
+function readHookInput(raw, platform) {
+  if (platform === "claude") {
+    return {
+      status: "completed",
+      conversationId: raw.session_id ? String(raw.session_id) : "",
+      loopCount: 0,
+      workspaceRoots: raw.cwd ? [String(raw.cwd)] : [],
+      hookEventName: String(raw.hook_event_name ?? ""),
+      rawKeys: Object.keys(raw).sort(),
+    };
+  }
+  const status = String(raw.status ?? raw.agent_status ?? "").toLowerCase();
+  const conversationId = raw.conversation_id ?? raw.conversationId ?? null;
+  const loopCount = Number(raw.loop_count ?? raw.loopCount ?? 0);
+  const workspaceRoots = Array.isArray(raw.workspace_roots)
+    ? raw.workspace_roots
+    : Array.isArray(raw.workspaceRoots)
+      ? raw.workspaceRoots
+      : [];
+  return {
+    status,
+    conversationId: conversationId ? String(conversationId) : "",
+    loopCount: Number.isFinite(loopCount) ? loopCount : 0,
+    workspaceRoots,
+    hookEventName: String(raw.hook_event_name ?? raw.hookEventName ?? ""),
+    rawKeys: Object.keys(raw).sort(),
+  };
+}
+
+function resolveStatePath(input, workspaceRoots) {
+  if (process.env.ORIS_LOOP_CHAT_STATE) {
+    return path.resolve(process.env.ORIS_LOOP_CHAT_STATE);
+  }
+  for (const root of workspaceRoots) {
+    if (typeof root !== "string" || root.trim().length === 0) continue;
+    const candidate = path.join(root, ORIS_FLOW_RUNTIME, "chat-active.json");
+    if (fs.existsSync(candidate)) return path.resolve(candidate);
+  }
+  return path.resolve(process.cwd(), ORIS_FLOW_RUNTIME, "chat-active.json");
+}
+
+function resolveDebugPath(statePath) {
+  return path.join(path.dirname(statePath), "hook-debug.jsonl");
+}
+
+function appendDebug(debugPath, entry) {
+  try {
+    fs.mkdirSync(path.dirname(debugPath), { recursive: true });
+    fs.appendFileSync(debugPath, `${JSON.stringify(entry)}\n`, "utf8");
+  } catch {
+    // Debug logging must never break the hook.
+  }
+}
+
+function packageOutput(platform, followup) {
+  if (!followup) return {};
+  if (platform === "claude") return { decision: "block", reason: followup };
+  return { followup_message: followup };
+}
+
+function finish(debugPath, baseEntry, result) {
+  appendDebug(debugPath, {
+    ...baseEntry,
+    at: new Date().toISOString(),
+    decision: result.decision,
+    reason: result.reason,
+    emittedFollowup: Boolean(result.followup),
+  });
+  emit(packageOutput(baseEntry.platform, result.followup));
+}
+
+/** Resolve the orchestrator prompt: per-loop file > packaged template > embedded. */
+function buildFollowup(state, repositoryRoot, values) {
+  let template = null;
+  if (state.promptsPath && repositoryRoot) {
+    const perLoop = path.join(repositoryRoot, state.promptsPath, "orchestrator.md");
+    if (fs.existsSync(perLoop)) {
+      template = stripTemplateHeading(fs.readFileSync(perLoop, "utf8"));
+    }
+  }
+  if (!template) template = readTemplate("orchestrator", import.meta.url);
+  return substitutePlaceholders(template, values);
+}
+
+try {
+  const rawInput = await readInput();
+  const platform = detectPlatform(process.argv.slice(2), rawInput);
+  const input = readHookInput(rawInput, platform);
+  const statePath = resolveStatePath(rawInput, input.workspaceRoots);
+  const debugPath = resolveDebugPath(statePath);
+  const baseEntry = {
+    pid: process.pid,
+    cwd: process.cwd(),
+    platform,
+    statePath,
+    inputStatus: input.status,
+    conversationId: input.conversationId || null,
+    loopCount: input.loopCount,
+    hookEventName: input.hookEventName,
+    rawKeys: input.rawKeys,
+  };
+
+  if (input.status !== "completed") {
+    finish(debugPath, baseEntry, { decision: "noop", reason: `status-not-completed:${input.status || "missing"}` });
+    process.exit(0);
+  }
+
+  if (!input.conversationId) {
+    finish(debugPath, baseEntry, { decision: "noop", reason: "missing-conversation-id" });
+    process.exit(0);
+  }
+
+  if (!fs.existsSync(statePath)) {
+    finish(debugPath, baseEntry, { decision: "noop", reason: "chat-active-missing" });
+    process.exit(0);
+  }
+
+  let state;
+  try {
+    state = normalizeState(parseJsonText(fs.readFileSync(statePath, "utf8")));
+  } catch {
+    finish(debugPath, baseEntry, { decision: "noop", reason: "chat-active-invalid-json" });
+    process.exit(0);
+  }
+
+  baseEntry.runtimeActive = state?.active ?? null;
+  baseEntry.runtimeState = state?.state ?? null;
+  baseEntry.runtimeIteration = state?.iteration ?? null;
+
+  if (!state) {
+    finish(debugPath, baseEntry, { decision: "noop", reason: "chat-active-unsupported-schema" });
+    process.exit(0);
+  }
+
+  if (state.active !== true || terminalStates.has(state.state) || !resumableStates.has(state.state)) {
+    finish(debugPath, baseEntry, { decision: "noop", reason: `runtime-not-resumable:${state.state}` });
+    process.exit(0);
+  }
+
+  let boundConversation = false;
+  if (!state.conversationId) {
+    state.conversationId = input.conversationId;
+    boundConversation = true;
+  }
+  if (state.conversationId !== input.conversationId) {
+    finish(debugPath, baseEntry, { decision: "noop", reason: `conversation-mismatch:bound=${state.conversationId}` });
+    process.exit(0);
+  }
+  if (boundConversation) {
+    writeStateAtomic(statePath, { ...state, updatedAt: new Date().toISOString() });
+    baseEntry.boundConversation = true;
+  }
+
+  const iteration = Number(state.iteration ?? 0);
+  const maxIterations = Number(state.maxIterations ?? 25);
+  const maxMinutes = Number(state.maxMinutes ?? 240);
+  const startedAt = Date.parse(state.startedAt ?? "");
+  const elapsedMinutes = Number.isFinite(startedAt)
+    ? (Date.now() - startedAt) / 60_000
+    : Number.POSITIVE_INFINITY;
+
+  if (!Number.isInteger(iteration) || !Number.isInteger(maxIterations) || maxIterations < 1) {
+    finish(debugPath, baseEntry, { decision: "noop", reason: "invalid-runtime-counters" });
+    process.exit(0);
+  }
+
+  if (iteration >= maxIterations || input.loopCount >= maxIterations) {
+    stopState(statePath, state, "iteration limit exhausted");
+    finish(debugPath, baseEntry, { decision: "stop", reason: "iteration-limit-exhausted" });
+    process.exit(0);
+  }
+
+  if (elapsedMinutes >= maxMinutes) {
+    stopState(statePath, state, "wall-clock limit exhausted");
+    finish(debugPath, baseEntry, { decision: "stop", reason: "wall-clock-limit-exhausted" });
+    process.exit(0);
+  }
+
+  const nextIteration = iteration + 1;
+  const phases = Array.isArray(state.phases) && state.phases.length > 0 ? state.phases : ["execute"];
+  const phaseIndex = Number.isInteger(Number(state.phaseIndex)) ? Number(state.phaseIndex) : 0;
+  const phaseName = state.phaseName ?? phases[Math.max(0, Math.min(phaseIndex, phases.length - 1))] ?? "execute";
+  const models = state.models && typeof state.models === "object" ? state.models : {};
+  const defaultModel = String(models.default ?? "inherit");
+  const repositoryRoot = state.repositoryRoot && fs.existsSync(state.repositoryRoot)
+    ? state.repositoryRoot
+    : input.workspaceRoots.find((root) => typeof root === "string" && fs.existsSync(root)) ?? process.cwd();
+
+  const followup = buildFollowup(state, repositoryRoot, {
+    iteration: nextIteration,
+    maxIterations,
+    loop: state.program ?? "",
+    phase: phaseName,
+    phaseIndex: phaseIndex + 1,
+    phaseCount: phases.length,
+    instruction: state.state === "advance" ? "advance to the next declared phase" : "continue the current phase",
+    loopPath: state.loopPath ?? "",
+    contextPath: state.contextPath ?? "",
+    promptsDir: state.promptsPath ?? "",
+    executorModel: String(models.executor ?? defaultModel),
+    verifierModel: String(models.verifier ?? defaultModel),
+    doctorModel: String(models.doctor ?? defaultModel),
+    debrieferModel: String(models.debriefer ?? defaultModel),
+    improveMode: String(state.improveMode ?? "propose"),
+    taskPath: state.taskPath ?? "",
+  });
+
+  writeStateAtomic(statePath, {
+    ...state,
+    state: "running",
+    iteration: nextIteration,
+    phaseIteration: Number(state.phaseIteration ?? 0) + 1,
+    updatedAt: new Date().toISOString(),
+  });
+
+  finish(debugPath, baseEntry, { decision: "followup", reason: "scheduled-next-iteration", followup });
+} catch (error) {
+  const fallbackPath = path.resolve(process.cwd(), ORIS_FLOW_RUNTIME, "hook-debug.jsonl");
+  appendDebug(fallbackPath, {
+    at: new Date().toISOString(),
+    decision: "error",
+    reason: String(error?.message ?? error),
+  });
+  emit({});
+}

package/scripts/loop/oris-loop-templates.mjs

@@ -0,0 +1,77 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+/**
+ * Prompt templates live in skills/oris-loop/templates/*.md so users and
+ * agents can read and copy them. Scripts fall back to an embedded
+ * orchestrator prompt so the stop hook can never fail on a missing file.
+ */
+export const TEMPLATE_NAMES = ["orchestrator", "executor", "verifier", "doctor", "debriefer"];
+
+export const EMBEDDED_ORCHESTRATOR = `ORIS LOOP RUN — pass {{iteration}}/{{maxIterations}}
+Loop: {{loop}} | Phase: {{phase}} ({{phaseIndex}}/{{phaseCount}}) | Do: {{instruction}}
+Definition: {{loopPath}} | Context: {{contextPath}} | Prompts: {{promptsDir}}
+Models: executor={{executorModel}} verifier={{verifierModel}} doctor={{doctorModel}} debriefer={{debrieferModel}} ("inherit" = current session model)
+Improve mode: {{improveMode}}
+
+ROLE: you are the orchestrator only. NEVER do executor, verifier, or doctor work in this chat.
+
+EACH PASS:
+1. READ {{contextPath}}; pick exactly ONE bounded next step.
+2. SPAWN executor subagent with {{promptsDir}}/executor.md (fill runtime values), model {{executorModel}}.
+3. SPAWN verifier subagent with {{promptsDir}}/verifier.md + the executor claim, model {{verifierModel}}.
+4. SPAWN doctor subagent with {{promptsDir}}/doctor.md + both compact summaries, model {{doctorModel}}.
+5. WRITE a compact receipt to the loop receipts/ folder; update context.md with durable facts only.
+6. RUN: \`oris-skills loop chat --action set-state --state <continue|advance|complete|blocked>\`.
+7. END the turn with exactly: \`ORIS_LOOP_STATE: continue | advance | complete | blocked | ask_user\`.
+
+IMPROVE ({{improveMode}}):
+- auto → after the doctor verdict, the debriefer may rewrite files under {{promptsDir}} (archive the old version to history/ first). It must NEVER change scope, limits, permissions, or verification in loop.md — those go to proposals/.
+- propose → the debriefer writes proposals/ only; nothing changes until the user approves.
+
+ALWAYS:
+- Keep chat output compact; raw logs go to .oris-flow/runtime/evidence/.
+- Tell the user in one line what this pass will do before spawning workers.
+
+NEVER:
+- Continue when the doctor says blocked, scope is violated, or the same failure repeats.
+- Commit, push, deploy, edit .oris-flow/runtime/**, or touch paths outside the approved scope.
+- Ask "run next pass?" after continue/advance — end the turn; the hook schedules the next pass.
+
+IF prompts files are missing or subagents cannot be spawned: \`set-state --state blocked\`, say why, end the turn.`;
+
+export function resolveTemplatesDir(fromImportMetaUrl) {
+  const scriptsLoop = path.dirname(fileURLToPath(fromImportMetaUrl));
+  const candidates = [
+    path.resolve(scriptsLoop, "..", "..", "skills", "oris-loop", "templates"),
+    path.resolve(scriptsLoop, "..", "skills", "oris-loop", "templates"),
+  ];
+  for (const candidate of candidates) {
+    if (fs.existsSync(path.join(candidate, "orchestrator.md"))) return candidate;
+  }
+  return null;
+}
+
+/** Strip the leading "# ..." comment line templates carry for humans. */
+export function stripTemplateHeading(text) {
+  const lines = String(text ?? "").split(/\r?\n/);
+  while (lines.length > 0 && (lines[0].startsWith("# ") || !lines[0].trim())) lines.shift();
+  return lines.join("\n").trim();
+}
+
+export function readTemplate(name, fromImportMetaUrl) {
+  const dir = resolveTemplatesDir(fromImportMetaUrl);
+  if (dir) {
+    const full = path.join(dir, `${name}.md`);
+    if (fs.existsSync(full)) return stripTemplateHeading(fs.readFileSync(full, "utf8"));
+  }
+  return name === "orchestrator" ? EMBEDDED_ORCHESTRATOR : null;
+}
+
+/** Replace {{key}} for provided keys only; craft placeholders stay intact. */
+export function substitutePlaceholders(text, values) {
+  return String(text ?? "").replace(/\{\{([A-Za-z0-9_]+)\}\}/g, (token, key) => (
+    Object.prototype.hasOwnProperty.call(values, key) ? String(values[key]) : token
+  ));
+}

package/scripts/loop/oris-loop-verify.mjs

@@ -0,0 +1,206 @@
+#!/usr/bin/env node
+
+/**
+ * `oris-skills loop verify [--temp]` — self-check of the same-chat loop
+ * runtime. With --temp it builds a throwaway smoke repository, arms it, and
+ * simulates both the Cursor and the Claude Code stop hooks.
+ */
+
+import childProcess from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import { scriptPath } from "./oris-loop-bundle.mjs";
+import { initSmokeRepository } from "./oris-loop-fixtures.mjs";
+import { ORIS_FLOW_ADAPTER, ORIS_FLOW_RUNTIME } from "../flow/oris-flow-layout.mjs";
+
+function readJson(filePath) {
+  if (!fs.existsSync(filePath)) return null;
+  return JSON.parse(fs.readFileSync(filePath, "utf8"));
+}
+
+function tailJsonl(filePath, count = 5) {
+  if (!fs.existsSync(filePath)) return [];
+  return fs.readFileSync(filePath, "utf8")
+    .trim()
+    .split("\n")
+    .filter(Boolean)
+    .slice(-count)
+    .map((line) => JSON.parse(line));
+}
+
+function runHook(hookPath, repoRoot, statePath, input, { bom = false, platformArg = "" } = {}) {
+  const payload = JSON.stringify(input);
+  const stdin = bom ? `\uFEFF${payload}` : payload;
+  const args = [hookPath];
+  if (platformArg) args.push("--platform", platformArg);
+  const result = childProcess.spawnSync(process.execPath, args, {
+    input: stdin,
+    encoding: "utf8",
+    cwd: repoRoot,
+    env: { ...process.env, ORIS_LOOP_CHAT_STATE: statePath },
+  });
+  return {
+    status: result.status,
+    stderr: result.stderr?.trim() ?? "",
+    stdout: result.stdout?.trim() ?? "",
+    output: result.stdout?.trim() ? JSON.parse(result.stdout.trim()) : {},
+    state: readJson(statePath),
+  };
+}
+
+function check(name, ok, detail) {
+  const mark = ok ? "OK" : "FAIL";
+  console.log(`[${mark}] ${name}${detail ? `: ${detail}` : ""}`);
+  return ok;
+}
+
+function parseArgs(argv) {
+  const options = {
+    repositoryRoot: "",
+    temp: false,
+    simulateOnly: false,
+    statusOnly: false,
+    withBom: false,
+    conversation: "",
+  };
+  for (let i = 0; i < argv.length; i += 1) {
+    const raw = argv[i];
+    if (raw === "--temp") options.temp = true;
+    else if (raw === "--simulate") options.simulateOnly = true;
+    else if (raw === "--status-only") options.statusOnly = true;
+    else if (raw === "--bom") options.withBom = true;
+    else if (raw.startsWith("--conversation=")) options.conversation = raw.slice("--conversation=".length);
+    else if (raw.startsWith("--repository-root=")) options.repositoryRoot = raw.slice("--repository-root=".length);
+    else if (raw === "--repository-root" && argv[i + 1]) {
+      options.repositoryRoot = argv[i + 1];
+      i += 1;
+    } else if (!raw.startsWith("-") && !options.repositoryRoot) {
+      options.repositoryRoot = raw;
+    }
+  }
+  return options;
+}
+
+const options = parseArgs(process.argv.slice(2));
+let repoRoot = options.repositoryRoot ? path.resolve(options.repositoryRoot) : process.cwd();
+let tempRoot = null;
+
+if (options.temp) {
+  tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "oris-loop-verify-"));
+  const task = initSmokeRepository(tempRoot);
+  repoRoot = tempRoot;
+  if (!options.statusOnly && !options.simulateOnly) {
+    const chatScript = scriptPath(import.meta.url, "oris-loop-chat.mjs");
+    const start = childProcess.spawnSync(process.execPath, [
+      chatScript,
+      "--action", "start",
+      "--task", task.taskPath,
+      "--repository-root", repoRoot,
+      "--max-repair-cycles", "0",
+    ], { cwd: repoRoot, encoding: "utf8" });
+    if (start.status !== 0) {
+      console.error(start.stderr || start.stdout);
+      process.exit(1);
+    }
+  }
+}
+
+const runtimeDir = path.join(repoRoot, ORIS_FLOW_RUNTIME);
+const statePath = path.join(runtimeDir, "chat-active.json");
+const debugPath = path.join(runtimeDir, "hook-debug.jsonl");
+const stopHookPath = scriptPath(import.meta.url, "oris-loop-stop.mjs");
+const chatScript = scriptPath(import.meta.url, "oris-loop-chat.mjs");
+const cursorWrapper = path.join(repoRoot, ".cursor", "hooks", "oris-loop-stop.mjs");
+const claudeWrapper = path.join(repoRoot, ".claude", "hooks", "oris-loop-stop.mjs");
+
+console.log("Oris loop verify (same-chat)");
+console.log(`Repository: ${repoRoot}`);
+if (tempRoot) console.log("(temporary smoke repository)");
+console.log("");
+
+const checks = [];
+checks.push(check("adapter.json", fs.existsSync(path.join(repoRoot, ORIS_FLOW_ADAPTER))));
+checks.push(check("shared stop hook", fs.existsSync(stopHookPath)));
+checks.push(check("chat helper", fs.existsSync(chatScript)));
+const hasCursor = fs.existsSync(path.join(repoRoot, ".cursor", "hooks.json")) && fs.existsSync(cursorWrapper);
+const hasClaude = fs.existsSync(path.join(repoRoot, ".claude", "settings.json")) && fs.existsSync(claudeWrapper);
+checks.push(check("stop hook armed (cursor or claude)", hasCursor || hasClaude, `cursor=${hasCursor} claude=${hasClaude}`));
+
+const chat = readJson(statePath);
+console.log("");
+console.log("chat-active.json:");
+if (!chat) {
+  console.log("(missing - run oris-skills loop chat --action start first)");
+} else {
+  console.log(JSON.stringify(chat, null, 2));
+}
+
+console.log("");
+console.log(`hook-debug.jsonl (last ${Math.min(5, tailJsonl(debugPath).length)} events):`);
+const events = tailJsonl(debugPath, 5);
+if (events.length === 0) {
+  console.log("(none yet)");
+} else {
+  for (const event of events) {
+    console.log(`- ${event.at} | ${event.decision} | ${event.reason}`);
+  }
+}
+
+if (!options.simulateOnly && !options.statusOnly) {
+  console.log("");
+  console.log("Simulating Cursor stop hook...");
+  if (!chat) {
+    check("simulate", false, "chat-active.json missing");
+    if (tempRoot) fs.rmSync(tempRoot, { recursive: true, force: true });
+    process.exit(1);
+  }
+
+  const conversationId = options.conversation || chat.conversationId || "debug-conversation";
+
+  const cursorInput = {
+    conversation_id: conversationId,
+    status: "completed",
+    loop_count: Number(chat.iteration ?? 0),
+    hook_event_name: "stop",
+    workspace_roots: [repoRoot],
+  };
+
+  console.log(`Conversation: ${conversationId}${options.withBom ? " (UTF-8 BOM stdin)" : ""}`);
+  const result = runHook(stopHookPath, repoRoot, statePath, cursorInput, { bom: options.withBom });
+  checks.push(check("cursor hook exit code 0", result.status === 0, result.stderr || undefined));
+  checks.push(check("cursor followup_message emitted", Boolean(result.output.followup_message)));
+
+  if (result.output.followup_message) {
+    const preview = result.output.followup_message.split("\n").slice(0, 3).join(" | ");
+    console.log(`Follow-up preview: ${preview}`);
+  }
+
+  if (result.state) {
+    checks.push(check("conversation bound", result.state.conversationId === conversationId));
+    checks.push(check("iteration incremented", Number(result.state.iteration) > Number(chat.iteration ?? 0)));
+  }
+
+  console.log("");
+  console.log("Simulating Claude Code stop hook...");
+  const beforeClaude = readJson(statePath);
+  const claudeInput = {
+    session_id: conversationId,
+    hook_event_name: "Stop",
+    stop_hook_active: false,
+    cwd: repoRoot,
+  };
+  const claudeResult = runHook(stopHookPath, repoRoot, statePath, claudeInput, { platformArg: "claude" });
+  checks.push(check("claude hook exit code 0", claudeResult.status === 0, claudeResult.stderr || undefined));
+  checks.push(check("claude decision block emitted", claudeResult.output.decision === "block" && Boolean(claudeResult.output.reason)));
+  if (claudeResult.state && beforeClaude) {
+    checks.push(check("claude iteration incremented", Number(claudeResult.state.iteration) > Number(beforeClaude.iteration ?? 0)));
+  }
+}
+
+console.log("");
+const passed = checks.every(Boolean);
+console.log(passed ? "Same-chat verification passed." : "Same-chat verification failed.");
+if (tempRoot) fs.rmSync(tempRoot, { recursive: true, force: true });
+process.exit(passed ? 0 : 1);