oris-skills 2.2.3 → 3.0.2

package/scripts/tests/test-agent-adapters.mjs

@@ -1,70 +0,0 @@
-import childProcess from "node:child_process";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import assert from "node:assert/strict";
-import process from "node:process";
-import test from "node:test";
-import { fileURLToPath } from "node:url";
-import { generateAgentAdapters } from "../install/generate-agent-adapters.mjs";
-
-const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
-
-function runCli(args, homeDir) {
-  return childProcess.spawnSync(process.execPath, ["scripts/oris-skills.mjs", ...args], {
-    cwd: root,
-    encoding: "utf8",
-    env: { ...process.env, HOME: homeDir, USERPROFILE: homeDir },
-    shell: false,
-  });
-}
-
-test("generates repo-local Cursor, Claude, and Codex agent adapters", () => {
-  const temp = fs.mkdtempSync(path.join(os.tmpdir(), "oris-agent-adapters-"));
-  try {
-    const generated = generateAgentAdapters(temp);
-    assert.ok(generated.includes("oris-loop-executor"));
-    assert.ok(fs.existsSync(path.join(temp, ".cursor", "agents", "oris-loop-executor.md")));
-    assert.ok(fs.existsSync(path.join(temp, ".claude", "agents", "oris-loop-verifier.md")));
-    assert.ok(fs.existsSync(path.join(temp, ".codex", "agents", "oris-loop-doctor.toml")));
-  } finally {
-    fs.rmSync(temp, { recursive: true, force: true });
-  }
-});
-
-test("install never plans loop agent adapters in user agent homes", () => {
-  const homeDir = fs.mkdtempSync(path.join(os.tmpdir(), "oris-agent-install-"));
-  try {
-    fs.mkdirSync(path.join(homeDir, ".claude"), { recursive: true });
-    fs.mkdirSync(path.join(homeDir, ".cursor"), { recursive: true });
-    const result = runCli(["install", "--dry-run"], homeDir);
-    assert.equal(result.status, 0, result.stderr);
-    assert.doesNotMatch(result.stdout, /loop agents/i);
-    assert.doesNotMatch(result.stdout, /agent adapters/i);
-  } finally {
-    fs.rmSync(homeDir, { recursive: true, force: true });
-  }
-});
-
-test("uninstall removes legacy loop agent adapters but keeps user agents", () => {
-  const homeDir = fs.mkdtempSync(path.join(os.tmpdir(), "oris-agent-uninstall-"));
-  try {
-    const claudeAgents = path.join(homeDir, ".claude", "agents");
-    const cursorAgents = path.join(homeDir, ".cursor", "agents");
-    const codexAgents = path.join(homeDir, ".codex", "agents");
-    for (const dir of [claudeAgents, cursorAgents, codexAgents]) fs.mkdirSync(dir, { recursive: true });
-    fs.writeFileSync(path.join(claudeAgents, "oris-loop-executor.md"), "legacy adapter\n", "utf8");
-    fs.writeFileSync(path.join(claudeAgents, "my-agent.md"), "user agent\n", "utf8");
-    fs.writeFileSync(path.join(cursorAgents, "oris-loop-verifier.md"), "legacy adapter\n", "utf8");
-    fs.writeFileSync(path.join(codexAgents, "oris-loop-doctor.toml"), "legacy adapter\n", "utf8");
-
-    const result = runCli(["uninstall"], homeDir);
-    assert.equal(result.status, 0, result.stderr);
-    assert.equal(fs.existsSync(path.join(claudeAgents, "oris-loop-executor.md")), false);
-    assert.equal(fs.existsSync(path.join(cursorAgents, "oris-loop-verifier.md")), false);
-    assert.equal(fs.existsSync(path.join(codexAgents, "oris-loop-doctor.toml")), false);
-    assert.equal(fs.existsSync(path.join(claudeAgents, "my-agent.md")), true, "non-Oris agents must survive");
-  } finally {
-    fs.rmSync(homeDir, { recursive: true, force: true });
-  }
-});

