oris-skills 2.2.3 → 3.0.2

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

@@ -1,120 +0,0 @@
-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_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 moves through declared phases", () => {
-  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];
-    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",
-        "--progress", "yes",
-        "--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.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 {
-    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 });
-  }
-});
-

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

@@ -1,432 +0,0 @@
-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",
-    },
-    roles: ["executor", "verifier", "doctor"],
-    conversationId: null,
-    iteration: 0,
-    maxIterations: 5,
-    noProgressStreak: 0,
-    maxNoProgress: 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, /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, /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);
-    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("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 {
-    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");
-
-    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 });
-  }
-});
-
-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 });
-  }
-});

package/skills/oris-flow/references/loop-craft.md

@@ -1,59 +0,0 @@
-# Craft a loop — four decisions, everything else defaults
-
-Interview → draft prompts → user approves → write. The user owns the final wording of
-every prompt. A good loop needs exactly FOUR decisions; the rest has a stated default.
-
-## Interview (four decisions, one per turn)
-
-READ first: `.oris-flow/manifest.json` + relevant maps — project facts live there; NEVER
-re-ask them. Question kernel: `references/conventions.md`.
-
-1. GOAL — what does "done" look like? One sentence; it becomes the loop's `Goal:`.
-2. PROOF — how does a pass PROVE it worked? Commands, criteria, observable behavior —
-   this feeds the VERIFIER prompt verbatim, including when `goalMet` becomes true.
-   Weak proof = weak loop; push hardest here.
-3. SCOPE — what may the loop inspect and change; what is off-limits.
-4. STOP — when to stop, ask for help, or declare no-progress. One sentence; becomes `Stop:`.
-
-DEFAULTS — state them once in the recap, change only if the user objects or the work
-demands it: roles executor + verifier · limits 10 passes / 240 minutes · models `inherit`
-· `improve.mode: propose`. OFFER doctor ONLY for multi-phase stop logic; debriefer ONLY
-for long unattended runs (and required for `improve.mode: auto`).
-
-INFER phases and structure from the answers — NEVER ask the user to design schemas or
-subagent contracts. Fresh evidence could not change the next action → recommend a
-one-shot workflow instead of a loop.
-
-## Draft prompts
-
-- COPY templates from `skills/oris-flow/templates/` — ONLY the active roles.
-- FILL the CAPS placeholders from the four decisions; the verifier prompt embeds
-  decision 2 (PROOF) verbatim.
-- KEEP runtime placeholders (`{{iteration}}`, `{{phase}}`, `{{currentTarget}}`) — the
-  orchestrator fills them each pass.
-- TRACE one full pass silently (observe → act → verify → record → stop rule). REPAIR weak
-  verification or vague stops BEFORE showing anything.
-
-## Approval gate
-
-SHOW: goal + stop (2 lines) + the defaults line, then each draft prompt.
-ASK one question: write the loop | edit verifier | edit executor | edit doctor | edit debriefer | keep interviewing.
-ITERATE until the user chooses "write the loop". NEVER write files before that.
-
-## Write
-
-Under `.oris-flow/loops/{slug}/`:
-
-- `loop.md` — front matter per `references/loop-contract.md` (`schemaVersion: 2`,
-  `approved: true`, `roles:` from the interview) + body: `Goal:` and `Stop:` lines.
-- `prompts/<role>.md` — one file per active role.
-- `context.md` — objective + next action.
-- empty `receipts/`, `proposals/`, `history/`.
-
-THEN `npx oris-skills loop dry-run --loop {slug}` and show the result.
-IF the user chose "run now" → follow `skills/oris-flow/references/loop-run.md`.
-
-## Adapt an existing loop
-
-COPY the source loop's prompts, EDIT only what the interview changed, run the same
-approval gate. NEVER overwrite the source loop.

package/skills/oris-flow/references/loop-improve.md

