oris-skills 2.2.3 → 3.0.2

package/scripts/flow/oris-flow-layout.mjs

@@ -2,31 +2,15 @@ import os from "node:os";
 import path from "node:path";
 
 export const ORIS_FLOW_ROOT = ".oris-flow";
-export const ORIS_FLOW_MANIFEST = ".oris-flow/manifest.json";
-export const ORIS_FLOW_MAPS_ROOT = ".oris-flow/maps";
 export const ORIS_FLOW_TASKS_ROOT = ".oris-flow/tasks";
-export const ORIS_FLOW_ADAPTER = ".oris-flow/adapter.json";
-export const ORIS_FLOW_LOOPS_ROOT = ".oris-flow/loops";
-export const ORIS_FLOW_RUNTIME = ".oris-flow/runtime";
 export const ORIS_FLOW_SETTINGS = ".oris-flow/settings.json";
 export const ORIS_HOME = path.join(os.homedir(), ".oris");
 export const ORIS_BUNDLE_ROOT = path.join(ORIS_HOME, "oris-skills");
-export const ORIS_LOOP_SCHEMA = "https://oris.dev/schemas/oris-loop-adapter-v1.json";
-export const ORIS_LOOP_SCHEMA_VERSION = 1;
-export const ORIS_LOOP_DOCUMENT_VERSION = 2;
-export const ORIS_FLOW_MAP_SCHEMA = "https://oris.dev/schemas/oris-flow-map-v1.json";
-export const ORIS_FLOW_MAP_SCHEMA_VERSION = 1;
 
 export function toPosixPath(value) {
   return String(value).replace(/\\/g, "/");
 }
 