package/scripts/tests/test-oris-1-0-cleanliness.mjs

@@ -1,58 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import assert from "node:assert/strict";
-import test from "node:test";
-import { fileURLToPath } from "node:url";
-
-const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
-const ignoredDirs = new Set([".git", "node_modules", ".cursor", ".claude", ".codex", "dist", ".cursor-plugin-install-backups", ".oris-flow"]);
-
-function walk(dir, matches = []) {
-  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-    if (ignoredDirs.has(entry.name)) continue;
-    const full = path.join(dir, entry.name);
-    if (entry.isDirectory()) walk(full, matches);
-    else matches.push(full);
-  }
-  return matches;
-}
-
-function repoFiles() {
-  return walk(repoRoot).map((filePath) => ({
-    filePath,
-    relative: path.relative(repoRoot, filePath).replace(/\\/g, "/"),
-  }));
-}
-
-test("repository contains no PowerShell scripts", () => {
-  const psFiles = repoFiles().filter((entry) => entry.relative.endsWith(".ps1"));
-  assert.deepEqual(psFiles.map((entry) => entry.relative), []);
-});
-
-test("Oris public loop text does not reference external loop brands", () => {
-  const offenders = repoFiles()
-    .filter((entry) => /\.(md|mjs|json|yml|yaml|cmd|sh|command)$/.test(entry.relative))
-    .filter((entry) => entry.relative !== "scripts/tests/test-oris-1-0-cleanliness.mjs")
-    .filter((entry) => entry.relative !== "CHANGELOG.md")
-    .filter((entry) => /loopy/i.test(fs.readFileSync(entry.filePath, "utf8")))
-    .map((entry) => entry.relative);
-  assert.deepEqual(offenders, []);
-});
-
-test("Oris Loop 1.0 does not use global preset storage", () => {
-  const offenders = repoFiles()
-    .filter((entry) => /\.(md|mjs|json|yml|yaml|cmd|sh|command)$/.test(entry.relative))
-    .filter((entry) => entry.relative !== "scripts/tests/test-oris-1-0-cleanliness.mjs")
-    .filter((entry) => /ORIS_FLOW_USER_PRESETS|~\/\.cursor\/oris-flow|oris-flow[\\/]presets/i.test(fs.readFileSync(entry.filePath, "utf8")))
-    .map((entry) => entry.relative);
-  assert.deepEqual(offenders, []);
-});
-
-test("Oris Loop does not ship or install loop libraries", () => {
-  const offenders = repoFiles()
-    .filter((entry) => /\.(md|mjs|json|yml|yaml|cmd|sh|command)$/.test(entry.relative))
-    .filter((entry) => entry.relative !== "scripts/tests/test-oris-1-0-cleanliness.mjs")
-    .filter((entry) => /\.oris-flow[\\/]library|flow[\\/]oris[\\/]library|oris-loop-library|ORIS_FLOW_(?:SOFTWARE_|CUSTOM_)?LIBRARY/i.test(fs.readFileSync(entry.filePath, "utf8")))
-    .map((entry) => entry.relative);
-  assert.deepEqual(offenders, []);
-});

package/scripts/tests/test-oris-flow-clean-runtime.mjs

