oris-skills 2.0.0 → 2.1.0

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

@@ -85,6 +85,8 @@ 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";
   }
@@ -146,10 +148,15 @@ function appendDebug(debugPath, entry) {
   }
 }
 
-function packageOutput(platform, followup) {
-  if (!followup) return {};
-  if (platform === "claude") return { decision: "block", reason: followup };
-  return { followup_message: followup };
+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) {
@@ -160,7 +167,7 @@ function finish(debugPath, baseEntry, result) {
     reason: result.reason,
     emittedFollowup: Boolean(result.followup),
   });
-  emit(packageOutput(baseEntry.platform, result.followup));
+  emit(packageOutput(baseEntry.platform, result.followup, result.notice));
 }
 
 /** Resolve the orchestrator prompt: per-loop file > packaged template > embedded. */
@@ -213,7 +220,11 @@ try {
   try {
     state = normalizeState(parseJsonText(fs.readFileSync(statePath, "utf8")));
   } catch {
-    finish(debugPath, baseEntry, { decision: "noop", reason: "chat-active-invalid-json" });
+    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);
   }
 
@@ -222,7 +233,11 @@ try {
   baseEntry.runtimeIteration = state?.iteration ?? null;
 
   if (!state) {
-    finish(debugPath, baseEntry, { decision: "noop", reason: "chat-active-unsupported-schema" });
+    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);
   }
 
@@ -260,13 +275,32 @@ try {
 
   if (iteration >= maxIterations || input.loopCount >= maxIterations) {
     stopState(statePath, state, "iteration limit exhausted");
-    finish(debugPath, baseEntry, { decision: "stop", reason: "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" });
+    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);
   }
 
@@ -280,6 +314,10 @@ try {
     ? 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,
@@ -291,6 +329,7 @@ try {
     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),

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

@@ -12,6 +12,7 @@ export const TEMPLATE_NAMES = ["orchestrator", "executor", "verifier", "doctor",
 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}}
 
@@ -21,13 +22,15 @@ 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}}.
+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: \`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\`.
+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}}):
-- 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/.
+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:
@@ -35,11 +38,11 @@ ALWAYS:
 - 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.
+- 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 prompts files are missing or subagents cannot be spawned: \`set-state --state blocked\`, say why, end the turn.`;
+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));

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

