oris-skills 2.0.0

package/scripts/tests/test-oris-loop-list.mjs

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import {
+  defaultLoopDocumentPaths,
+  discoverExistingLoops,
+  resolveLoopDocumentPaths,
+} from "../loop/oris-loop-paths.mjs";
+import { loopDocumentSource } from "../loop/oris-loop-fixtures.mjs";
+import { ORIS_FLOW_LOOPS_ROOT } from "../flow/oris-flow-layout.mjs";
+
+function makeTempRepo() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "oris-loop-list-"));
+}
+
+test("discoverExistingLoops finds approved loop documents", () => {
+  const root = makeTempRepo();
+  try {
+    const loopFile = path.join(root, ORIS_FLOW_LOOPS_ROOT, "feature-a", "loop.md");
+    const contextFile = path.join(root, ORIS_FLOW_LOOPS_ROOT, "feature-a", "context.md");
+    fs.mkdirSync(path.dirname(loopFile), { recursive: true });
+    fs.writeFileSync(loopFile, loopDocumentSource({ program: "feature-a", goal: "Verify feature A." }), "utf8");
+    fs.writeFileSync(contextFile, "# Oris Loop Context\n\nRun: inactive\nState: ready\nCurrent program: feature-a\n\n## Objective\n\nVerify feature A\n", "utf8");
+
+    const loops = discoverExistingLoops(root);
+    assert.equal(loops.length, 1);
+    assert.equal(loops[0].slug, "feature-a");
+    assert.equal(loops[0].program, "feature-a");
+    assert.match(loops[0].objective, /Verify feature A/);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("discoverExistingLoops ignores incomplete folders", () => {
+  const root = makeTempRepo();
+  try {
+    const partial = path.join(root, ORIS_FLOW_LOOPS_ROOT, "partial", "loop.md");
+    fs.mkdirSync(path.dirname(partial), { recursive: true });
+    fs.writeFileSync(partial, "not a loop\n", "utf8");
+    assert.deepEqual(discoverExistingLoops(root), []);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("defaultLoopDocumentPaths includes the prompts directory", () => {
+  const root = makeTempRepo();
+  try {
+    const docs = defaultLoopDocumentPaths(root, "docs/tasks/my-feature");
+    assert.match(docs.loopRelative, /^\.oris-flow\/loops\/my-feature\/loop\.md$/);
+    assert.match(docs.contextRelative, /^\.oris-flow\/loops\/my-feature\/context\.md$/);
+    assert.match(docs.promptsRelative, /^\.oris-flow\/loops\/my-feature\/prompts$/);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("resolveLoopDocumentPaths resolves loop documents", () => {
+  const root = makeTempRepo();
+  try {
+    const taskPath = "docs/tasks/preferred";
+    const resolved = resolveLoopDocumentPaths(root, { taskPath });
+    assert.match(resolved.loopRelative, /^\.oris-flow\/loops\/preferred\/loop\.md$/);
+    assert.match(resolved.contextRelative, /^\.oris-flow\/loops\/preferred\/context\.md$/);
+    assert.match(resolved.promptsRelative, /^\.oris-flow\/loops\/preferred\/prompts$/);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});

package/scripts/tests/test-oris-loop-run.mjs

@@ -0,0 +1,45 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { buildRoleInvocation, doctorDecisionToState, extractJson } from "../loop/oris-loop-run.mjs";
+import { readTemplate, stripTemplateHeading, substitutePlaceholders } from "../loop/oris-loop-templates.mjs";
+
+test("buildRoleInvocation maps roles to codex and claude CLI calls with per-role models", () => {
+  const codex = buildRoleInvocation("codex", { prompt: "do it", model: "model-x", root: "/repo" });
+  assert.equal(codex.command, "codex");
+  assert.deepEqual(codex.args, ["exec", "--sandbox", "workspace-write", "--cd", "/repo", "-m", "model-x", "do it"]);
+
+  const claude = buildRoleInvocation("claude", { prompt: "do it", model: "model-y", root: "/repo" });
+  assert.equal(claude.command, "claude");
+  assert.deepEqual(claude.args, ["-p", "do it", "--permission-mode", "acceptEdits", "--model", "model-y"]);
+
+  const inherit = buildRoleInvocation("claude", { prompt: "do it", model: "inherit", root: "/repo" });
+  assert.ok(!inherit.args.includes("--model"), "inherit must not pass an explicit model");
+});
+
+test("extractJson pulls the last valid JSON object from noisy output", () => {
+  const output = 'thinking...\n{"broken": \nand then {"role":"doctor","decision":"complete"} trailing';
+  assert.deepEqual(extractJson(output), { role: "doctor", decision: "complete" });
+  assert.equal(extractJson("no json here"), null);
+});
+
+test("doctorDecisionToState maps decisions to loop states", () => {
+  assert.equal(doctorDecisionToState("complete"), "complete");
+  assert.equal(doctorDecisionToState("continue"), "continue");
+  assert.equal(doctorDecisionToState("retry"), "continue");
+  assert.equal(doctorDecisionToState("advance"), "advance");
+  assert.equal(doctorDecisionToState("stop"), "blocked");
+  assert.equal(doctorDecisionToState(undefined), "blocked");
+});
+
+test("orchestrator template resolves from the skill templates and substitutes placeholders", () => {
+  const template = readTemplate("orchestrator", import.meta.url);
+  assert.match(template, /ORIS LOOP RUN/);
+  const filled = substitutePlaceholders(template, { iteration: 3, maxIterations: 9, loop: "demo" });
+  assert.match(filled, /pass 3\/9/);
+  assert.match(filled, /\{\{phase\}\}/, "unknown placeholders stay intact");
+});
+
+test("stripTemplateHeading removes the human comment line only", () => {
+  assert.equal(stripTemplateHeading("# Comment line\n\nBody {{x}}\n"), "Body {{x}}");
+  assert.equal(stripTemplateHeading("Body only\n"), "Body only");
+});

package/scripts/tests/test-oris-loop-smoke.mjs

@@ -0,0 +1,130 @@
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+import { initSmokeRepository } from "../loop/oris-loop-fixtures.mjs";
+import { ORIS_FLOW_ADAPTER, ORIS_FLOW_RUNTIME } from "../flow/oris-flow-layout.mjs";
+
+const scriptsRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "loop");
+
+function runScript(scriptName, args = []) {
+  return spawnSync(process.execPath, [path.join(scriptsRoot, scriptName), ...args], {
+    cwd: scriptsRoot,
+    encoding: "utf8",
+    env: {
+      ...process.env,
+      ORIS_SKILLS_SCRIPTS_ROOT: scriptsRoot,
+    },
+  });
+}
+
+test("same-chat verify passes on temporary repository", () => {
+  const result = runScript("oris-loop-verify.mjs", ["--temp"]);
+  assert.equal(result.status, 0, `${result.stdout}\n${result.stderr}`);
+  assert.match(result.stdout, /Same-chat verification passed\./);
+});
+
+test("phase advance does not consume repair-cycle limit", () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "oris-loop-advance-"));
+  try {
+    const task = initSmokeRepository(root, {
+      taskSlug: "advance-smoke",
+      program: "advance-smoke",
+      phases: ["test", "fix", "clean"],
+    });
+    const chat = path.join(scriptsRoot, "oris-loop-chat.mjs");
+    const common = ["--repository-root", root, "--task", task.taskPath, "--max-repair-cycles", "2"];
+    const start = spawnSync(process.execPath, [chat, "--action", "start", ...common], { encoding: "utf8" });
+    assert.equal(start.status, 0, `${start.stdout}\n${start.stderr}`);
+
+    for (let index = 0; index < 2; index += 1) {
+      const advance = spawnSync(process.execPath, [
+        chat,
+        "--action", "set-state",
+        "--state", "advance",
+        "--repository-root", root,
+      ], { encoding: "utf8" });
+      assert.equal(advance.status, 0, `${advance.stdout}\n${advance.stderr}`);
+    }
+
+    const state = JSON.parse(fs.readFileSync(path.join(root, ORIS_FLOW_RUNTIME, "chat-active.json"), "utf8"));
+    assert.equal(state.active, true);
+    assert.equal(state.state, "advance");
+    assert.equal(state.repairCycles, 0);
+    assert.equal(state.phaseName, "clean");
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("same-chat start accepts an existing loop slug", () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "oris-loop-slug-"));
+  try {
+    initSmokeRepository(root, {
+      taskSlug: "feature-121313-therapy-quality-hardening",
+      program: "therapy-quality-hardening",
+    });
+    const chat = path.join(scriptsRoot, "oris-loop-chat.mjs");
+    const start = spawnSync(process.execPath, [
+      chat,
+      "--action", "start",
+      "--loop", "feature-121313-therapy-quality-hardening",
+      "--repository-root", root,
+    ], { encoding: "utf8" });
+    assert.equal(start.status, 0, `${start.stdout}\n${start.stderr}`);
+
+    const state = JSON.parse(fs.readFileSync(path.join(root, ORIS_FLOW_RUNTIME, "chat-active.json"), "utf8"));
+    assert.equal(state.active, true);
+    assert.equal(state.taskPath, "feature-121313-therapy-quality-hardening");
+    assert.equal(state.loopPath, ".oris-flow/loops/feature-121313-therapy-quality-hardening/loop.md");
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("missing required profile leaves same-chat loop unarmed", () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "oris-loop-profile-"));
+  try {
+    initSmokeRepository(root, {
+      taskSlug: "profile-smoke",
+      program: "profile-smoke",
+    });
+    const adapterPath = path.join(root, ORIS_FLOW_ADAPTER);
+    const adapter = JSON.parse(fs.readFileSync(adapterPath, "utf8"));
+    adapter.profile = {
+      required: true,
+      defaultRole: "testing",
+      mappings: [
+        { env: "BASE_URL", from: "values.baseUrl", required: true, secret: false },
+      ],
+    };
+    fs.writeFileSync(adapterPath, `${JSON.stringify(adapter, null, 2)}\n`, "utf8");
+    const settingsPath = path.join(root, "settings.json");
+    fs.writeFileSync(settingsPath, `${JSON.stringify({
+      version: 1,
+      orisFlow: { uiLanguage: "en", artifactLanguage: "en" },
+      defaultProfiles: { testing: "default" },
+      profiles: {
+        default: { environment: "local", values: {}, secrets: {}, flags: {} },
+      },
+    }, null, 2)}\n`, "utf8");
+
+    const chat = path.join(scriptsRoot, "oris-loop-chat.mjs");
+    const start = spawnSync(process.execPath, [
+      chat,
+      "--action", "start",
+      "--loop", "profile-smoke",
+      "--repository-root", root,
+      "--settings-path", settingsPath,
+    ], { encoding: "utf8" });
+    assert.notEqual(start.status, 0);
+    assert.match(start.stderr, /missing required field 'values\.baseUrl'/);
+    assert.match(start.stderr, /Oris chat loop was not armed; the stop hook will not resume this chat/);
+    assert.equal(fs.existsSync(path.join(root, ORIS_FLOW_RUNTIME, "chat-active.json")), false);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});

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

@@ -0,0 +1,371 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+import { ORIS_FLOW_RUNTIME } from "../flow/oris-flow-layout.mjs";
+
+const scriptsRoot = path.dirname(fileURLToPath(import.meta.url));
+const hook = path.join(scriptsRoot, "..", "loop", "oris-loop-stop.mjs");
+
+function runHook(root, input, state, extraArgs = []) {
+  const statePath = path.join(root, "chat-active.json");
+  if (state !== undefined) {
+    fs.writeFileSync(statePath, `${JSON.stringify(state)}\n`, "utf8");
+  }
+  const result = spawnSync(process.execPath, [hook, ...extraArgs], {
+    input: JSON.stringify(input),
+    encoding: "utf8",
+    env: { ...process.env, ORIS_LOOP_CHAT_STATE: statePath },
+  });
+  assert.equal(result.status, 0, result.stderr);
+  return {
+    output: JSON.parse(result.stdout.trim()),
+    statePath,
+    state: fs.existsSync(statePath)
+      ? JSON.parse(fs.readFileSync(statePath, "utf8"))
+      : undefined,
+  };
+}
+
+function activeState(overrides = {}) {
+  return {
+    schemaVersion: 1,
+    active: true,
+    state: "continue",
+    program: "custom",
+    phases: ["test", "fix", "clean"],
+    phaseIndex: 0,
+    phaseName: "test",
+    phaseIteration: 0,
+    taskPath: "sample",
+    loopPath: ".oris-flow/loops/sample/loop.md",
+    contextPath: ".oris-flow/loops/sample/context.md",
+    promptsPath: ".oris-flow/loops/sample/prompts",
+    improveMode: "auto",
+    models: {
+      default: "inherit",
+      executor: "model-e",
+      verifier: "model-v",
+      doctor: "model-d",
+      debriefer: "inherit",
+    },
+    conversationId: null,
+    iteration: 0,
+    maxIterations: 5,
+    repairCycles: 0,
+    maxRepairCycles: 2,
+    maxMinutes: 30,
+    startedAt: new Date().toISOString(),
+    ...overrides,
+  };
+}
+
+test("is a no-op without active state", () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "oris-hook-"));
+  try {
+    const result = runHook(root, {
+      conversation_id: "c1",
+      status: "completed",
+      loop_count: 0,
+    });
+    assert.deepEqual(result.output, {});
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("cursor: claims the conversation and injects the orchestrator prompt", () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "oris-hook-"));
+  try {
+    const result = runHook(
+      root,
+      { conversation_id: "c1", status: "completed", loop_count: 0 },
+      activeState(),
+    );
+    const message = result.output.followup_message;
+    assert.match(message, /ORIS LOOP RUN — pass 1\/5/);
+    assert.match(message, /Loop: custom \| Phase: test \(1\/3\)/);
+    assert.match(message, /Definition: \.oris-flow\/loops\/sample\/loop\.md/);
+    assert.match(message, /Prompts: \.oris-flow\/loops\/sample\/prompts/);
+    assert.match(message, /executor=model-e verifier=model-v doctor=model-d debriefer=inherit/);
+    assert.match(message, /Improve mode: auto/);
+    assert.match(message, /ROLE: you are the orchestrator only/);
+    assert.match(message, /SPAWN executor subagent/);
+    assert.match(message, /SPAWN verifier subagent/);
+    assert.match(message, /SPAWN doctor subagent/);
+    assert.match(message, /oris-skills loop chat --action set-state --state/);
+    assert.match(message, /ORIS_LOOP_STATE: continue \| advance \| complete \| blocked \| ask_user/);
+    assert.doesNotMatch(message, /\{\{iteration\}\}/, "runtime placeholders must be substituted");
+    assert.equal(result.state.conversationId, "c1");
+    assert.equal(result.state.iteration, 1);
+    assert.equal(result.state.state, "running");
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("claude: emits decision block with the same orchestrator prompt", () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "oris-hook-"));
+  try {
+    const result = runHook(
+      root,
+      { session_id: "s1", hook_event_name: "Stop", stop_hook_active: false, cwd: root },
+      activeState(),
+      ["--platform", "claude"],
+    );
+    assert.equal(result.output.decision, "block");
+    assert.match(result.output.reason, /ORIS LOOP RUN — pass 1\/5/);
+    assert.match(result.output.reason, /ROLE: you are the orchestrator only/);
+    assert.equal(result.state.conversationId, "s1");
+    assert.equal(result.state.iteration, 1);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("claude: platform is auto-detected from Stop payload", () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "oris-hook-"));
+  try {
+    const result = runHook(
+      root,
+      { session_id: "s2", hook_event_name: "Stop", stop_hook_active: true, cwd: root },
+      activeState(),
+    );
+    assert.equal(result.output.decision, "block");
+    assert.ok(result.output.reason.length > 0);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("per-loop prompts/orchestrator.md overrides the default template", () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "oris-hook-"));
+  try {
+    const promptsDir = path.join(root, ".oris-flow", "loops", "sample", "prompts");
+    fs.mkdirSync(promptsDir, { recursive: true });
+    fs.writeFileSync(path.join(promptsDir, "orchestrator.md"), "# Custom orchestrator\nCUSTOM PASS {{iteration}} for {{loop}}\n", "utf8");
+    const result = runHook(
+      root,
+      { conversation_id: "c1", status: "completed", loop_count: 0, workspace_roots: [root] },
+      activeState({ repositoryRoot: root.replaceAll("\\", "/") }),
+    );
+    assert.equal(result.output.followup_message, "CUSTOM PASS 1 for custom");
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("does not continue another conversation or failed stop", () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "oris-hook-"));
+  try {
+    const mismatch = runHook(
+      root,
+      { conversation_id: "other", status: "completed", loop_count: 0 },
+      activeState({ conversationId: "bound" }),
+    );
+    assert.deepEqual(mismatch.output, {});
+    const failed = runHook(
+      root,
+      { conversation_id: "bound", status: "error", loop_count: 0 },
+      activeState({ conversationId: "bound" }),
+    );
+    assert.deepEqual(failed.output, {});
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("stops on terminal state and exhausted limits", () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "oris-hook-"));
+  try {
+    for (const state of ["complete", "blocked", "cancelled"]) {
+      const terminal = runHook(
+        root,
+        { conversation_id: "c1", status: "completed", loop_count: 0 },
+        activeState({ state, conversationId: "c1" }),
+      );
+      assert.deepEqual(terminal.output, {});
+    }
+
+    const limited = runHook(
+      root,
+      { conversation_id: "c1", status: "completed", loop_count: 2 },
+      activeState({
+        conversationId: "c1",
+        iteration: 2,
+        maxIterations: 2,
+      }),
+    );
+    assert.deepEqual(limited.output, {});
+    assert.equal(limited.state.active, false);
+    assert.equal(limited.state.state, "blocked");
+
+    const expired = runHook(
+      root,
+      { conversation_id: "c1", status: "completed", loop_count: 0 },
+      activeState({
+        conversationId: "c1",
+        maxMinutes: 1,
+        startedAt: new Date(Date.now() - 120_000).toISOString(),
+      }),
+    );
+    assert.deepEqual(expired.output, {});
+    assert.equal(expired.state.state, "blocked");
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("is a no-op for corrupted runtime state", () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "oris-hook-"));
+  const statePath = path.join(root, "chat-active.json");
+  try {
+    fs.writeFileSync(statePath, "{broken", "utf8");
+    const result = spawnSync(process.execPath, [hook], {
+      input: JSON.stringify({ conversation_id: "c1", status: "completed", loop_count: 0 }),
+      encoding: "utf8",
+      env: { ...process.env, ORIS_LOOP_CHAT_STATE: statePath },
+    });
+    assert.equal(result.status, 0, result.stderr);
+    assert.deepEqual(JSON.parse(result.stdout.trim()), {});
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("does not continue unsupported runtime schema", () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "oris-hook-"));
+  try {
+    const result = runHook(
+      root,
+      { conversation_id: "c1", status: "completed", loop_count: 0 },
+      activeState({ schemaVersion: 99 }),
+    );
+    assert.deepEqual(result.output, {});
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("continues when the previous hook left state running", () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "oris-hook-"));
+  try {
+    const result = runHook(
+      root,
+      { conversation_id: "c1", status: "completed", loop_count: 0 },
+      activeState({ state: "running", conversationId: "c1", iteration: 1, phaseIteration: 1 }),
+    );
+    assert.match(result.output.followup_message, /pass 2\/5/);
+    assert.equal(result.state.iteration, 2);
+    assert.equal(result.state.state, "running");
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("resolves runtime state from workspace_roots", () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "oris-hook-"));
+  const repo = path.join(root, "repo");
+  const runtimeDir = path.join(repo, ORIS_FLOW_RUNTIME);
+  fs.mkdirSync(runtimeDir, { recursive: true });
+  const statePath = path.join(runtimeDir, "chat-active.json");
+  try {
+    fs.writeFileSync(statePath, `${JSON.stringify(activeState())}\n`, "utf8");
+    const result = spawnSync(process.execPath, [hook], {
+      input: JSON.stringify({
+        conversation_id: "c1",
+        status: "completed",
+        loop_count: 0,
+        workspace_roots: [repo],
+      }),
+      encoding: "utf8",
+      cwd: root,
+    });
+    assert.equal(result.status, 0, result.stderr);
+    const output = JSON.parse(result.stdout.trim());
+    assert.match(output.followup_message, /ORIS LOOP RUN/);
+    const state = JSON.parse(fs.readFileSync(statePath, "utf8"));
+    assert.equal(state.conversationId, "c1");
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("advance uses the same conversation with phase instruction", () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "oris-hook-"));
+  try {
+    const result = runHook(
+      root,
+      { conversation_id: "c1", status: "completed", loop_count: 0 },
+      activeState({ state: "advance", conversationId: "c1" }),
+    );
+    assert.match(result.output.followup_message, /advance to the next declared phase/);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("writes debug reason when conversation id is missing", () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "oris-hook-"));
+  try {
+    const result = runHook(
+      root,
+      { status: "completed", loop_count: 0 },
+      activeState(),
+    );
+    assert.deepEqual(result.output, {});
+    const debugPath = path.join(root, "hook-debug.jsonl");
+    assert.ok(fs.existsSync(debugPath));
+    const lines = fs.readFileSync(debugPath, "utf8").trim().split("\n");
+    const last = JSON.parse(lines[lines.length - 1]);
+    assert.equal(last.decision, "noop");
+    assert.equal(last.reason, "missing-conversation-id");
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("writes debug reason when status is aborted", () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "oris-hook-"));
+  try {
+    runHook(
+      root,
+      { conversation_id: "c1", status: "aborted", loop_count: 0 },
+      activeState(),
+    );
+    const debugPath = path.join(root, "hook-debug.jsonl");
+    const last = JSON.parse(fs.readFileSync(debugPath, "utf8").trim().split("\n").at(-1));
+    assert.equal(last.reason, "status-not-completed:aborted");
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("parses hook stdin with UTF-8 BOM from Cursor on Windows", () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "oris-hook-"));
+  const statePath = path.join(root, "chat-active.json");
+  try {
+    fs.writeFileSync(statePath, `${JSON.stringify(activeState())}\n`, "utf8");
+    const payload = JSON.stringify({
+      conversation_id: "c1",
+      status: "completed",
+      loop_count: 0,
+    });
+    const result = spawnSync(process.execPath, [hook], {
+      input: `${payload}`,
+      encoding: "utf8",
+      env: { ...process.env, ORIS_LOOP_CHAT_STATE: statePath },
+    });
+    assert.equal(result.status, 0, result.stderr);
+    const output = JSON.parse(result.stdout.trim());
+    assert.match(output.followup_message, /ORIS LOOP RUN/);
+    const debugPath = path.join(root, "hook-debug.jsonl");
+    const last = JSON.parse(fs.readFileSync(debugPath, "utf8").trim().split("\n").at(-1));
+    assert.equal(last.decision, "followup");
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});