@@ -1,75 +0,0 @@
-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 { cleanFlowRuntime, resolveCleanTargets } from "../flow/oris-flow-clean-runtime.mjs";
-import { ORIS_FLOW_ADAPTER, ORIS_FLOW_RUNTIME } from "../flow/oris-flow-layout.mjs";
-
-test("resolveCleanTargets defaults to .oris-flow runtime", () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), "oris-clean-"));
-  try {
-    assert.deepEqual(resolveCleanTargets(root), [path.join(root, ORIS_FLOW_RUNTIME)]);
-  } finally {
-    fs.rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("resolveCleanTargets honors adapter runtime under .oris-flow", () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), "oris-clean-"));
-  try {
-    fs.mkdirSync(path.dirname(path.join(root, ORIS_FLOW_ADAPTER)), { recursive: true });
-    fs.writeFileSync(path.join(root, ORIS_FLOW_ADAPTER), `${JSON.stringify({
-      paths: { runtime: ".oris-flow/runtime" },
-    })}\n`, "utf8");
-    assert.deepEqual(resolveCleanTargets(root), [path.join(root, ORIS_FLOW_RUNTIME)]);
-  } finally {
-    fs.rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("cleanFlowRuntime removes loop logs and preserves setup files", () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), "oris-clean-"));
-  try {
-    fs.mkdirSync(path.join(root, ".oris-flow", "maps"), { recursive: true });
-    fs.mkdirSync(path.join(root, ".oris-flow", "loops", "sample"), { recursive: true });
-    fs.writeFileSync(path.join(root, ".oris-flow", "manifest.json"), "{}\n", "utf8");
-    fs.writeFileSync(path.join(root, ".oris-flow", "maps", "summary.md"), "# setup\n", "utf8");
-    fs.writeFileSync(path.join(root, ".oris-flow", "loops", "sample", "loop.md"), "# loop\n", "utf8");
-    fs.writeFileSync(path.join(root, ORIS_FLOW_ADAPTER), `${JSON.stringify({
-      paths: { runtime: ".oris-flow/runtime" },
-    })}\n`, "utf8");
-
-    const runtimeDir = path.join(root, ORIS_FLOW_RUNTIME);
-    fs.mkdirSync(path.join(runtimeDir, "failures"), { recursive: true });
-    fs.writeFileSync(path.join(runtimeDir, "chat-active.json"), "{}\n", "utf8");
-    fs.writeFileSync(path.join(runtimeDir, "hook-debug.jsonl"), "{}\n", "utf8");
-    fs.writeFileSync(path.join(runtimeDir, "sample.lock.json"), "{}\n", "utf8");
-    fs.writeFileSync(path.join(runtimeDir, "failures", "sample.stream.jsonl"), "{}\n", "utf8");
-    fs.writeFileSync(path.join(runtimeDir, "stack.json"), "{}\n", "utf8");
-
-    const result = cleanFlowRuntime(root);
-    assert.equal(result.cleaned, true);
-    assert.equal(fs.existsSync(path.join(root, ORIS_FLOW_RUNTIME)), false);
-    assert.ok(fs.existsSync(path.join(root, ".oris-flow", "manifest.json")));
-    assert.ok(fs.existsSync(path.join(root, ".oris-flow", "loops", "sample", "loop.md")));
-    assert.ok(fs.existsSync(path.join(root, ORIS_FLOW_ADAPTER)));
-  } finally {
-    fs.rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("cleanFlowRuntime dry run lists files without deleting them", () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), "oris-clean-"));
-  try {
-    const runtimeDir = path.join(root, ORIS_FLOW_RUNTIME);
-    fs.mkdirSync(runtimeDir, { recursive: true });
-    fs.writeFileSync(path.join(runtimeDir, "hook-debug.jsonl"), "{}\n", "utf8");
-
-    const result = cleanFlowRuntime(root, { dryRun: true });
-    assert.equal(result.cleaned, true);
-    assert.ok(fs.existsSync(path.join(runtimeDir, "hook-debug.jsonl")));
-  } finally {
-    fs.rmSync(root, { recursive: true, force: true });
-  }
-});

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

