oris-skills 2.2.2 → 3.0.1

package/references/settings.md

@@ -1,24 +1,30 @@
 # Oris Settings
 
-Per-project preferences. Path: `.oris-flow/settings.json`. Small and non-secret —
-chat verbosity and document language, nothing else. Missing file → defaults below.
-Created/edited via `/oris-flow` → Setup, or by hand.
+Per-project preferences. Path: `.oris-flow/settings.json`. Small and non-secret.
+Missing file → defaults below. Created/edited via `/oris-flow` → Setup, or by hand.
 
 ## Shape (v1)
 
 ```json
 {
   "version": 1,
-  "orisFlow": { "responseStyle": "standard", "artifactLanguage": "en" }
+  "orisFlow": {
+    "responseStyle": "standard",
+    "artifactLanguage": "en",
+    "tasksRoot": ".oris-flow/tasks",
+    "versionControl": "commit"
+  }
 }
 ```
 
 - `responseStyle` → chat verbosity (`standard` | `caveman`, default `standard`). Caveman = maximum token density in chat; contract in `references/conventions.md` `## Response style`. Documents and gates are never compressed.
 - `artifactLanguage` → language for generated documents (ISO code, default `en`). Chat/UI language is NOT configured here — it is deduced from the conversation.
+- `tasksRoot` → where task documents live (default `.oris-flow/tasks`; legacy `docs/tasks` supported when a team already treats task docs as project docs).
+- `versionControl` → whether `.oris-flow/` is committed (`commit`, team default) or ignored (`gitignore`, personal). Applied via `npx oris-skills flow version-control --mode <choice>`.
 
 ## Rules
 
 1. READ settings before the first workflow decision; missing/invalid → defaults above.
 2. Current user instructions override settings for the turn.
-3. Oris stores no credentials. Test/CI secrets belong to each project's own tooling — never Oris files, docs, loop state, receipts, or logs.
+3. Oris stores no credentials. Test/CI secrets belong to each project's own tooling — never Oris files, docs, or logs.
 4. CONFIRM before writing settings. Update via `/oris-flow` → Setup.

package/references/settings.schema.json

@@ -23,6 +23,16 @@
           "type": "string",
           "minLength": 2,
           "description": "Language for generated documents (ISO code, e.g. en, it). Default en. Chat language is deduced from the conversation, not configured here."
