oris-skills 2.2.3 → 3.0.2

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

@@ -1,358 +0,0 @@
-#!/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;
-  // Cursor payloads carry conversation_id (and may ALSO carry session_id) — check it first.
-  if (raw.conversation_id !== undefined || raw.conversationId !== undefined) return "cursor";
-  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, notice) {
-  if (followup) {
-    if (platform === "claude") return { decision: "block", reason: followup };
-    return { followup_message: followup };
-  }
-  // A stopped/broken loop must never wedge the chat, but the user should hear
-  // about it. Claude Code shows systemMessage; Cursor has no non-resuming channel.
-  if (notice && platform === "claude") return { systemMessage: notice };
-  return {};
-}
-
-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, result.notice));
-}
-
-/** 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",
-      notice: `Oris loop halted: ${statePath} is not valid JSON. Repair it with: npx oris-skills loop chat --action repair`,
-    });
-    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",
-      notice: `Oris loop halted: ${statePath} uses an unsupported schema. Re-arm it with: npx oris-skills loop chat --action repair`,
-    });
-    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",
-      notice: `Oris loop "${state.program ?? ""}" stopped: iteration limit exhausted (${maxIterations}). Goal NOT confirmed met. Resume with: npx oris-skills loop chat --action repair`,
-    });
-    process.exit(0);
-  }
-
-  if (elapsedMinutes >= maxMinutes) {
-    stopState(statePath, state, "wall-clock limit exhausted");
-    finish(debugPath, baseEntry, {
-      decision: "stop",
-      reason: "wall-clock-limit-exhausted",
-      notice: `Oris loop "${state.program ?? ""}" stopped: wall-clock limit exhausted (${maxMinutes} min). Goal NOT confirmed met. Resume with: npx oris-skills loop chat --action repair`,
-    });
-    process.exit(0);
-  }
-
-  const maxNoProgress = Number(state.maxNoProgress ?? 0);
-  if (maxNoProgress >= 1 && Number(state.noProgressStreak ?? 0) >= maxNoProgress) {
-    stopState(statePath, state, "no-progress limit exhausted");
-    finish(debugPath, baseEntry, {
-      decision: "stop",
-      reason: "no-progress-limit-exhausted",
-      notice: `Oris loop "${state.program ?? ""}" stopped: ${maxNoProgress} passes in a row without progress. Goal NOT confirmed met.`,
-    });
-    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 roles = Array.isArray(state.roles) && state.roles.length > 0
-    ? state.roles
-    : ["executor", "verifier"];
-
-  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 ?? "",
-    roles: roles.join(", "),
-    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

@@ -1,80 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
-/**
- * Prompt templates live in skills/oris-flow/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}}
-Active roles: {{roles}}
-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. DECIDE the state:
-   - doctor in active roles → SPAWN doctor subagent with {{promptsDir}}/doctor.md + both compact summaries, model {{doctorModel}}; use its decision.
-   - no doctor → map the verifier verdict: pass + goalMet → complete; pass → continue; fail → continue; blocked or inconclusive → ask-user.
-5. WRITE a compact receipt to the loop receipts/ folder; update context.md with durable facts only.
-6. RUN: \`npx oris-skills loop chat --action set-state --state <continue|advance|complete|blocked|ask-user> --progress <yes|no>\` (progress yes = the verifier confirmed forward movement).
-7. END the turn with exactly: \`ORIS_LOOP_STATE: <continue|advance|complete|blocked|ask-user>\`.
-
-IMPROVE ({{improveMode}}, only when debriefer is in active roles):
-- auto → after the 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 verdict is 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 prompt 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-flow", "templates"),
-    path.resolve(scriptsLoop, "..", "skills", "oris-flow", "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

@@ -1,205 +0,0 @@
-#!/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,
-    ], { 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 npx 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);