@@ -1,94 +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 {
-  assessLoopReadiness,
-  bootstrapLoop,
-  detectPlaywrightRoot,
-} from "../loop/oris-loop-bootstrap.mjs";
-import { ORIS_FLOW_ADAPTER } from "../flow/oris-flow-layout.mjs";
-
-function initGitRepo(root) {
-  const git = spawnSync("git", ["init", "-q"], { cwd: root, encoding: "utf8" });
-  assert.equal(git.status, 0, git.stderr);
-}
-
-test("bootstrap creates loop readiness files when missing", () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), "oris-loop-bootstrap-"));
-  try {
-    initGitRepo(root);
-    fs.mkdirSync(path.join(root, "Test", "e2e"), { recursive: true });
-    fs.writeFileSync(path.join(root, "Test", "e2e", "playwright.config.ts"), "export default { testDir: '.' };\n", "utf8");
-    fs.writeFileSync(path.join(root, "Test", "e2e", "package.json"), `${JSON.stringify({ scripts: { check: "playwright test --list" } })}\n`, "utf8");
-
-    const before = assessLoopReadiness(root);
-    assert.equal(before.ready, false);
-
-    const result = bootstrapLoop(root);
-    assert.equal(result.ready, true);
-    assert.ok(fs.existsSync(path.join(root, ORIS_FLOW_ADAPTER)));
-    assert.ok(fs.existsSync(path.join(root, ".cursor", "hooks.json")));
-    assert.ok(fs.existsSync(path.join(root, ".cursor", "hooks", "oris-loop-stop.mjs")));
-    assert.ok(fs.existsSync(path.join(root, ".claude", "settings.json")));
-    assert.ok(fs.existsSync(path.join(root, ".claude", "hooks", "oris-loop-stop.mjs")));
-    assert.match(fs.readFileSync(path.join(root, ".claude", "hooks", "oris-loop-stop.mjs"), "utf8"), /--platform", "claude/);
-    const claudeSettings = JSON.parse(fs.readFileSync(path.join(root, ".claude", "settings.json"), "utf8"));
-    assert.ok(JSON.stringify(claudeSettings.hooks.Stop).includes("oris-loop-stop"));
-    assert.match(fs.readFileSync(path.join(root, ".gitignore"), "utf8"), /\.oris-flow\/runtime\//);
-
-    const adapter = JSON.parse(fs.readFileSync(path.join(root, ORIS_FLOW_ADAPTER), "utf8"));
-    assert.equal(adapter.paths.testDir, "Test/e2e");
-    assert.ok(adapter.commands["e2e-check"]);
-  } finally {
-    fs.rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("bootstrap is idempotent when loop is already configured", () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), "oris-loop-bootstrap-"));
-  try {
-    initGitRepo(root);
-    bootstrapLoop(root);
-    const adapterBefore = fs.readFileSync(path.join(root, ORIS_FLOW_ADAPTER), "utf8");
-    const result = bootstrapLoop(root);
-    assert.equal(result.ready, true);
-    assert.equal(fs.readFileSync(path.join(root, ORIS_FLOW_ADAPTER), "utf8"), adapterBefore);
-  } finally {
-    fs.rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("bootstrap merges stop hook into existing hooks.json", () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), "oris-loop-bootstrap-"));
-  try {
-    initGitRepo(root);
-    fs.mkdirSync(path.join(root, ".cursor"), { recursive: true });
-    fs.writeFileSync(path.join(root, ".cursor", "hooks.json"), `${JSON.stringify({
-      version: 1,
-      hooks: { stop: [{ command: "node .cursor/hooks/custom-stop.mjs", loop_limit: null }] },
-    }, null, 2)}\n`, "utf8");
-
-    const result = bootstrapLoop(root);
-    assert.equal(result.ready, true);
-    const hooks = JSON.parse(fs.readFileSync(path.join(root, ".cursor", "hooks.json"), "utf8"));
-    assert.equal(hooks.hooks.stop.length, 2);
-    assert.ok(hooks.hooks.stop.some((entry) => String(entry.command).includes("custom-stop")));
-    assert.ok(hooks.hooks.stop.some((entry) => String(entry.command).includes("oris-loop-stop")));
-  } finally {
-    fs.rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("detectPlaywrightRoot resolves config directory", () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), "oris-loop-bootstrap-"));
-  try {
-    fs.mkdirSync(path.join(root, "Test", "e2e"), { recursive: true });
-    fs.writeFileSync(path.join(root, "Test", "e2e", "playwright.config.ts"), "export default { testDir: '.' };\n", "utf8");
-    assert.equal(detectPlaywrightRoot(root), "Test/e2e");
-  } finally {
-    fs.rmSync(root, { recursive: true, force: true });
-  }
-});

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