+        },
+        "tasksRoot": {
+          "type": "string",
+          "minLength": 1,
+          "description": "Repository-relative root for task documents. Default .oris-flow/tasks; legacy docs/tasks supported."
+        },
+        "versionControl": {
+          "type": "string",
+          "enum": ["commit", "gitignore"],
+          "description": "Whether .oris-flow/ is committed (team default) or gitignored (personal). Default commit."
         }
       }
     }

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

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+/**
+ * Built-in Oris default DevOps provider. Non-secret only — org and repo layers override it.
+ * The provider is swappable: move off Azure DevOps by overriding `provider` and `mcp`.
+ */
+export const DEFAULT_DEVOPS = {
+  version: 1,
+  devops: {
+    provider: "azure-devops",
+    organization: "orislineweb",
+    workItemSyntax: "#{id}",
+    commitLanguage: "en",
+    prLanguage: "en",
+    mcp: {
+      name: "oris-devops",
+      package: "@azure-devops/mcp@2.7.0",
+      domains: ["core", "work", "work-items", "repositories"],
+    },
+  },
+};
+
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+/** Deep-merge source over target; arrays and scalars replace, plain objects merge. */
+function deepMerge(target, source) {
+  if (!isPlainObject(source)) return source;
+  const out = isPlainObject(target) ? { ...target } : {};
+  for (const [key, value] of Object.entries(source)) {
+    out[key] = isPlainObject(value) ? deepMerge(out[key], value) : value;
+  }
+  return out;
+}
+
+function readJson(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Resolve the effective DevOps config: built-in default → org (`~/.oris/devops.json`) →
+ * repository (`.oris-flow/devops.json`). Missing or invalid layers are skipped, never fatal.
+ */
+export function resolveDevops(repositoryRoot, options = {}) {
+  const home = options.home ?? os.homedir();
+  const orgFile = readJson(path.join(home, ".oris", "devops.json"));
+  const repoFile = repositoryRoot ? readJson(path.join(repositoryRoot, ".oris-flow", "devops.json")) : null;
+  let resolved = DEFAULT_DEVOPS;
+  for (const layer of [orgFile, repoFile]) {
+    if (isPlainObject(layer)) resolved = deepMerge(resolved, layer);
+  }
+  return resolved;
+}
+
+/**
+ * Build the MCP server entry for an agent config from a resolved `devops` block. Azure
+ * DevOps command shape by default; any provider can supply explicit `mcp.args` instead.
+ */
+export function buildMcpServer(devops) {
+  const mcp = devops.mcp ?? {};
+  if (Array.isArray(mcp.args)) return { command: mcp.command ?? "npx", args: [...mcp.args] };
+  const domains = Array.isArray(mcp.domains) ? mcp.domains : [];
+  return { command: "npx", args: ["-y", mcp.package, devops.organization, "-d", ...domains] };
+}
+
+export function mcpServerName(devops) {
+  return devops.mcp?.name ?? "oris-devops";
+}

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

@@ -22,6 +22,8 @@ import os from "node:os";
 import path from "node:path";
 import process from "node:process";
 import { fileURLToPath } from "node:url";
+import { buildMcpServer, mcpServerName, resolveDevops } from "../flow/oris-flow-devops.mjs";
+import { MCP_AGENTS, seedMcpServer } from "./oris-mcp.mjs";
 
 const markerName = ".oris-skills-managed.json";
 const installManifestName = ".oris-skills-install.json";
@@ -61,6 +63,7 @@ function parseArgs(argv) {
   const options = {
     dryRun: false,
     force: false,
+    noMcp: false,
     agents: [],
     bundleRoot: paths.bundleRoot,
     agentRoots: paths.agentRoots,
@@ -76,6 +79,7 @@ function parseArgs(argv) {
     };
     if (key === "--dry-run") options.dryRun = true;
     else if (key === "--force") options.force = true;
+    else if (key === "--no-mcp") options.noMcp = true;
     else if (key === "--agents" || key.startsWith("--agents=")) {
       options.agents = value().split(",").map((name) => name.trim().toLowerCase()).filter(Boolean);
     } else if (key === "--bundle-root" || key.startsWith("--bundle-root=")) options.bundleRoot = value();
@@ -246,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");
 }
 
@@ -256,6 +260,10 @@ function main() {
   const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
   const manifest = readJson(path.join(repoRoot, ".cursor-plugin", "plugin.json"));
   const skills = manifestSkills(manifest, repoRoot);
+  const devops = resolveDevops(null).devops;
+  const mcpServer = buildMcpServer(devops);
+  const mcpName = mcpServerName(devops);
+  const mcpAgents = options.noMcp ? [] : (options.agents.length > 0 ? options.agents : detectAgents(options.agentRoots)).filter((agent) => MCP_AGENTS.includes(agent));
   const agents = options.agents.length > 0 ? options.agents : detectAgents(options.agentRoots);
   if (agents.length === 0) {
     fail("No agent detected (~/.cursor, ~/.claude, ~/.codex). Pass --agents cursor,claude,codex explicitly.");
@@ -273,6 +281,7 @@ function main() {
       else log(`Would write ${agent} skills: ${path.join(options.agentRoots[agent], "skills")}`);
     }
     log(`Would write universal pointer: ${path.join(path.dirname(options.bundleRoot), "oris-flow.md")}`);
+    if (mcpAgents.length > 0) log(`Would seed MCP server '${mcpName}' for: ${mcpAgents.join(", ")}`);
     return;
   }
 
@@ -282,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));
   }
@@ -301,6 +310,11 @@ function main() {
   }
   installUniversalPointer(skills, options.bundleRoot);
 
+  for (const agent of mcpAgents) {
+    const result = seedMcpServer(agent, options.agentRoots, mcpName, mcpServer, { force: options.force });
+    log(`MCP ${mcpName} for ${agent}: ${result.status}`);
+  }
+
   writeJson(path.join(options.bundleRoot, installManifestName), {
     package: manifest.name,
     version: manifest.version,
@@ -309,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 {