oris-skills 2.2.2 → 3.0.1

package/scripts/install/oris-mcp.mjs

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import path from "node:path";
+
+/** Agents that receive an MCP seed. Copilot has no home-scoped MCP target here. */
+export const MCP_AGENTS = ["cursor", "claude", "codex"];
+
+/** MCP config file + format per agent, derived from the (overridable) agent roots. */
+export function mcpConfigTarget(agent, agentRoots) {
+  if (agent === "cursor") return { kind: "json", filePath: path.join(agentRoots.cursor, "mcp.json") };
+  if (agent === "claude") return { kind: "json", filePath: path.join(path.dirname(agentRoots.claude), ".claude.json") };
+  if (agent === "codex") return { kind: "toml", filePath: path.join(agentRoots.codex, "config.toml") };
+  return null;
+}
+
+function readText(filePath) {
+  try {
+    return fs.readFileSync(filePath, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+function tomlBlock(name, server) {
+  const args = server.args.map((arg) => JSON.stringify(arg)).join(", ");
+  return `\n[mcp_servers.${name}]\ncommand = ${JSON.stringify(server.command)}\nargs = [${args}]\n`;
+}
+
+/**
+ * Seed one MCP server into an agent's config, idempotently. Already present → skip unless
+ * `force`. `dryRun` reports the plan without writing. Returns a status per agent:
+ * "seeded" | "present" | "planned" | "skipped".
+ */
+export function seedMcpServer(agent, agentRoots, name, server, options = {}) {
+  const target = mcpConfigTarget(agent, agentRoots);
+  if (!target) return { status: "skipped", agent };
+
+  if (target.kind === "json") {
+    let data = {};
+    const existing = readText(target.filePath);
+    if (existing.trim()) {
+      try {
+        data = JSON.parse(existing);
+      } catch {
+        data = {};
+      }
+    }
+    const servers = data.mcpServers && typeof data.mcpServers === "object" ? data.mcpServers : {};
+    const present = Object.prototype.hasOwnProperty.call(servers, name);
+    if (present && !options.force) return { status: "present", agent, filePath: target.filePath };
+    if (options.dryRun) return { status: "planned", agent, filePath: target.filePath };
+    servers[name] = server;
+    data.mcpServers = servers;
+    fs.mkdirSync(path.dirname(target.filePath), { recursive: true });
+    fs.writeFileSync(target.filePath, `${JSON.stringify(data, null, 2)}\n`, "utf8");
+    return { status: "seeded", agent, filePath: target.filePath };
+  }
+
+  // TOML (Codex config.toml)
+  const text = readText(target.filePath);
+  const present = text.includes(`[mcp_servers.${name}]`);
+  if (present) return { status: "present", agent, filePath: target.filePath };
+  if (options.dryRun) return { status: "planned", agent, filePath: target.filePath };
+  fs.mkdirSync(path.dirname(target.filePath), { recursive: true });
+  fs.writeFileSync(target.filePath, `${text}${tomlBlock(name, server)}`, "utf8");
+  return { status: "seeded", agent, filePath: target.filePath };
+}

package/scripts/install/uninstall-user-skills.mjs

@@ -24,7 +24,6 @@ function parseArgs(argv) {
   const options = {
     dryRun: false,
     bundleRoot: path.join(home, ".oris", "oris-skills"),
-    settingsPath: path.join(home, ".oris", "settings.json"),
     cursorRoot: path.join(home, ".cursor"),
     claudeRoot: path.join(home, ".claude"),
     codexRoot: path.join(home, ".codex"),
@@ -45,7 +44,6 @@ function parseArgs(argv) {
     };
     if (key === "--dry-run") options.dryRun = true;
     else if (key === "--bundle-root" || key.startsWith("--bundle-root=")) options.bundleRoot = value();
-    else if (key === "--settings" || key.startsWith("--settings=")) options.settingsPath = value();
     else if (key === "--cursor-root" || key.startsWith("--cursor-root=")) options.cursorRoot = value();
     else if (key === "--claude-root" || key.startsWith("--claude-root=")) options.claudeRoot = value();
     else if (key === "--codex-root" || key.startsWith("--codex-root=")) options.codexRoot = value();
@@ -92,15 +90,6 @@ function managedCodexPrompts(codexRoot) {
     .map((entry) => path.join(promptsRoot, entry.name));
 }
 
-/** Loop agent adapters that pre-2.2.1 installers wrote into <agent home>/agents/. */
-function managedAgentAdapters(agentRoot, extension) {
-  const agentsRoot = path.join(agentRoot, "agents");
-  if (!fs.existsSync(agentsRoot)) return [];
-  return fs.readdirSync(agentsRoot, { withFileTypes: true })
-    .filter((entry) => entry.isFile() && entry.name.toLowerCase().startsWith("oris-") && entry.name.endsWith(extension))
-    .map((entry) => path.join(agentsRoot, entry.name));
-}
-
 function managedCopilotPrompts(copilotRoot) {
   const promptsRoot = path.join(copilotRoot, "prompts");
   if (!fs.existsSync(promptsRoot)) return [];
@@ -109,18 +98,6 @@ function managedCopilotPrompts(copilotRoot) {
     .map((entry) => path.join(promptsRoot, entry.name));
 }
 
-function legacyOrisPaths(options) {
-  return [
-    path.join(options.cursorRoot, "oris-skills"),
-    path.join(options.cursorRoot, "oris-flow"),
-    path.join(options.cursorRoot, "oris-loop"),
-    path.join(options.cursorRoot, "oris-skills.settings.json"),
-    path.join(options.cursorRoot, ".cursor-plugin-install-backups"),
-    path.join(options.cursorRoot, "plugins", "oris-skills"),
-    options.settingsPath,
-  ];
-}
-
 function plannedRemovals(options) {
   const paths = new Set([
     options.bundleRoot,
@@ -128,11 +105,7 @@ function plannedRemovals(options) {
     ...managedSkillDirs(path.join(options.claudeRoot, "skills")),
     ...managedCodexPrompts(options.codexRoot),
     ...managedCopilotPrompts(options.copilotRoot),
-    ...managedAgentAdapters(options.cursorRoot, ".md"),
-    ...managedAgentAdapters(options.claudeRoot, ".md"),
-    ...managedAgentAdapters(options.codexRoot, ".toml"),
     path.join(path.dirname(options.bundleRoot), "oris-flow.md"),
-    ...legacyOrisPaths(options),
   ]);
   return [...paths].map((target) => path.resolve(target)).filter(safeOrisPath).sort();
 }
@@ -153,7 +126,7 @@ function removeOrisMcpServers(userMcpPath, dryRun) {
 
 export function uninstallUserSkills(rawArgs = []) {
   const options = parseArgs(rawArgs);
-  for (const target of [options.bundleRoot, options.settingsPath, options.cursorRoot, options.claudeRoot, options.codexRoot, options.copilotRoot]) {
+  for (const target of [options.bundleRoot, options.cursorRoot, options.claudeRoot, options.codexRoot, options.copilotRoot]) {
     assertInsideHome(target);
   }
 
@@ -161,7 +134,7 @@ export function uninstallUserSkills(rawArgs = []) {
   log(options.dryRun ? "Dry run uninstall plan:" : "Uninstalling Oris-owned assets:");
   for (const target of removals) log(`${options.dryRun ? "Would remove" : "Remove"} ${target}`);
 
-  // Legacy cleanup: older releases merged an Oris MCP server into Cursor's user config.
+  // The installer seeds the Oris MCP server into Cursor's user config; remove it with the rest.
   const mcpResult = removeOrisMcpServers(path.join(options.cursorRoot, "mcp.json"), options.dryRun);
   if (mcpResult.changed) log(`${options.dryRun ? "Would update" : "Updated"} ${mcpResult.path}`);
 

package/scripts/oris-skills.mjs

@@ -4,7 +4,6 @@ import childProcess from "node:child_process";
 import path from "node:path";
 import process from "node:process";
 import { fileURLToPath } from "node:url";
-import { bootstrapLoop } from "./loop/oris-loop-bootstrap.mjs";
 
 const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 
@@ -19,15 +18,6 @@ function runNode(script, args, options = {}) {
   process.exit(status);
 }
 
-function runGitRoot() {
-  const result = childProcess.spawnSync("git", ["rev-parse", "--show-toplevel"], {
-    cwd: process.cwd(),
-    shell: process.platform === "win32",
-    encoding: "utf8",
-  });
-  return result.status === 0 && result.stdout.trim() ? path.resolve(result.stdout.trim()) : process.cwd();
-}
-
 function printHelp() {
   console.log(`Oris Skills
 
@@ -36,24 +26,10 @@ Install for your agents (Cursor, Claude Code, Codex):
   oris-skills uninstall [--dry-run]
   oris-skills reinstall [--dry-run]
 
-Learn and test loops:
-  oris-skills loop demo                      create a safe tutorial loop
-  oris-skills loop dry-run --loop <slug>     preview the next pass, run nothing
-  oris-skills loop verify --temp             self-check the loop runtime
-
-Run and manage loops:
-  oris-skills loop list [--json]
-  oris-skills loop bootstrap [--platforms cursor,claude]
-  oris-skills loop chat --action start --loop <slug>
-  oris-skills loop chat --action status|set-state|repair|stop [...]
-  oris-skills loop run --loop <slug> --agent codex|claude   headless runner
-
 Repository tools:
-  oris-skills doctor
   oris-skills validate
   oris-skills flow scan [...]
   oris-skills flow version-control [...]
-  oris-skills flow clean-runtime [...]
 `);
 }
 
@@ -79,37 +55,14 @@ if (command === "reinstall") {
   runNode("install/install-user-skills.mjs", ["--force", ...commandArgs]);
 }
 
-if (command === "doctor") {
-  const root = runGitRoot();
-  const result = bootstrapLoop(root, { dryRun: true });
-  console.log(JSON.stringify({
-    repositoryRoot: root,
-    ready: result.ready,
-    missing: result.before.missing,
-    plannedActions: result.actions,
-  }, null, 2));
-  process.exit(result.ready ? 0 : 1);
-}
-
 if (command === "validate") {
   // Kept as an alias of the full test suite for older docs and muscle memory.
   runNode("tests/run-all-tests.mjs", []);
 }
 
-if (command === "loop") {
-  if (subcommand === "list") runNode("loop/oris-loop-list.mjs", rest);
-  if (subcommand === "bootstrap") runNode("loop/oris-loop-bootstrap.mjs", rest);
-  if (subcommand === "chat") runNode("loop/oris-loop-chat.mjs", rest);
-  if (subcommand === "verify") runNode("loop/oris-loop-verify.mjs", rest);
-  if (subcommand === "demo") runNode("loop/oris-loop-demo.mjs", rest);
-  if (subcommand === "dry-run") runNode("loop/oris-loop-dry-run.mjs", rest);
-  if (subcommand === "run") runNode("loop/oris-loop-run.mjs", rest);
-}
-
 if (command === "flow") {
   if (subcommand === "scan") runNode("flow/oris-flow-scan.mjs", rest);
   if (subcommand === "version-control") runNode("flow/oris-flow-version-control.mjs", rest);
-  if (subcommand === "clean-runtime") runNode("flow/oris-flow-clean-runtime.mjs", rest);
 }
 
 console.error(`Unknown command: ${[command, subcommand].filter(Boolean).join(" ")}`);

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

@@ -9,19 +9,13 @@ const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", ".
 
 const nodeTestFiles = [
   "scripts/tests/test-schemas.mjs",
-  "scripts/tests/test-oris-loop-document.mjs",
-  "scripts/tests/test-agent-adapters.mjs",
   "scripts/tests/test-skill-self-contained.mjs",
-  "scripts/tests/test-oris-1-0-cleanliness.mjs",
+  "scripts/tests/test-cleanliness.mjs",
   "scripts/tests/test-oris-flow-scan.mjs",
+  "scripts/tests/test-oris-flow-devops.mjs",
+  "scripts/tests/test-install-mcp.mjs",
   "scripts/tests/test-routing-lifecycle.mjs",
   "scripts/tests/test-skill-style.mjs",
-  "scripts/tests/test-oris-loop-stop.mjs",
-  "scripts/tests/test-oris-loop-smoke.mjs",
-  "scripts/tests/test-oris-loop-bootstrap.mjs",
-  "scripts/tests/test-oris-flow-clean-runtime.mjs",
-  "scripts/tests/test-oris-loop-list.mjs",
-  "scripts/tests/test-oris-loop-run.mjs",
   "scripts/tests/test-oris-gitignore.mjs",
 ];
 

package/scripts/tests/test-cleanliness.mjs

@@ -0,0 +1,54 @@
+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), []);
+});
+
+// Machinery removed in 3.0: the loop runtime and the manifest/maps knowledge store.
+// The agent-facing surface (skills, references, docs, README) must never point at it;
+// CHANGELOG keeps the history, and the uninstaller/gitignore keep legacy-cleanup paths.
+const removedMachinery = /oris-skills loop |scripts\/loop\/|\.oris-flow\/(?:loops|runtime|manifest\.json|maps|adapter\.json)|loop-contract|references\/repo-map|flow scan[^\n]*--(?:check|write|area)|flow clean-runtime/;
+
+test("agent-facing text never references machinery removed in 3.0", () => {
+  const offenders = repoFiles()
+    .filter((entry) => /^(skills|references|docs)\/.*\.md$|^(README|AGENTS|CONTEXT)\.md$/.test(entry.relative))
+    .filter((entry) => removedMachinery.test(fs.readFileSync(entry.filePath, "utf8")))
+    .map((entry) => entry.relative);
+  assert.deepEqual(offenders, []);
+});
+
+test("production scripts never invoke machinery removed in 3.0", () => {
+  const offenders = repoFiles()
+    // scripts/tests assert absences; the uninstaller/gitignore clean legacy paths — both must name them.
+    .filter((entry) => /^scripts\/(flow|install)\/.*\.mjs$|^scripts\/[^/]+\.mjs$/.test(entry.relative))
+    .filter((entry) => entry.relative !== "scripts/install/uninstall-user-skills.mjs")
+    .filter((entry) => entry.relative !== "scripts/flow/oris-gitignore.mjs")
+    .filter((entry) => removedMachinery.test(fs.readFileSync(entry.filePath, "utf8")))
+    .map((entry) => entry.relative);
+  assert.deepEqual(offenders, []);
+});

package/scripts/tests/test-install-mcp.mjs

@@ -0,0 +1,66 @@
+import assert from "node:assert/strict";
+import childProcess from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+
+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("install --dry-run plans the oris-devops MCP server", () => {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), "oris-mcp-dry-"));
+  try {
+    const result = runCli(["install", "--dry-run", "--agents", "claude,cursor,codex"], home);
+    assert.equal(result.status, 0, result.stderr);
+    assert.match(result.stdout, /Would seed MCP server 'oris-devops'/);
+  } finally {
+    fs.rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test("--no-mcp skips seeding", () => {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), "oris-mcp-off-"));
+  try {
+    const result = runCli(["install", "--dry-run", "--agents", "claude", "--no-mcp"], home);
+    assert.equal(result.status, 0, result.stderr);
+    assert.doesNotMatch(result.stdout, /Would seed MCP/);
+  } finally {
+    fs.rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test("real install seeds oris-devops into the Claude config, idempotently", () => {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), "oris-mcp-real-"));
+  try {
+    fs.mkdirSync(path.join(home, ".claude"), { recursive: true });
+    const first = runCli(["install", "--force", "--agents", "claude"], home);
+    assert.equal(first.status, 0, first.stderr);
+
+    const claudeConfig = path.join(home, ".claude.json");
+    assert.ok(fs.existsSync(claudeConfig), "~/.claude.json written");
+    const data = JSON.parse(fs.readFileSync(claudeConfig, "utf8"));
+    assert.ok(data.mcpServers["oris-devops"], "oris-devops seeded");
+    assert.deepEqual(
+      data.mcpServers["oris-devops"].args.slice(0, 3),
+      ["-y", "@azure-devops/mcp@2.7.0", "orislineweb"],
+    );
+
+    const second = runCli(["install", "--force", "--agents", "claude"], home);
+    assert.equal(second.status, 0, second.stderr);
+    const after = JSON.parse(fs.readFileSync(claudeConfig, "utf8"));
+    assert.equal(Object.keys(after.mcpServers).length, 1, "no duplicate server on re-install");
+  } finally {
+    fs.rmSync(home, { recursive: true, force: true });
+  }
+});

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

@@ -0,0 +1,64 @@
+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 { fileURLToPath } from "node:url";
+import { DEFAULT_DEVOPS, resolveDevops, buildMcpServer, mcpServerName } from "../flow/oris-flow-devops.mjs";
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
+
+test("default provider is Azure DevOps with the oris-devops MCP and #{id} work items", () => {
+  const d = DEFAULT_DEVOPS.devops;
+  assert.equal(d.provider, "azure-devops");
+  assert.equal(d.organization, "orislineweb");
+  assert.equal(d.workItemSyntax, "#{id}");
+  assert.equal(d.commitLanguage, "en");
+  assert.equal(d.prLanguage, "en");
+  assert.equal(mcpServerName(d), "oris-devops");
+});
+
+test("buildMcpServer produces the exact Azure DevOps command", () => {
+  const server = buildMcpServer(DEFAULT_DEVOPS.devops);
+  assert.deepEqual(server, {
+    command: "npx",
+    args: ["-y", "@azure-devops/mcp@2.7.0", "orislineweb", "-d", "core", "work", "work-items", "repositories"],
+  });
+});
+
+test("buildMcpServer honours explicit args for a non-Azure provider", () => {
+  const server = buildMcpServer({ organization: "x", mcp: { command: "node", args: ["jira-mcp.js"] } });
+  assert.deepEqual(server, { command: "node", args: ["jira-mcp.js"] });
+});
+
+test("resolution order is default -> org -> repo, each overriding the previous", () => {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), "oris-devops-home-"));
+  const repo = fs.mkdtempSync(path.join(os.tmpdir(), "oris-devops-repo-"));
+  try {
+    fs.mkdirSync(path.join(home, ".oris"), { recursive: true });
+    fs.writeFileSync(
+      path.join(home, ".oris", "devops.json"),
+      JSON.stringify({ version: 1, devops: { organization: "acme", workItemSyntax: "AB#{id}" } }),
+    );
+    fs.mkdirSync(path.join(repo, ".oris-flow"), { recursive: true });
+    fs.writeFileSync(
+      path.join(repo, ".oris-flow", "devops.json"),
+      JSON.stringify({ version: 1, devops: { workItemSyntax: "JIRA-{id}" } }),
+    );
+    const resolved = resolveDevops(repo, { home }).devops;
+    assert.equal(resolved.provider, "azure-devops", "provider inherited from default");
+    assert.equal(resolved.organization, "acme", "organization from org layer");
+    assert.equal(resolved.workItemSyntax, "JIRA-{id}", "repo layer wins over org layer");
+  } finally {
+    fs.rmSync(home, { recursive: true, force: true });
+    fs.rmSync(repo, { recursive: true, force: true });
+  }
+});
+
+test("devops schema is a versioned v1 contract", () => {
+  const schema = JSON.parse(fs.readFileSync(path.join(root, "references", "devops.schema.json"), "utf8"));
+  assert.equal(schema.$id, "https://oris.dev/schemas/oris-flow-devops-v1.json");
+  assert.equal(schema.properties.version.const, 1);
+  assert.deepEqual(schema.required, ["version", "devops"]);
+  assert.ok(schema.properties.devops.properties.provider);
+});

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

@@ -1,18 +1,16 @@
-import assert from "node:assert/strict";
+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 childProcess from "node:child_process";
-import { checkFreshness, scanRepository, writeScanResult } from "../flow/oris-flow-scan.mjs";
-import { ORIS_FLOW_MANIFEST } from "../flow/oris-flow-layout.mjs";
+import { scanRepository } from "../flow/oris-flow-scan.mjs";
 
 function write(filePath, content) {
   fs.mkdirSync(path.dirname(filePath), { recursive: true });
   fs.writeFileSync(filePath, content, "utf8");
 }
 
-test("scanner creates only evidence-backed map sections", () => {
+test("scanner reports only evidence-backed areas and writes nothing", () => {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), "oris-flow-scan-"));
   try {
     write(path.join(root, "README.md"), "# Demo\n");
@@ -20,17 +18,13 @@ test("scanner creates only evidence-backed map sections", () => {
     write(path.join(root, "src", "index.js"), "export const value = 1;\n");
 
     const scan = scanRepository(root);
-    assert.ok(scan.manifest.sections.docs);
-    assert.ok(scan.manifest.sections.stack);
-    assert.ok(scan.manifest.sections.commands);
-    assert.ok(scan.manifest.sections.code);
-    assert.equal(scan.manifest.sections.backendData, undefined);
-    assert.equal(scan.manifest["known" + "Gaps"], undefined);
+    assert.ok(scan.areas.docs);
+    assert.ok(scan.areas.code);
+    assert.ok(scan.stacks.some((stack) => stack.id === "node"));
+    assert.ok(scan.commands.some((command) => command.command === "npm run test"));
+    assert.equal(scan.areas.tests, undefined, "no test evidence → no tests area");
 
-    const written = writeScanResult(scan);
-    assert.equal(written.manifestPath, ORIS_FLOW_MANIFEST);
-    assert.ok(fs.existsSync(path.join(root, ORIS_FLOW_MANIFEST)));
-    assert.ok(fs.existsSync(path.join(root, ".oris-flow", "maps", "stack.md")));
+    assert.equal(fs.existsSync(path.join(root, ".oris-flow")), false, "scan never writes");
   } finally {
     fs.rmSync(root, { recursive: true, force: true });
   }
@@ -41,8 +35,9 @@ test("scanner supports documentation-only repositories", () => {
   try {
     write(path.join(root, "docs", "guide.md"), "# Guide\n");
     const scan = scanRepository(root);
-    assert.deepEqual(Object.keys(scan.manifest.sections), ["docs"]);
+    assert.deepEqual(Object.keys(scan.areas), ["docs"]);
     assert.deepEqual(scan.stacks, []);
+    assert.deepEqual(scan.commands, []);
   } finally {
     fs.rmSync(root, { recursive: true, force: true });
   }
@@ -61,96 +56,31 @@ test("scanner detects project type and derives inferred stack commands", () => {
     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", () => {
+test("scanner flags truncation instead of silently under-reporting", () => {
   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);
+    for (let index = 0; index < 12; index += 1) {
+      write(path.join(root, "src", `file-${index}.js`), "export {};\n");
+    }
+    const scan = scanRepository(root, { maxFiles: 5 });
+    assert.equal(scan.truncated, true);
+    assert.ok(scan.fileCount <= 5);
   } 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 });
-  }
-});
-
-
-test("scan anchors the map to HEAD; --check answers freshness from the SHA + changed files", () => {
+test("empty repository classifies as empty", () => {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), "oris-flow-scan-"));
-  const git = (...args) => childProcess.execFileSync("git", args, { cwd: root, encoding: "utf8" });
   try {
-    write(path.join(root, "README.md"), "# Demo\n");
-    write(path.join(root, "package.json"), `${JSON.stringify({ scripts: { test: "node --test" } })}\n`);
-    git("init", "-q");
-    git("-c", "user.email=t@t", "-c", "user.name=t", "add", ".");
-    git("-c", "user.email=t@t", "-c", "user.name=t", "commit", "-q", "-m", "init");
-
-    const scan = scanRepository(root);
-    assert.equal(typeof scan.manifest.headSha, "string", "scan records the HEAD anchor");
-    writeScanResult(scan);
-
-    const fresh = checkFreshness(root);
-    assert.equal(fresh.fresh, true, "same SHA + clean tree → fresh, zero reads");
-    assert.deepEqual(fresh.changedFiles, []);
-
-    write(path.join(root, "src", "new.js"), "export const later = 1;\n");
-    const stale = checkFreshness(root);
-    assert.equal(stale.fresh, false, "working-tree change → stale");
-    assert.ok(stale.changedFiles.some((file) => file.includes("new.js")), "changed files name the delta");
-  } finally {
-    fs.rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("outside git the map still works — no anchor, never an error", () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), "oris-flow-scan-"));
-  try {
-    write(path.join(root, "README.md"), "# Demo\n");
     const scan = scanRepository(root);
-    assert.equal(scan.manifest.headSha, null);
-    writeScanResult(scan);
-    const check = checkFreshness(root);
-    assert.equal(check.fresh, false, "no anchor → refresh advised, not an error");
+    assert.equal(scan.projectType.id, "empty");
+    assert.deepEqual(scan.areas, {});
   } finally {
     fs.rmSync(root, { recursive: true, force: true });
   }