@bcelep/capint 0.4.2 → 0.7.0

package/src/lib/scaffold/presets.js

@@ -2,8 +2,50 @@ const fs = require("fs");
 const path = require("path");
 const { applyFilePolicy } = require("./file-policy");
 
+const CORE_SKILL_NAMES = ["capability-router", "prismx-skill-gateway", "task-skill-router"];
+
+/** CI / lightweight init — matrix task types still resolve when skills present */
+const MINIMAL_BUNDLE_SKILLS = [
+  "capability-router",
+  "context-memory-bridge",
+  "localization-hub",
+  "refactor",
+  "systematic-debugging"
+];
+
+const MINIMAL_BUNDLE_WORKFLOWS = ["forge.md"];
+
+const BUNDLE_MODES = new Set(["full", "minimal"]);
+
+const TEXT_EXTENSIONS = new Set([
+  ".md",
+  ".json",
+  ".yaml",
+  ".yml",
+  ".txt",
+  ".js",
+  ".mjs",
+  ".cjs",
+  ".ts",
+  ".tsx",
+  ".jsx",
+  ".css",
+  ".html",
+  ".htm",
+  ".svg",
+  ".xml",
+  ".toml",
+  ".sh",
+  ".ps1",
+  ".csv"
+]);
+
+function pkgRoot() {
+  return path.join(__dirname, "..", "..", "..");
+}
+
 function loadTemplate(name) {
-  const tplDir = path.join(__dirname, "..", "..", "..", "templates", name);
+  const tplDir = path.join(pkgRoot(), "templates", name);
   const files = {};
   if (!fs.existsSync(tplDir)) return files;
   for (const rel of walk(tplDir)) {
@@ -31,38 +73,108 @@ function interpolate(content, vars) {
   return out;
 }
 
-function deriveRegistryFromMatrix(matrix) {
-  const core = new Set(["capability-router"]);
+function listPackageSkillNames(root = pkgRoot()) {
+  const skillsDir = path.join(root, "skills");
+  if (!fs.existsSync(skillsDir)) return [];
+  return fs
+    .readdirSync(skillsDir)
+    .filter((name) => fs.existsSync(path.join(skillsDir, name, "SKILL.md")))
+    .sort();
+}
+
+function isTextBundleFile(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  return !ext || TEXT_EXTENSIONS.has(ext);
+}
+
+function copyBinaryBundleFile({ rootDir, relativePath, srcAbs, force }) {
+  const abs = path.join(rootDir, relativePath);
+  const dir = path.dirname(abs);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+
+  if (!fs.existsSync(abs)) {
+    fs.copyFileSync(srcAbs, abs);
+    return { path: relativePath, action: "created" };
+  }
+
+  if (force) {
+    fs.copyFileSync(srcAbs, abs);
+    return { path: relativePath, action: "updated", mode: "force" };
+  }
+
+  const existing = fs.readFileSync(abs);
+  const incoming = fs.readFileSync(srcAbs);
+  if (existing.equals(incoming)) {
+    return { path: relativePath, action: "skipped", reason: "identical" };
+  }
+
+  const sidecar = `${relativePath}.capint.new`;
+  fs.copyFileSync(srcAbs, path.join(rootDir, sidecar));
+  return { path: relativePath, action: "conflict", sidecar };
+}
+
+function listProjectSkillNames(rootDir) {
+  return listPackageSkillNames(rootDir);
+}
+
+function resolveBundleSkillNames(bundle, packageRoot = pkgRoot()) {
+  if (bundle === "minimal") {
+    return MINIMAL_BUNDLE_SKILLS.filter((name) =>
+      fs.existsSync(path.join(packageRoot, "skills", name, "SKILL.md"))
+    );
+  }
+  return listPackageSkillNames(packageRoot);
+}
+
+function normalizeBundleMode(mode) {
+  const m = (mode || "full").toLowerCase();
+  if (!BUNDLE_MODES.has(m)) return null;
+  return m;
+}
+
+function deriveRegistryFromMatrix(matrix, packageRoot = pkgRoot(), options = {}) {
+  const onDisk = new Set(options.skillNames || listPackageSkillNames(packageRoot));
+  const core = new Set();
   const recommended = new Set();
 
+  for (const name of CORE_SKILL_NAMES) {
+    if (onDisk.has(name)) core.add(name);
+  }
+  if (!core.size) core.add("capability-router");
+
   for (const tt of matrix?.task_types || []) {
     for (const s of tt.skills || []) {
-      if (s === "capability-router") core.add(s);
-      else recommended.add(s);
+      if (core.has(s)) continue;
+      if (onDisk.has(s)) recommended.add(s);
     }
   }
   for (const meta of Object.values(matrix?.rules_domain_map || {})) {
     for (const s of meta.skills || []) {
-      if (s === "capability-router") core.add(s);
-      else recommended.add(s);
+      if (core.has(s)) continue;
+      if (onDisk.has(s)) recommended.add(s);
     }
   }
-  recommended.delete("capability-router");
+
+  for (const name of core) recommended.delete(name);
+
+  const optional = [...onDisk].filter((name) => !core.has(name) && !recommended.has(name));
 
   return {
-    schema_version: "1.0",
+    schema_version: "1.1",
     core: [...core].sort(),
     recommended: [...recommended].sort(),
-    optional: [],
+    optional,
     project_added: []
   };
 }
 
-function getPresetFiles(preset, vars = {}) {
-  const pkgRoot = path.join(__dirname, "..", "..", "..");
-  const matrixRaw = fs.readFileSync(path.join(pkgRoot, "skill-routing-matrix.json"), "utf-8");
+function getPresetFiles(preset, vars = {}, options = {}) {
+  const root = pkgRoot();
+  const bundle = normalizeBundleMode(options.bundle) || "full";
+  const matrixRaw = fs.readFileSync(path.join(root, "skill-routing-matrix.json"), "utf-8");
   const matrix = JSON.parse(matrixRaw);
-  const registryJson = `${JSON.stringify(deriveRegistryFromMatrix(matrix), null, 2)}\n`;
+  const skillNames = resolveBundleSkillNames(bundle, root);
+  const registryJson = `${JSON.stringify(deriveRegistryFromMatrix(matrix, root, { skillNames }), null, 2)}\n`;
   const routingBundle = {
     "skill-routing-matrix.json": matrixRaw,
     "registry.json": registryJson
@@ -85,19 +197,40 @@ function getPresetFiles(preset, vars = {}) {
   return files;
 }
 
-function copyBundle({ rootDir, force = false }) {
-  const bundleDir = path.join(__dirname, "..", "..", "..", "templates", "bundle");
+function copyBundleTree({ rootDir, srcDir, prefix, force = false }) {
   const results = [];
-  if (!fs.existsSync(bundleDir)) return results;
+  if (!fs.existsSync(srcDir)) return results;
 
-  for (const rel of walk(bundleDir)) {
-    const relNorm = rel.replace(/\\/g, "/");
-    const content = fs.readFileSync(path.join(bundleDir, rel), "utf-8");
+  for (const rel of walk(srcDir)) {
+    const relNorm = `${prefix}/${rel}`.replace(/\\/g, "/");
+    const srcAbs = path.join(srcDir, rel);
+    if (isTextBundleFile(srcAbs)) {
+      const content = fs.readFileSync(srcAbs, "utf-8");
+      results.push(
+        applyFilePolicy({
+          rootDir,
+          relativePath: relNorm,
+          content,
+          force
+        })
+      );
+    } else {
+      results.push(copyBinaryBundleFile({ rootDir, relativePath: relNorm, srcAbs, force }));
+    }
+  }
+  return results;
+}
+
+function copyPackageSchemas({ rootDir, force = false }) {
+  const schemaDir = path.join(pkgRoot(), "schemas");
+  const results = [];
+  if (!fs.existsSync(schemaDir)) return results;
+  for (const file of fs.readdirSync(schemaDir).filter((f) => f.endsWith(".json"))) {
     results.push(
       applyFilePolicy({
         rootDir,
-        relativePath: relNorm,
-        content,
+        relativePath: `.capint/schemas/${file}`,
+        content: fs.readFileSync(path.join(schemaDir, file), "utf-8"),
         force
       })
     );
@@ -105,15 +238,56 @@ function copyBundle({ rootDir, force = false }) {
   return results;
 }
 
+/** Copy skills/ + workflows/ into the target project (`full` default, `minimal` for CI). */
+function copyBundle({ rootDir, force = false, bundle = "full" }) {
+  const root = pkgRoot();
+  const mode = normalizeBundleMode(bundle) || "full";
+
+  if (mode === "minimal") {
+    const results = [];
+    for (const name of MINIMAL_BUNDLE_SKILLS) {
+      const srcDir = path.join(root, "skills", name);
+      if (!fs.existsSync(srcDir)) continue;
+      results.push(
+        ...copyBundleTree({ rootDir, srcDir, prefix: `skills/${name}`, force })
+      );
+    }
+    for (const wf of MINIMAL_BUNDLE_WORKFLOWS) {
+      const srcAbs = path.join(root, "workflows", wf);
+      if (!fs.existsSync(srcAbs)) continue;
+      results.push(
+        applyFilePolicy({
+          rootDir,
+          relativePath: `workflows/${wf}`,
+          content: fs.readFileSync(srcAbs, "utf-8"),
+          force
+        })
+      );
+    }
+    return results;
+  }
+
+  return [
+    ...copyBundleTree({ rootDir, srcDir: path.join(root, "skills"), prefix: "skills", force }),
+    ...copyBundleTree({ rootDir, srcDir: path.join(root, "workflows"), prefix: "workflows", force })
+  ];
+}
+
 const PRESET_MANIFEST = {
   minimal: {
     id: "minimal",
-    description: "AGENT.md, design.md, rules, matrix, registry, skill bundle",
+    description: "AGENT.md, design.md, rules, matrix, registry, skill bundle (full or --bundle minimal)",
     files: [
+      "GUNLUK.md",
+      "DONE.md",
       "AGENT.md",
       "AGENTS.md",
       "design.md",
+      "docs/kullanim-kilavuzu.md",
+      "docs/conventions/daily-use.md",
+      "docs/conventions/task-to-capability-cheatsheet.md",
       ".capint/rules/core.md",
+      ".capint/schemas/",
       ".gitignore",
       "skill-routing-matrix.json",
       "registry.json",
@@ -129,4 +303,19 @@ const PRESET_MANIFEST = {
   }
 };
 
-module.exports = { getPresetFiles, PRESET_MANIFEST, interpolate, deriveRegistryFromMatrix, copyBundle };
+module.exports = {
+  getPresetFiles,
+  PRESET_MANIFEST,
+  interpolate,
+  deriveRegistryFromMatrix,
+  copyBundle,
+  copyPackageSchemas,
+  listPackageSkillNames,
+  listProjectSkillNames,
+  resolveBundleSkillNames,
+  normalizeBundleMode,
+  MINIMAL_BUNDLE_SKILLS,
+  MINIMAL_BUNDLE_WORKFLOWS,
+  BUNDLE_MODES,
+  pkgRoot
+};

package/src/lib/skill-audit.js

@@ -0,0 +1,141 @@
+const fs = require("fs");
+const path = require("path");
+const { loadMatrix } = require("./route-engine");
+
+const STALE_BACKUP_DAYS = 90;
+const TIERS = ["core", "recommended", "optional", "project_added"];
+
+function loadRegistry(rootDir) {
+  const p = path.join(rootDir, "registry.json");
+  if (!fs.existsSync(p)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(p, "utf-8"));
+  } catch (e) {
+    return { parseError: e.message };
+  }
+}
+
+function skillsOnDisk(rootDir) {
+  const skillsDir = path.join(rootDir, "skills");
+  if (!fs.existsSync(skillsDir)) return [];
+  return fs
+    .readdirSync(skillsDir)
+    .filter((n) => fs.existsSync(path.join(skillsDir, n, "SKILL.md")));
+}
+
+function registrySkillSet(registry) {
+  const set = new Set();
+  if (!registry || registry.parseError) return set;
+  for (const tier of TIERS) {
+    for (const name of registry[tier] || []) set.add(name);
+  }
+  return set;
+}
+
+function matrixReferencedSkills(matrix) {
+  const set = new Set();
+  for (const tt of matrix?.task_types || []) {
+    for (const s of tt.skills || []) set.add(s);
+  }
+  for (const meta of Object.values(matrix?.rules_domain_map || {})) {
+    for (const s of meta.skills || []) set.add(s);
+  }
+  return set;
+}
+
+function listStaleBackupGroups(rootDir, maxAgeDays = STALE_BACKUP_DAYS) {
+  const dir = path.join(rootDir, ".capint", "backups");
+  if (!fs.existsSync(dir)) return [];
+  const cutoff = Date.now() - maxAgeDays * 24 * 60 * 60 * 1000;
+  const stamps = new Map();
+  for (const file of fs.readdirSync(dir).filter((f) => f.endsWith(".json"))) {
+    const stat = fs.statSync(path.join(dir, file));
+    const m = file.match(/^(skill-routing-matrix|registry)\.(.+)\.json$/);
+    if (!m) continue;
+    const stamp = m[2];
+    const prev = stamps.get(stamp);
+    if (!prev || stat.mtimeMs > prev.mtime) {
+      stamps.set(stamp, { stamp, mtime: stat.mtimeMs });
+    }
+  }
+  return [...stamps.values()].filter((g) => g.mtime < cutoff);
+}
+
+function runSkillAudit(rootDir, options = {}) {
+  const findings = [];
+  const recommendations = [];
+  const matrix = loadMatrix(rootDir);
+  const registry = loadRegistry(rootDir);
+  const disk = skillsOnDisk(rootDir);
+  const diskSet = new Set(disk);
+  const regSet = registrySkillSet(registry);
+  const matrixRefs = matrixReferencedSkills(matrix);
+
+  for (const name of disk) {
+    if (!regSet.has(name)) {
+      findings.push({
+        level: "warning",
+        code: "orphan_on_disk",
+        skill: name,
+        message: `Skill on disk but not in registry: ${name}`
+      });
+      recommendations.push(`capint skill pin ${name}  # or remove skills/${name}/`);
+    }
+  }
+
+  if (registry && !registry.parseError) {
+    for (const name of regSet) {
+      if (!diskSet.has(name)) {
+        const level = (registry.core || []).includes(name) ? "issue" : "warning";
+        findings.push({
+          level,
+          code: "registry_ghost",
+          skill: name,
+          message: `Registry entry missing on disk: ${name}`
+        });
+        recommendations.push(`capint init --bundle full  # or remove from registry`);
+      }
+    }
+
+    for (const name of registry.optional || []) {
+      if (diskSet.has(name) && !matrixRefs.has(name)) {
+        findings.push({
+          level: "info",
+          code: "matrix_unreferenced",
+          skill: name,
+          message: `Optional skill not referenced by matrix: ${name}`
+        });
+      }
+    }
+  }
+
+  const stale = listStaleBackupGroups(rootDir, options.staleDays ?? STALE_BACKUP_DAYS);
+  for (const g of stale) {
+    findings.push({
+      level: "info",
+      code: "stale_backup",
+      stamp: g.stamp,
+      message: `Backup older than ${STALE_BACKUP_DAYS} days: ${g.stamp}`
+    });
+    recommendations.push("Review .capint/backups/ and prune old snapshots if no longer needed");
+  }
+
+  const issueCount = findings.filter((f) => f.level === "issue").length;
+  const warningCount = findings.filter((f) => f.level === "warning").length;
+
+  return {
+    pass: issueCount === 0,
+    exit_code: issueCount === 0 ? 0 : 1,
+    summary: {
+      issues: issueCount,
+      warnings: warningCount,
+      info: findings.filter((f) => f.level === "info").length,
+      skills_on_disk: disk.length,
+      registry_count: regSet.size
+    },
+    findings,
+    recommendations: [...new Set(recommendations)]
+  };
+}
+
+module.exports = { runSkillAudit, STALE_BACKUP_DAYS, skillsOnDisk, loadRegistry };

package/src/lib/stack/index.js

@@ -0,0 +1,259 @@
+const fs = require("fs");
+const path = require("path");
+const { execSync } = require("child_process");
+const { runProvidersDoctor } = require("../providers/doctor");
+
+const STACK_DOC = "docs/capint-stack.md";
+const STACK_MANIFEST = ".capint/stack.json";
+const WORKFLOW_ANCHORS = [
+  { path: "workflows/forge.md", label: "forge gate (zero-regression)" },
+  { path: "workflows/challenge.md", label: "challenge gate" },
+  { path: "workflows/genesis.md", label: "genesis / design-first" },
+  { path: "workflows/blueprint.md", label: "blueprint / tasks" }
+];
+
+const GRAPH_PATH_CANDIDATES = ["src", "app", "lib", "components", "packages"];
+
+function fileExists(rootDir, rel) {
+  return fs.existsSync(path.join(rootDir, rel));
+}
+
+function countMarkdown(dir) {
+  if (!fs.existsSync(dir)) return 0;
+  return fs.readdirSync(dir).filter((f) => f.endsWith(".md")).length;
+}
+
+function tierWorkflows(rootDir) {
+  const wfDir = path.join(rootDir, "workflows");
+  const count = countMarkdown(wfDir);
+  const anchors = WORKFLOW_ANCHORS.map((a) => ({
+    ...a,
+    exists: fileExists(rootDir, a.path)
+  }));
+  const coreOk = anchors.filter((a) =>
+    ["workflows/forge.md", "workflows/challenge.md"].includes(a.path)
+  ).every((a) => a.exists);
+
+  let status = "missing";
+  if (count >= 4 && coreOk) status = "ok";
+  else if (count > 0) status = "partial";
+
+  return {
+    id: "layer_workflows",
+    label: "ANWS-style workflows (decisions, forge gate, drift)",
+    status,
+    workflow_count: count,
+    anchors,
+    chat: "Use /genesis /blueprint /challenge /forge in chat — not capint CLI"
+  };
+}
+
+function tierRouting(rootDir) {
+  const files = ["GUNLUK.md", "AGENT.md", "HANDOFF.md", "design.md", "skill-routing-matrix.json"];
+  const paths = files.map((p) => ({ path: p, exists: fileExists(rootDir, p) }));
+  const hasCore = paths.filter((p) => ["GUNLUK.md", "AGENT.md", "skill-routing-matrix.json"].includes(p.path)).every(
+    (p) => p.exists
+  );
+  return {
+    id: "layer_routing",
+    label: "CapInt routing + HANDOFF contract",
+    status: hasCore ? "ok" : fileExists(rootDir, "AGENT.md") ? "partial" : "missing",
+    paths,
+    enable: "capint init — daily chat via GUNLUK.md"
+  };
+}
+
+function detectGraphPaths(rootDir) {
+  const existing = GRAPH_PATH_CANDIDATES.filter((name) => {
+    const p = path.join(rootDir, name);
+    return fs.existsSync(p) && fs.statSync(p).isDirectory();
+  });
+
+  let suggested = [];
+  if (existing.includes("src")) {
+    suggested = ["./src"];
+  } else if (existing.includes("app") && existing.includes("lib")) {
+    suggested = ["./app", "./lib", "./components"].filter((rel) => fileExists(rootDir, rel.replace(/^\.\//, "")));
+  } else if (existing.length) {
+    suggested = existing.slice(0, 3).map((d) => `./${d}`);
+  } else {
+    suggested = ["."];
+  }
+
+  const cursorCmd = `/graphify ${suggested.join(" ")}`;
+  return { existing_dirs: existing, suggested, cursor_command: cursorCmd };
+}
+
+function syncGraphArtifacts(rootDir) {
+  const outDir = path.join(rootDir, "graphify-out");
+  const reportSrc = path.join(outDir, "GRAPH_REPORT.md");
+  const jsonSrc = path.join(outDir, "graph.json");
+  const actions = [];
+
+  if (!fs.existsSync(reportSrc) && !fs.existsSync(jsonSrc)) {
+    return { ok: false, error: "graphify-out/ not found — run /graphify in Cursor first", actions };
+  }
+
+  if (fs.existsSync(reportSrc)) {
+    fs.copyFileSync(reportSrc, path.join(rootDir, "GRAPH_REPORT.md"));
+    actions.push("GRAPH_REPORT.md");
+  }
+  if (fs.existsSync(jsonSrc)) {
+    const destDir = path.join(rootDir, ".capint", "graph");
+    fs.mkdirSync(destDir, { recursive: true });
+    fs.copyFileSync(jsonSrc, path.join(destDir, "graph.json"));
+    actions.push(".capint/graph/graph.json");
+  }
+
+  return { ok: actions.length > 0, actions };
+}
+
+function tryGraphifyCursorInstall(rootDir) {
+  try {
+    execSync("graphify install cursor --project", {
+      cwd: rootDir,
+      stdio: "pipe",
+      encoding: "utf-8"
+    });
+    return { ok: true, path: path.join(rootDir, ".cursor", "rules", "graphify.mdc") };
+  } catch (e) {
+    return { ok: false, error: (e.stderr || e.message || "graphify install failed").trim() };
+  }
+}
+
+function writeStackManifest(rootDir, report) {
+  const manifest = {
+    version: 1,
+    updated_at: new Date().toISOString(),
+    doc: STACK_DOC,
+    layers: {
+      workflows: report.layers.layer_workflows.status,
+      routing: report.layers.layer_routing.status,
+      graph: report.providers.tiers.tier1_graphify.status,
+      memory: report.providers.tiers.tier2_agentmemory.status
+    },
+    graph_paths: report.graph_paths
+  };
+  fs.mkdirSync(path.join(rootDir, ".capint"), { recursive: true });
+  fs.writeFileSync(path.join(rootDir, STACK_MANIFEST), `${JSON.stringify(manifest, null, 2)}\n`, "utf-8");
+  return manifest;
+}
+
+async function runStackDoctor(rootDir) {
+  const providers = await runProvidersDoctor(rootDir);
+  providers.recipe = STACK_DOC;
+
+  const layers = {
+    layer_workflows: tierWorkflows(rootDir),
+    layer_routing: tierRouting(rootDir)
+  };
+
+  const graph_paths = detectGraphPaths(rootDir);
+
+  const stackReady =
+    layers.layer_routing.status === "ok" &&
+    layers.layer_workflows.status !== "missing" &&
+    providers.tiers.tier1_graphify.status === "ok" &&
+    providers.tiers.tier2_agentmemory.status === "ok";
+
+  const recommendations = [];
+  if (layers.layer_routing.status !== "ok") recommendations.push("Run: capint init");
+  if (layers.layer_workflows.status === "missing") {
+    recommendations.push("Init with --bundle full (workflows/) or copy workflows from CapInt package.");
+  }
+  if (providers.tiers.tier1_graphify.status !== "ok") {
+    recommendations.push(`Cursor: ${graph_paths.cursor_command} then capint stack graph sync`);
+  }
+  if (providers.tiers.tier2_agentmemory.status !== "ok") {
+    recommendations.push("Machine: agentmemory (background) + Cursor MCP — see capint stack setup");
+  }
+  if (!providers.env.local_context_enabled) {
+    recommendations.push("Optional: CAPINT_LOCAL_CONTEXT=1 on route for file + graph excerpts.");
+  }
+
+  return {
+    mode: "read_only",
+    doc: STACK_DOC,
+    stack_ready: stackReady,
+    layers,
+    graph_paths,
+    providers,
+    env: providers.env,
+    recommendations,
+    daily_use: {
+      chat: "GUNLUK.md — natural language tasks",
+      heavy: "/blueprint then /forge (challenge gate before forge)",
+      memory: "agentmemory MCP + HANDOFF/DONE at session end",
+      graph: graph_paths.cursor_command
+    }
+  };
+}
+
+async function runStackSetup(rootDir, { installGraphifyRule = true } = {}) {
+  const doctorBefore = await runStackDoctor(rootDir);
+  const steps = [];
+
+  if (doctorBefore.layers.layer_routing.status !== "ok") {
+    steps.push({ id: "init", status: "required", action: "capint init [--bundle full]" });
+  } else {
+    steps.push({ id: "init", status: "ok", action: "CapInt scaffold present" });
+  }
+
+  if (installGraphifyRule && !fileExists(rootDir, ".cursor/rules/graphify.mdc")) {
+    const inst = tryGraphifyCursorInstall(rootDir);
+    steps.push({
+      id: "graphify_cursor",
+      status: inst.ok ? "ok" : "manual",
+      action: inst.ok ? "graphify install cursor --project" : "uv tool install graphifyy && graphify install cursor --project",
+      detail: inst.ok ? inst.path : inst.error
+    });
+  } else {
+    steps.push({ id: "graphify_cursor", status: "ok", action: ".cursor/rules/graphify.mdc" });
+  }
+
+  steps.push({
+    id: "graph_build",
+    status: doctorBefore.providers.tiers.tier1_graphify.status === "ok" ? "ok" : "manual",
+    action: doctorBefore.graph_paths.cursor_command,
+    then: "capint stack graph sync"
+  });
+
+  steps.push({
+    id: "agentmemory",
+    status: doctorBefore.providers.tiers.tier2_agentmemory.status === "ok" ? "ok" : "manual",
+    action: "agentmemory (separate terminal) + ~/.cursor/mcp.json agentmemory block",
+    doc: "https://github.com/rohitg00/agentmemory#other-agents"
+  });
+
+  const manifest = writeStackManifest(rootDir, doctorBefore);
+
+  return {
+    doc: STACK_DOC,
+    manifest,
+    steps,
+    doctor: await runStackDoctor(rootDir)
+  };
+}
+
+function formatStackSummary(report) {
+  const lines = [];
+  lines.push("CapInt stack (4 layers):");
+  lines.push(`  1. Workflows  ${report.layers.layer_workflows.status}  — ANWS-style gates (/forge, /challenge)`);
+  lines.push(`  2. Routing    ${report.layers.layer_routing.status}  — capint route + HANDOFF/GUNLUK`);
+  lines.push(`  3. Graph      ${report.providers.tiers.tier1_graphify.status}  — graphify → CapInt reads artifacts`);
+  lines.push(`  4. Memory     ${report.providers.tiers.tier2_agentmemory.status}  — agentmemory sidecar + MCP`);
+  lines.push(`  Stack ready: ${report.stack_ready ? "yes" : "no"} — doc: ${report.doc}`);
+  return lines.join("\n");
+}
+
+module.exports = {
+  STACK_DOC,
+  STACK_MANIFEST,
+  detectGraphPaths,
+  syncGraphArtifacts,
+  runStackDoctor,
+  runStackSetup,
+  formatStackSummary,
+  tierWorkflows,
+  tierRouting
+};