@@ -1,148 +0,0 @@
-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 {
-  activeRoles,
-  assessPromptFiles,
-  improveMode,
-  normalizeModels,
-  validateLoopDocumentText,
-} from "../loop/oris-loop-document.mjs";
-
-const validLoop = `---
-schemaVersion: 2
-kind: oris-loop
-name: bug-fix-loop
-approved: true
-phases: [observe, execute, verify, debrief]
-roles: [executor, verifier, debriefer]
-limits:
-  maxIterations: 10
-  maxNoProgress: 2
-  maxMinutes: 60
-models:
-  default: inherit
-  verifier: smart
-improve:
-  mode: auto
-permissions:
-  allowedPaths: [src, tests]
-  forbiddenActions: [commit, push, deploy, external-message]
-verification:
-  commands: [npm test]
-  evidenceRequired: true
----
-
-# Bug Fix Loop
-
-Goal: fix one verified bug per pass.
-Stop: all listed bugs fixed or blocked.
-`;
-
-test("validates Oris Loop v2 front matter", () => {
-  const parsed = validateLoopDocumentText(validLoop, "bug-fix.loop.md");
-  assert.equal(parsed.data.schemaVersion, 2);
-  assert.equal(parsed.data.kind, "oris-loop");
-  assert.equal(parsed.data.approved, true);
-  assert.deepEqual(parsed.data.phases, ["observe", "execute", "verify", "debrief"]);
-  assert.equal(parsed.data.limits.maxIterations, 10);
-  assert.equal(parsed.data.verification.evidenceRequired, true);
-});
-
-test("rejects loops without user approval", () => {
-  assert.throws(
-    () => validateLoopDocumentText(validLoop.replace("approved: true", "approved: false"), "unapproved.loop.md"),
-    /approved must be true/,
-  );
-});
-
-test("rejects old schema versions", () => {
-  assert.throws(
-    () => validateLoopDocumentText(validLoop.replace("schemaVersion: 2", "schemaVersion: 1"), "old.loop.md"),
-    /schemaVersion must be 2/,
-  );
-});
-
-test("rejects empty model values but accepts arbitrary model ids", () => {
-  assert.throws(
-    () => validateLoopDocumentText(validLoop.replace("verifier: smart", 'verifier: ""'), "bad-model.loop.md"),
-    /models\.verifier/,
-  );
-  const custom = validateLoopDocumentText(validLoop.replace("verifier: smart", "verifier: any-platform-model"), "custom-model.loop.md");
-  assert.equal(custom.data.models.verifier, "any-platform-model");
-});
-
-test("rejects unknown improve modes", () => {
-  assert.throws(
-    () => validateLoopDocumentText(validLoop.replace("mode: auto", "mode: yolo"), "bad-improve.loop.md"),
-    /improve\.mode/,
-  );
-});
-
-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" },
-    { smart: "platform-smart-model" },
-  );
-  assert.equal(models.default, "inherit");
-  assert.equal(models.executor, "inherit");
-  assert.equal(models.verifier, "platform-smart-model");
-  assert.equal(models.doctor, "explicit-model-id");
-  assert.equal(models.debriefer, "inherit");
-});
-
-test("improveMode defaults to propose", () => {
-  assert.equal(improveMode({}), "propose");
-  assert.equal(improveMode({ improve: { mode: "auto" } }), "auto");
-});
-
-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"]);
-    fs.mkdirSync(path.join(dir, "prompts"), { recursive: true });
-    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-list.mjs

@@ -1,74 +0,0 @@
-#!/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

@@ -1,71 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-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", () => {
-  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("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("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/);
-  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");
-});