@@ -1,32 +0,0 @@
-# Improve a loop — evidence first, smallest change
-
-READ receipts + the evidence they reference BEFORE touching anything. No pattern from a
-single run unless the defect is obvious.
-
-CLASSIFY the cause first:
-loop design | execution choice | verifier gap | environment/tooling | changed goal | insufficient evidence.
-ONLY loop-design and verifier-gap causes justify changing the loop.
-
-## Where changes land
-
-| Change | improve.mode: propose | improve.mode: auto |
-|--------|----------------------|--------------------|
-| prompts/*.md wording | proposal in `proposals/` | debriefer edits directly; old file → `history/`; noted in receipt |
-| context.md facts | allowed | allowed |
-| scope, limits, permissions, verification commands (loop.md) | proposal + explicit user approval | SAME — never automatic |
-
-RULE: one improvement per debrief, the smallest change the evidence justifies.
-APPLYING an approved loop.md change → archive the previous `loop.md` to
-`history/loop.vN.md`, record the decision in the next receipt.
-
-## Never
-
-- Let an unapproved proposal affect execution.
-- Change scope, limits, permissions, or verification commands without explicit approval —
-  in ANY improve mode.
-- Tune prompts to make the verifier easier to satisfy — fix the loop, not the bar.
-
-## Outcome
-
-Report exactly one:
-`Keep loop` | `Tuned prompts` | `Patch proposed` | `Execution issue` | `Environment blocked` | `Inconclusive`.

package/skills/oris-flow/references/loop-run.md

@@ -1,47 +0,0 @@
-# Run a loop — arm once, then obey the hook
-
-The chat is the control plane, never the worker. Arm the loop, end the turn; every pass
-after that is injected by the platform hook and followed exactly.
-
-## Arm (first turn)
-
-1. RESOLVE the slug: `npx oris-skills loop list --json`.
-2. CHECK readiness: `npx oris-skills loop dry-run --loop <slug>` — validates prompts and
-   shows the exact pass message.
-3. ARM: `npx oris-skills loop chat --action start --loop <slug>` (rebind a broken runtime
-   with `--action repair`).
-4. END the turn with one status line. The stop hook injects the next pass automatically.
-
-`--task <path>` only materializes a NEW loop from a task path — never an alias for a slug.
-
-## Each pass (triggered by the hook message)
-
-The injected message IS the orchestrator prompt (from `prompts/orchestrator.md` or the
-shipped default). FOLLOW it exactly:
-
-- Orchestrator = control plane only. NEVER do executor/verifier/doctor work in the main chat.
-- SPAWN one subagent per ACTIVE role (listed in the pass message) with its
-  `prompts/<role>.md` file, runtime placeholders filled, model from the pass message.
-- No doctor among the active roles → map the verifier verdict yourself:
-  pass + goalMet → complete · pass / fail → continue · blocked / inconclusive → ask-user.
-- Windows: workers must not chain commands with `&&`; use the tool working directory.
-- RECEIPT per pass (see contract); raw logs → `.oris-flow/runtime/evidence/`.
-- CLOSE: `npx oris-skills loop chat --action set-state --state <state> --progress <yes|no>`,
-  then end the turn with `ORIS_LOOP_STATE: <state>`.
-- On ask-user: say what decision is needed; the loop stays paused until
-  `set-state --state continue`.
-
-## Never
-
-- Start or simulate a pass in the same turn you armed the loop — the hook drives.
-- Ask "run next pass?" after continue/advance — END THE TURN instead.
-- Invent role instructions: prompt files missing → `set-state blocked`, tell the user to
-  complete craft.
-- Degrade into worker roles when subagents cannot be spawned → `set-state blocked`.
-- Classify an error, a missing tool, or an exhausted limit as success.
-
-## Headless (Codex / CI)
-
-`npx oris-skills loop run --loop <slug> --agent codex|claude`
-Each active role runs as a separate CLI process with its own prompt file and model
-(read-only roles run without write access); receipts and state work the same.