@@ -98,7 +98,6 @@ if (options.temp) {
       "--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);
@@ -132,7 +131,7 @@ const chat = readJson(statePath);
 console.log("");
 console.log("chat-active.json:");
 if (!chat) {
-  console.log("(missing - run oris-skills loop chat --action start first)");
+  console.log("(missing - run npx oris-skills loop chat --action start first)");
 } else {
   console.log(JSON.stringify(chat, null, 2));
 }

package/scripts/oris-skills.mjs

@@ -92,7 +92,8 @@ if (command === "doctor") {
 }
 
 if (command === "validate") {
-  runNode("tests/run-all-tests.mjs", ["--node-only", ...commandArgs]);
+  // Kept as an alias of the full test suite for older docs and muscle memory.
+  runNode("tests/run-all-tests.mjs", []);
 }
 
 if (command === "loop") {

package/scripts/tests/run-all-tests.mjs

@@ -33,6 +33,4 @@ function run(command, args, options = {}) {
   if (result.status !== 0) process.exit(result.status ?? 1);
 }
 
-const nodeOnly = process.argv.includes("--node-only");
 run(process.execPath, ["--test", ...nodeTestFiles]);
-

package/scripts/tests/test-oris-flow-scan.mjs

@@ -47,3 +47,69 @@ test("scanner supports documentation-only repositories", () => {
   }
 });
 
+test("scanner detects project type and derives inferred stack commands", () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "oris-flow-scan-"));
+  try {
+    write(path.join(root, "App.sln"), "");
+    write(path.join(root, "src", "App", "App.csproj"), "<Project />\n");
+    write(path.join(root, "src", "App", "Controllers", "HomeController.cs"), "class HomeController {}\n");
+
+    const scan = scanRepository(root);
+    assert.equal(scan.projectType.id, "api");
+    assert.ok(scan.stacks.some((stack) => stack.id === "dotnet"));
+    const dotnetTest = scan.commands.find((command) => command.command.startsWith("dotnet test"));
+    assert.ok(dotnetTest, "expected an inferred dotnet test command");
+    assert.equal(dotnetTest.confidence, "inferred");
+    assert.equal(scan.manifest.setup.tasksRoot, ".oris-flow/tasks");
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("refresh preserves confirmed sections, commands, and tasksRoot", () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "oris-flow-scan-"));
+  try {
+    write(path.join(root, "README.md"), "# Demo\n");
+    write(path.join(root, "package.json"), `${JSON.stringify({ scripts: { test: "node --test" } })}\n`);
+
+    const first = scanRepository(root);
+    first.manifest.setup.tasksRoot = "docs/tasks";
+    first.manifest.setup.confirmedDecisions = ["tests live under scripts/tests"];
+    first.manifest.sections.docs.confidence = "confirmed";
+    first.manifest.commands[0].confidence = "confirmed";
+    writeScanResult(first);
+    const enriched = "# Docs\n\nUser-confirmed enrichment that must survive refresh.\n";
+    write(path.join(root, ".oris-flow", "maps", "docs.md"), enriched);
+
+    const second = scanRepository(root);
+    assert.equal(second.manifest.setup.tasksRoot, "docs/tasks");
+    assert.deepEqual(second.manifest.setup.confirmedDecisions, ["tests live under scripts/tests"]);
+    assert.equal(second.manifest.sections.docs.confidence, "confirmed");
+    assert.equal(second.manifest.sections.docs.stale, false);
+    assert.equal(second.manifest.commands[0].confidence, "confirmed");
+    assert.ok(second.preservedSections.has("docs"));
+
+    writeScanResult(second);
+    assert.equal(fs.readFileSync(path.join(root, ".oris-flow", "maps", "docs.md"), "utf8"), enriched);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("confirmed section without fresh evidence is marked stale, not deleted", () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "oris-flow-scan-"));
+  try {
+    write(path.join(root, "README.md"), "# Demo\n");
+    const first = scanRepository(root);
+    first.manifest.sections.docs.confidence = "confirmed";
+    writeScanResult(first);
+
+    fs.rmSync(path.join(root, "README.md"));
+    const second = scanRepository(root);
+    assert.equal(second.manifest.sections.docs.confidence, "confirmed");
+    assert.equal(second.manifest.sections.docs.stale, true);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+

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

@@ -4,6 +4,7 @@ import os from "node:os";
 import path from "node:path";
 import test from "node:test";
 import {
+  activeRoles,
   assessPromptFiles,
   improveMode,
   normalizeModels,
@@ -16,6 +17,7 @@ kind: oris-loop
 name: bug-fix-loop
 approved: true
 phases: [observe, execute, verify, debrief]
+roles: [executor, verifier, debriefer]
 limits:
   maxIterations: 10
   maxNoProgress: 2
@@ -79,6 +81,35 @@ test("rejects unknown improve modes", () => {
   );
 });
 
+test("roles default to executor + verifier and must always include both", () => {
+  assert.deepEqual(activeRoles({}), ["executor", "verifier"]);
+  assert.deepEqual(activeRoles({ roles: ["executor", "verifier", "doctor"] }), ["executor", "verifier", "doctor"]);
+  assert.throws(
+    () => validateLoopDocumentText(
+      validLoop.replace("roles: [executor, verifier, debriefer]", "roles: [executor, debriefer]"),
+      "no-verifier.loop.md",
+    ),
+    /roles must include verifier/,
+  );
+  assert.throws(
+    () => validateLoopDocumentText(
+      validLoop.replace("roles: [executor, verifier, debriefer]", "roles: [executor, verifier, narrator]"),
+      "bad-role.loop.md",
+    ),
+    /roles must be an array/,
+  );
+});
+
+test("improve.mode auto requires the debriefer role", () => {
+  assert.throws(
+    () => validateLoopDocumentText(
+      validLoop.replace("roles: [executor, verifier, debriefer]", "roles: [executor, verifier]"),
+      "auto-without-debriefer.loop.md",
+    ),
+    /improve\.mode auto requires the debriefer role/,
+  );
+});
+
 test("normalizeModels resolves inherit, adapter aliases, and role fallbacks", () => {
   const models = normalizeModels(
     { default: "inherit", verifier: "smart", doctor: "explicit-model-id" },
@@ -96,16 +127,21 @@ test("improveMode defaults to propose", () => {
   assert.equal(improveMode({ improve: { mode: "auto" } }), "auto");
 });
 
-test("assessPromptFiles reports missing role prompt files", () => {
+test("assessPromptFiles reports missing prompts for the active roles only", () => {
   const dir = fs.mkdtempSync(path.join(os.tmpdir(), "oris-prompts-"));
   try {
     const empty = assessPromptFiles(dir);
-    assert.deepEqual(empty.missing, ["prompts/executor.md", "prompts/verifier.md", "prompts/doctor.md"]);
+    assert.deepEqual(empty.missing, ["prompts/executor.md", "prompts/verifier.md"]);
     fs.mkdirSync(path.join(dir, "prompts"), { recursive: true });
-    for (const file of ["executor.md", "verifier.md", "doctor.md"]) {
+    for (const file of ["executor.md", "verifier.md"]) {
       fs.writeFileSync(path.join(dir, "prompts", file), "prompt content\n", "utf8");
     }
     assert.deepEqual(assessPromptFiles(dir).missing, []);
+    assert.deepEqual(
+      assessPromptFiles(dir, ["executor", "verifier", "doctor"]).missing,
+      ["prompts/doctor.md"],
+      "opting in a role requires its prompt file",
+    );
   } finally {
     fs.rmSync(dir, { recursive: true, force: true });
   }

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

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import { buildRoleInvocation, doctorDecisionToState, extractJson } from "../loop/oris-loop-run.mjs";
+import { buildRoleInvocation, doctorDecisionToState, extractJson, verifierVerdictToState } 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", () => {
@@ -16,21 +16,47 @@ test("buildRoleInvocation maps roles to codex and claude CLI calls with per-role
   assert.ok(!inherit.args.includes("--model"), "inherit must not pass an explicit model");
 });
 
+test("readonly roles never get write access at the harness level", () => {
+  const claude = buildRoleInvocation("claude", { prompt: "check", model: "inherit", root: "/repo", readonly: true });
+  assert.ok(claude.args.includes("plan"), "claude readonly roles run in plan permission mode");
+  assert.ok(!claude.args.includes("acceptEdits"));
+
+  const codex = buildRoleInvocation("codex", { prompt: "check", model: "inherit", root: "/repo", readonly: true });
+  assert.ok(codex.args.includes("read-only"), "codex readonly roles run in the read-only sandbox");
+  assert.ok(!codex.args.includes("workspace-write"));
+});
+
 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", () => {
+test("extractJson prefers the fenced json block over stray braces", () => {
+  const output = 'prose with {braces} everywhere\n```json\n{"role":"verifier","state":"pass","goalMet":true}\n```\nmore {noise}';
+  assert.deepEqual(extractJson(output), { role: "verifier", state: "pass", goalMet: true });
+});
+
+test("doctorDecisionToState maps the canonical decision enum 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("ask-user"), "ask-user", "ask-user must pause, never fail");
+  assert.equal(doctorDecisionToState("propose-patch"), "ask-user", "a proposed patch awaits approval");
   assert.equal(doctorDecisionToState("stop"), "blocked");
   assert.equal(doctorDecisionToState(undefined), "blocked");
 });
 
+test("verifierVerdictToState drives two-role loops without a doctor", () => {
+  assert.equal(verifierVerdictToState({ state: "pass", goalMet: true }), "complete");
+  assert.equal(verifierVerdictToState({ state: "pass", goalMet: false }), "continue");
+  assert.equal(verifierVerdictToState({ state: "fail" }), "continue");
+  assert.equal(verifierVerdictToState({ state: "blocked" }), "ask-user");
+  assert.equal(verifierVerdictToState({ state: "inconclusive" }), "ask-user");
+  assert.equal(verifierVerdictToState(null), "ask-user", "unparseable verifier output pauses the loop");
+});
+
 test("orchestrator template resolves from the skill templates and substitutes placeholders", () => {
   const template = readTemplate("orchestrator", import.meta.url);
   assert.match(template, /ORIS LOOP RUN/);

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

@@ -27,7 +27,7 @@ test("same-chat verify passes on temporary repository", () => {
   assert.match(result.stdout, /Same-chat verification passed\./);
 });
 
-test("phase advance does not consume repair-cycle limit", () => {
+test("phase advance moves through declared phases", () => {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), "oris-loop-advance-"));
   try {
     const task = initSmokeRepository(root, {
@@ -36,7 +36,7 @@ test("phase advance does not consume repair-cycle limit", () => {
       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 common = ["--repository-root", root, "--task", task.taskPath];
     const start = spawnSync(process.execPath, [chat, "--action", "start", ...common], { encoding: "utf8" });
     assert.equal(start.status, 0, `${start.stdout}\n${start.stderr}`);
 
@@ -45,6 +45,7 @@ test("phase advance does not consume repair-cycle limit", () => {
         chat,
         "--action", "set-state",
         "--state", "advance",
+        "--progress", "yes",
         "--repository-root", root,
       ], { encoding: "utf8" });
       assert.equal(advance.status, 0, `${advance.stdout}\n${advance.stderr}`);
@@ -53,13 +54,45 @@ test("phase advance does not consume repair-cycle limit", () => {
     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.noProgressStreak, 0);
+    assert.deepEqual(state.roles, ["executor", "verifier"]);
     assert.equal(state.phaseName, "clean");
   } finally {
     fs.rmSync(root, { recursive: true, force: true });
   }
 });
 
+test("no-progress passes force the loop to blocked", () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "oris-loop-noprog-"));
+  try {
+    const task = initSmokeRepository(root, {
+      taskSlug: "noprog-smoke",
+      program: "noprog-smoke",
+    });
+    const chat = path.join(scriptsRoot, "oris-loop-chat.mjs");
+    const start = spawnSync(process.execPath, [
+      chat, "--action", "start", "--repository-root", root, "--task", task.taskPath,
+    ], { encoding: "utf8" });
+    assert.equal(start.status, 0, `${start.stdout}\n${start.stderr}`);
+
+    // maxNoProgress is 2 in the smoke loop document.
+    for (let index = 0; index < 2; index += 1) {
+      const step = spawnSync(process.execPath, [
+        chat, "--action", "set-state", "--state", "continue", "--progress", "no", "--repository-root", root,
+      ], { encoding: "utf8" });
+      assert.equal(step.status, 0, `${step.stdout}\n${step.stderr}`);
+    }
+
+    const state = JSON.parse(fs.readFileSync(path.join(root, ORIS_FLOW_RUNTIME, "chat-active.json"), "utf8"));
+    assert.equal(state.state, "blocked");
+    assert.equal(state.active, false);
+    assert.equal(state.stopReason, "no-progress limit exhausted");
+    assert.equal(state.noProgressStreak, 2);
+  } 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 {

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

@@ -52,11 +52,12 @@ function activeState(overrides = {}) {
       doctor: "model-d",
       debriefer: "inherit",
     },
+    roles: ["executor", "verifier", "doctor"],
     conversationId: null,
     iteration: 0,
     maxIterations: 5,
-    repairCycles: 0,
-    maxRepairCycles: 2,
+    noProgressStreak: 0,
+    maxNoProgress: 2,
     maxMinutes: 30,
     startedAt: new Date().toISOString(),
     ...overrides,
@@ -91,13 +92,15 @@ test("cursor: claims the conversation and injects the orchestrator prompt", () =
     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, /Active roles: executor, verifier, doctor/);
     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.match(message, /npx oris-skills loop chat --action set-state --state/);
+    assert.match(message, /--progress <yes\|no>/);
+    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);
@@ -141,6 +144,23 @@ test("claude: platform is auto-detected from Stop payload", () => {
   }
 });
 
+test("cursor: auto-detected even when the payload also carries session_id", () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "oris-hook-"));
+  try {
+    // Real Cursor payloads include BOTH conversation_id and session_id.
+    const result = runHook(
+      root,
+      { conversation_id: "c9", session_id: "s9", status: "completed", loop_count: 0 },
+      activeState(),
+    );
+    assert.ok(result.output.followup_message, "must answer in Cursor format");
+    assert.equal(result.output.decision, undefined);
+    assert.equal(result.state.conversationId, "c9");
+  } 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 {
@@ -214,6 +234,47 @@ test("stops on terminal state and exhausted limits", () => {
     );
     assert.deepEqual(expired.output, {});
     assert.equal(expired.state.state, "blocked");
+
+    const stalled = runHook(
+      root,
+      { conversation_id: "c1", status: "completed", loop_count: 0 },
+      activeState({ conversationId: "c1", noProgressStreak: 2, maxNoProgress: 2 }),
+    );
+    assert.deepEqual(stalled.output, {});
+    assert.equal(stalled.state.state, "blocked");
+    assert.equal(stalled.state.stopReason, "no-progress limit exhausted");
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("claude: stopping on an exhausted limit tells the user via systemMessage", () => {
+  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({ conversationId: "s1", iteration: 5, maxIterations: 5 }),
+      ["--platform", "claude"],
+    );
+    assert.match(result.output.systemMessage, /iteration limit exhausted/);
+    assert.equal(result.output.decision, undefined, "must not block the chat");
+    assert.equal(result.state.state, "blocked");
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("ask-user pauses the loop: the hook does not resume it", () => {
+  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: "ask-user", conversationId: "c1" }),
+    );
+    assert.deepEqual(result.output, {});
+    assert.equal(result.state.state, "ask-user", "pause must not be rewritten");
   } finally {
     fs.rmSync(root, { recursive: true, force: true });
   }

package/scripts/tests/test-routing-lifecycle.mjs

@@ -54,14 +54,13 @@ test("shared conventions centralize question, language, and gate rules", () => {
   assert.match(conventions, /ONE question per turn/i);
   assert.match(conventions, /Explain the options.*Spiega le opzioni/s);
   assert.match(conventions, /NEVER write documents, code, settings, Git, or DevOps without explicit user confirmation/i);
-  const questions = read("references/questions.md");
-  assert.match(questions, /`Explain the options`/);
-  assert.match(questions, /`Spiega le opzioni`/);
-  assert.match(questions, /`Basta domande — procedi`/);
-  assert.match(questions, /`Genera il documento`/);
-  assert.match(questions, /`Continua l'intervista`/);
-  assert.match(questions, /`Approva documento`/);
-  assert.match(questions, /`Annulla`/);
+  assert.match(conventions, /`Basta domande — procedi`/);
+  assert.match(conventions, /`Genera il documento`/);
+  assert.match(conventions, /`Continua l'intervista`/);
+  assert.match(conventions, /`Approva documento`/);
+  assert.match(conventions, /`Annulla`/);
+  assert.match(conventions, /oris-flow-criteria.*writes first/i, "the criteria write-first exception must live where skills read it");
+  assert.equal(exists("references/questions.md"), false, "questions.md was merged into conventions.md");
 });
 
 test("every skill points at conventions instead of repeating shared rules", () => {
@@ -108,10 +107,13 @@ test("loop contract stays subagent-first with per-role editable prompts", () =>
   const craft = read("skills/oris-loop/references/craft.md");
   assert.match(craft, /skills\/oris-loop\/templates\//);
   assert.match(craft, /write the loop \| edit verifier \| edit executor \| edit doctor/);
+  assert.match(contract, /ORIS LOOP ACTIVE/, "the contract defines the executor gate literal");
   for (const text of [contract, run, craft, read("skills/oris-loop/SKILL.md")]) {
     assert.doesNotMatch(text, /node scripts\/(?:flow|loop)\//);
     assert.doesNotMatch(text, /composer-2\.5/);
-    assert.doesNotMatch(text, /ORIS LOOP ACTIVE/);
+  }
+  for (const text of [run, craft, read("skills/oris-loop/SKILL.md")]) {
+    assert.doesNotMatch(text, /ORIS LOOP ACTIVE/, "the gate literal lives in the contract and executor prompts only");
   }
 });