-export function safeSlug(value, fallback = "loop") {
-  const raw = path.basename(toPosixPath(value || fallback));
-  const slug = raw.replace(/[^A-Za-z0-9_.-]/g, "-").replace(/^-+|-+$/g, "");
-  return slug || fallback;
-}
-
 export function assertRepositoryRelative(value, label) {
   const normalized = toPosixPath(value ?? "");
   if (!normalized || normalized.startsWith("/") || /^[A-Za-z]:\//.test(normalized)) {

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

@@ -1,20 +1,16 @@
 #!/usr/bin/env node
 
-import childProcess from "node:child_process";
+/**
+ * One-shot repository detector for the setup route. Reports evidence — project
+ * type, stacks, commands, notable areas — and writes NOTHING. Durable facts the
+ * user confirms belong in AGENTS.md; preferences belong in .oris-flow/settings.json.
+ */
+
 import fs from "node:fs";
 import path from "node:path";
 import process from "node:process";
 import { fileURLToPath } from "node:url";
-import {
-  ORIS_FLOW_MANIFEST,
-  ORIS_FLOW_MAP_SCHEMA,
-  ORIS_FLOW_MAP_SCHEMA_VERSION,
-  ORIS_FLOW_MAPS_ROOT,
-  ORIS_FLOW_TASKS_ROOT,
-  relativeToRepository,
-  resolveInsideRepository,
-  toPosixPath,
-} from "./oris-flow-layout.mjs";
+import { relativeToRepository, toPosixPath } from "./oris-flow-layout.mjs";
 
 const ignoredDirectories = new Set([
   ".oris-flow",
@@ -64,74 +60,10 @@ function fail(message) {
   process.exit(1);
 }
 
-function git(root, args) {
-  try {
-    const output = childProcess.execFileSync("git", args, { cwd: root, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
-    return output.trim();
-  } catch {
-    return null;
-  }
-}
-
-/** Commit SHA the scan anchors to; null outside git (the anchor is then unavailable, never an error). */
-export function gitHeadSha(root) {
-  return git(root, ["rev-parse", "HEAD"]);
-}
-
-/**
- * Files changed since the anchored SHA: committed delta + working-tree changes,
- * deduped. The map's own files (.oris-flow/**) never count — they describe the
- * code, they are not the code.
- */
-export function gitChangedFiles(root, sinceSha) {
-  const diff = git(root, ["diff", "--name-only", `${sinceSha}..HEAD`]);
-  const status = git(root, ["status", "--porcelain", "-uall"]);
-  if (diff === null && status === null) return null;
-  const changed = new Set();
-  const add = (file) => {
-    const clean = file.replace(/^"|"$/g, "");
-    if (clean && !clean.startsWith(".oris-flow/")) changed.add(clean);
-  };
-  for (const line of (diff ?? "").split(/\r?\n/)) if (line.trim()) add(line.trim());
-  for (const line of (status ?? "").split(/\r?\n/)) {
-    const file = line.slice(3).trim();
-    if (file) add(file.includes(" -> ") ? file.split(" -> ")[1] : file);
-  }
-  return [...changed].sort();
-}
-
-/**
- * Freshness in one cheap call (the delta-scan anchor): compare the manifest's
- * headSha with the current HEAD. Equal and clean → fresh, zero reads. Moved →
- * the changed file list tells the caller which map areas to refresh in place.
- */
-export function checkFreshness(repositoryRoot) {
-  const root = path.resolve(repositoryRoot);
-  const manifest = readJson(path.join(root, ...ORIS_FLOW_MANIFEST.split("/")));
-  if (!manifest) return { manifest: false, fresh: false, reason: "no manifest — run a full scan" };
-  const headSha = gitHeadSha(root);
-  const scannedSha = manifest.headSha ?? null;
-  if (!headSha || !scannedSha) {
-    return { manifest: true, fresh: false, reason: "no SHA anchor — refresh writes one", headSha, scannedSha, changedFiles: null };
-  }
-  const changedFiles = gitChangedFiles(root, scannedSha) ?? [];
-  const fresh = headSha === scannedSha && changedFiles.length === 0;
-  return {
-    manifest: true,
-    fresh,
-    headSha,
-    scannedSha,
-    changedFiles: fresh ? [] : changedFiles.slice(0, 200),
-    sections: Object.keys(manifest.sections ?? {}),
-  };
-}
-
 function parseArgs(argv) {
   const options = {
     repositoryRoot: process.cwd(),
-    write: false,
     json: false,
-    area: "",
   };
   const readValue = (index, raw) => {
     if (raw.includes("=")) return [index, raw.slice(raw.indexOf("=") + 1)];
@@ -142,10 +74,7 @@ function parseArgs(argv) {
     const raw = argv[i];
     const key = raw.toLowerCase();
     if (key === "--repository-root" || key.startsWith("--repository-root=")) [i, options.repositoryRoot] = readValue(i, raw);
-    else if (key === "--write") options.write = true;
     else if (key === "--json") options.json = true;
-    else if (key === "--area" || key.startsWith("--area=")) [i, options.area] = readValue(i, raw);
-    else if (key === "--check") options.check = true;
     else fail(`Unknown argument: ${raw}`);
   }
   return options;
@@ -309,274 +238,60 @@ function deriveStackCommands(stacks, files) {
   return commands;
 }
 
-function hasAny(files, predicate) {
-  return files.some(predicate);
-}
+/** Notable areas the setup interview walks through — evidence pointers, never a stored map. */
+function detectAreas(files) {
+  const paths = files.map((file) => file.relative);
+  const areas = {};
 
-function makeSection(pathValue, summary, details) {
-  return {
-    pointer: {
-      path: pathValue,
-      confidence: details.confidence ?? "detected",
-      lastScannedAt: details.scannedAt,
-      stale: false,
-      summary,
-    },
-    markdown: details.markdown,
-  };
-}
-
-function buildSections(root, files, stacks, commands, scannedAt) {
-  const sections = {};
-  const topFiles = files.map((file) => file.relative);
+  const docs = paths.filter((file) => /(^|\/)(README|CONTEXT|CHANGELOG|CONTRIBUTING|AGENTS|CLAUDE)\.md$/i.test(file) || file.startsWith("docs/")).slice(0, 20);
+  if (docs.length > 0) areas.docs = docs;
 
-  if (hasAny(files, (file) => /(^|\/)(README|CONTEXT|CHANGELOG|CONTRIBUTING|AGENTS|CLAUDE)\.md$/i.test(file.relative) || file.relative.startsWith("docs/"))) {
-    const docs = topFiles.filter((file) => /(^|\/)(README|CONTEXT|CHANGELOG|CONTRIBUTING|AGENTS|CLAUDE)\.md$/i.test(file) || file.startsWith("docs/")).slice(0, 20);
-    sections.docs = makeSection(".oris-flow/maps/docs.md", "Documentation and task context detected.", {
-      scannedAt,
-      markdown: [
-        "# Docs",
-        "",
-        "Detected documentation paths:",
-        ...docs.map((file) => `- ${file}`),
-        "",
-      ].join("\n"),
-    });
-  }
-
-  const guidancePaths = topFiles.filter((file) =>
+  const agentGuidance = paths.filter((file) =>
     file.startsWith(".cursor/skills/") || file.startsWith(".cursor/rules/")
     || file.startsWith(".claude/skills/") || /^AGENTS\.md$/i.test(file) || /^CLAUDE\.md$/i.test(file)
     || /^CONTEXT\.md$/i.test(file) || file.startsWith("docs/adr/")).slice(0, 20);
-  if (guidancePaths.length > 0) {
-    sections.agentGuidance = makeSection(".oris-flow/maps/agent-guidance.md", "Agent guidance detected (AGENTS/CLAUDE/CONTEXT, skills, rules, ADRs).", {
-      scannedAt,
-      markdown: [
-        "# Agent Guidance",
-        "",
-        "Detected agent-facing guidance:",
-        ...guidancePaths.map((file) => `- ${file}`),
-        "",
-      ].join("\n"),
-    });
-  }
+  if (agentGuidance.length > 0) areas.agentGuidance = agentGuidance;
 
-  if (stacks.length > 0) {
-    sections.stack = makeSection(".oris-flow/maps/stack.md", `Detected ${stacks.length} stack signal(s).`, {
-      scannedAt,
-      markdown: [
-        "# Stack",
-        "",
-        ...stacks.flatMap((stack) => [
-          `## ${stack.label}`,
-          "",
-          ...stack.evidence.map((file) => `- ${file}`),
-          "",
-        ]),
-      ].join("\n"),
-    });
-  }
+  const code = [...new Set(paths
+    .filter((file) => /(^|\/)(src|app|apps|packages)\//.test(file))
+    .map((file) => file.split("/").slice(0, 2).join("/")))]
+    .slice(0, 20);
+  if (code.length > 0) areas.code = code;
 
-  if (commands.length > 0) {
-    sections.commands = makeSection(".oris-flow/maps/commands.md", `Detected ${commands.length} command(s).`, {
-      scannedAt,
-      markdown: [
-        "# Commands",
-        "",
-        ...commands.map((command) => `- \`${command.command}\` (${command.evidence || command.confidence}${command.confidence === "inferred" ? ", inferred — confirm before relying on it" : ""})`),
-        "",
-      ].join("\n"),
-    });
-  }
-
-  if (hasAny(files, (file) => /(^|\/)(src|app|apps|packages)\//.test(file.relative))) {
-    const codeRoots = [...new Set(topFiles
-      .filter((file) => /(^|\/)(src|app|apps|packages)\//.test(file))
-      .map((file) => file.split("/").slice(0, 2).join("/")))]
-      .slice(0, 20);
-    sections.code = makeSection(".oris-flow/maps/code.md", "Source code areas detected.", {
-      scannedAt,
-      markdown: [
-        "# Code",
-        "",
-        "Detected source areas:",
-        ...codeRoots.map((file) => `- ${file}`),
-        "",
-      ].join("\n"),
-    });
-  }
-
-  if (hasAny(files, (file) => /(^|\/)(test|tests|spec|specs|e2e)(\/|$)|\.(test|spec)\.[jt]sx?$/i.test(file.relative))) {
-    const tests = topFiles.filter((file) => /(^|\/)(test|tests|spec|specs|e2e)(\/|$)|\.(test|spec)\.[jt]sx?$/i.test(file)).slice(0, 20);
-    sections.tests = makeSection(".oris-flow/maps/tests.md", "Test assets detected.", {
-      scannedAt,
-      markdown: [
-        "# Tests",
-        "",
-        "Detected test paths:",
-        ...tests.map((file) => `- ${file}`),
-        "",
-      ].join("\n"),
-    });
-  }
+  const tests = paths.filter((file) => /(^|\/)(test|tests|spec|specs|e2e)(\/|$)|\.(test|spec)\.[jt]sx?$/i.test(file)).slice(0, 20);
+  if (tests.length > 0) areas.tests = tests;
 
-  return sections;
-}
-
-function resolveTasksRoot(root, existingManifest) {
-  const configured = existingManifest?.setup?.tasksRoot;
-  if (typeof configured === "string" && configured.length > 0) return configured;
-  const legacy = path.join(root, "docs", "tasks");
-  if (fs.existsSync(legacy) && fs.readdirSync(legacy).length > 0) return "docs/tasks";
-  return ORIS_FLOW_TASKS_ROOT;
-}
-
-/**
- * Refresh keeps user truth: confirmed decisions, tasksRoot, version control,
- * confirmed commands, and confirmed sections (whose map files are also left
- * untouched). A confirmed section the scan no longer sees is marked stale,
- * never deleted.
- */
-function mergeWithExisting(scan, existingManifest) {
-  if (!existingManifest || typeof existingManifest !== "object") return scan;
-  const merged = scan;
-  merged.manifest.generatedAt = existingManifest.generatedAt ?? merged.manifest.generatedAt;
-  if (Array.isArray(existingManifest.setup?.confirmedDecisions)) {
-    merged.manifest.setup.confirmedDecisions = existingManifest.setup.confirmedDecisions;
-  }
-  if (existingManifest.setup?.versionControl?.orisFlowMap) {
-    merged.manifest.setup.versionControl.orisFlowMap = existingManifest.setup.versionControl.orisFlowMap;
-  }
-  if (existingManifest.projectType?.confidence === "confirmed") {
-    merged.manifest.projectType = existingManifest.projectType;
-  }
-
-  const confirmedCommands = (existingManifest.commands ?? []).filter((command) => command?.confidence === "confirmed");
-  if (confirmedCommands.length > 0) {
-    const scanned = merged.manifest.commands.filter((command) =>
-      !confirmedCommands.some((confirmed) => confirmed.name === command.name && confirmed.cwd === command.cwd));
-    merged.manifest.commands = [...confirmedCommands, ...scanned];
-    merged.commands = merged.manifest.commands;
-  }
-
-  merged.preservedSections = new Set();
-  for (const [key, pointer] of Object.entries(existingManifest.sections ?? {})) {
-    if (pointer?.confidence !== "confirmed") continue;
-    const rescanned = merged.manifest.sections[key];
-    merged.manifest.sections[key] = {
-      ...pointer,
-      stale: rescanned ? pointer.stale === true : true,
-    };
-    merged.preservedSections.add(key);
-    if (merged.sections[key]) delete merged.sections[key];
-  }
-  return merged;
+  return areas;
 }
 
 export function scanRepository(repositoryRoot, options = {}) {
   const root = path.resolve(repositoryRoot);
-  const scannedAt = new Date().toISOString();
-  const headSha = gitHeadSha(root);
-  const existingManifest = readJson(path.join(root, ...ORIS_FLOW_MANIFEST.split("/")));
   const { files, truncated } = walk(root, options);
   const stacks = detectStacks(files);
-  const projectType = detectProjectType(files, stacks);
-  const commands = [...findPackageCommands(files), ...deriveStackCommands(stacks, files)];
-  const sections = buildSections(root, files, stacks, commands, scannedAt);
-  const sectionPointers = Object.fromEntries(
-    Object.entries(sections).map(([key, value]) => [key, value.pointer]),
-  );
-  const manifest = {
-    $schema: ORIS_FLOW_MAP_SCHEMA,
-    schemaVersion: ORIS_FLOW_MAP_SCHEMA_VERSION,
-    repository: path.basename(root),
-    generatedAt: scannedAt,
-    updatedAt: scannedAt,
-    headSha,
-    projectType,
-    truncated,
-    setup: {
-      mode: options.mode ?? (existingManifest ? "refresh" : "create"),
-      scanDepth: options.scanDepth ?? "balanced",
-      tasksRoot: options.tasksRoot ?? resolveTasksRoot(root, existingManifest),
-      confirmedDecisions: [],
-      versionControl: {
-        orisFlowMap: options.versionControl ?? "commit",
-      },
-    },
-    stacks,
-    commands,
-    sections: sectionPointers,
-  };
-  const scan = {
+  return {
     repositoryRoot: root,
-    scannedAt,
+    scannedAt: new Date().toISOString(),
     fileCount: files.length,
     truncated,
-    projectType,
+    projectType: detectProjectType(files, stacks),
     stacks,
-    commands,
-    sections,
-    manifest,
-    preservedSections: new Set(),
-  };
-  return mergeWithExisting(scan, existingManifest);
-}
-
-export function writeScanResult(scan, options = {}) {
-  const root = scan.repositoryRoot;
-  const area = options.area ?? "";
-  const manifestPath = resolveInsideRepository(root, ORIS_FLOW_MANIFEST, "Oris Flow manifest");
-  fs.mkdirSync(path.dirname(manifestPath), { recursive: true });
-  fs.writeFileSync(manifestPath, `${JSON.stringify(scan.manifest, null, 2)}\n`, "utf8");
-
-  const written = [];
-  for (const [key, section] of Object.entries(scan.sections)) {
-    if (area && key !== area) continue;
-    const sectionPath = resolveInsideRepository(root, section.pointer.path, "Oris Flow section");
-    fs.mkdirSync(path.dirname(sectionPath), { recursive: true });
-    fs.writeFileSync(sectionPath, section.markdown, "utf8");
-    written.push(section.pointer.path);
-  }
-
-  const readmePath = resolveInsideRepository(root, `${ORIS_FLOW_MAPS_ROOT}/README.md`, "Oris Flow map README");
-  if (!fs.existsSync(readmePath)) {
-    fs.mkdirSync(path.dirname(readmePath), { recursive: true });
-    fs.writeFileSync(readmePath, "# Oris Flow Maps\n\nGenerated by `oris-flow-scan.mjs`. Sections are present only when repository evidence supports them.\n", "utf8");
-  }
-  return {
-    manifestPath: relativeToRepository(root, manifestPath),
-    sectionPaths: written,
-    preservedSections: [...(scan.preservedSections ?? [])],
+    commands: [...findPackageCommands(files), ...deriveStackCommands(stacks, files)],
+    areas: detectAreas(files),
   };
 }
 
 if (process.argv[1] && path.resolve(process.argv[1]) === path.resolve(fileURLToPath(import.meta.url))) {
   const options = parseArgs(process.argv.slice(2));
-  if (options.check) {
-    console.log(JSON.stringify(checkFreshness(options.repositoryRoot), null, 2));
-    process.exit(0);
-  }
   const scan = scanRepository(options.repositoryRoot, options);
-  const written = options.write ? writeScanResult(scan, { area: options.area }) : null;
-  const payload = {
-    repositoryRoot: toPosixPath(scan.repositoryRoot),
-    fileCount: scan.fileCount,
-    truncated: scan.truncated,
-    projectType: scan.projectType,
-    tasksRoot: scan.manifest.setup.tasksRoot,
-    stacks: scan.stacks,
-    commands: scan.commands,
-    sections: scan.manifest.sections,
-    written,
-  };
-  if (options.json || options.write) {
+  const payload = { ...scan, repositoryRoot: toPosixPath(scan.repositoryRoot) };
+  if (options.json) {
     console.log(JSON.stringify(payload, null, 2));
   } else {
     console.log(`Oris Flow scan: ${payload.repositoryRoot}`);
     console.log(`Files scanned: ${payload.fileCount}${payload.truncated ? " (truncated)" : ""}`);
     console.log(`Project type: ${payload.projectType.label}`);
     console.log(`Stacks: ${payload.stacks.map((stack) => stack.label).join(", ") || "none"}`);
-    console.log(`Sections: ${Object.keys(payload.sections).join(", ") || "none"}`);
+    console.log(`Commands: ${payload.commands.map((command) => command.command).join(", ") || "none"}`);
+    console.log(`Areas: ${Object.keys(payload.areas).join(", ") || "none"}`);
   }
 }

package/scripts/flow/oris-gitignore.mjs

@@ -2,13 +2,9 @@ import fs from "node:fs";
 import path from "node:path";
 
 export const ORIS_FLOW_GITIGNORE_ENTRIES = [
-  ".oris-flow/manifest.json",
-  ".oris-flow/maps/",
+  ".oris-flow/",
 ];
 
-export const ORIS_FLOW_RUNTIME_GITIGNORE_ENTRY = ".oris-flow/runtime/";
-export const ORIS_LOOP_GITIGNORE_ENTRY = ORIS_FLOW_RUNTIME_GITIGNORE_ENTRY;
-
 function normalizeGitignoreLines(text) {
   return text.replace(/\r\n/g, "\n").split("\n");
 }

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

@@ -250,7 +250,7 @@ Tell any agent that can read files:
 > Read \`${bundledSkill}\` and follow it exactly.
 
 That file routes every Oris flow (setup, discover, criteria, plan, implement, fix,
-verify, change, loop, architecture, docs, help) in the same chat.
+verify, change, architecture, docs, help) in the same chat.
 `, "utf8");
 }
 
@@ -291,7 +291,7 @@ function main() {
 
   fs.rmSync(options.bundleRoot, { recursive: true, force: true });
   fs.mkdirSync(options.bundleRoot, { recursive: true });
-  for (const item of [".cursor-plugin", "skills", "references", "agents", "scripts", "docs", "package.json", "README.md", "LICENSE"]) {
+  for (const item of [".cursor-plugin", "skills", "references", "scripts", "docs", "package.json", "README.md", "LICENSE"]) {
     const source = path.join(repoRoot, item);
     if (fs.existsSync(source)) copy(source, path.join(options.bundleRoot, item));
   }
@@ -323,7 +323,7 @@ function main() {
     installedAt: new Date().toISOString(),
   });
   log(`Done for agents: ${agents.join(", ")}. Reload your agent environment.`);
-  log("Next: type /oris-flow in your agent chat, or try the loop demo: npx oris-skills loop demo");
+  log("Next: type /oris-flow in your agent chat.");
 }
 
 try {

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,21 +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",
 ];