@bcelep/capint 0.6.5 → 0.7.0

package/schemas/ui-api.v1.json

@@ -0,0 +1,85 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://capint.dev/schemas/ui-api.v1.json",
+  "title": "CapInt UI Wizard API",
+  "definitions": {
+    "RouteRequest": {
+      "type": "object",
+      "required": ["task"],
+      "properties": {
+        "task": { "type": "string", "minLength": 1 },
+        "locale": { "enum": ["tr", "en"] }
+      }
+    },
+    "RouteResponse": {
+      "type": "object",
+      "required": ["result", "text_report", "chat_copy"],
+      "properties": {
+        "result": {
+          "type": "object",
+          "required": ["execution_intent"],
+          "properties": {
+            "execution_intent": { "$ref": "execution-intent.v1.json" }
+          }
+        },
+        "text_report": { "type": "string" },
+        "chat_copy": { "type": "string" }
+      }
+    },
+    "HealthResponse": {
+      "type": "object",
+      "required": ["ok", "doctor", "status"],
+      "properties": {
+        "ok": { "type": "boolean" },
+        "doctor": { "type": "object" },
+        "status": {
+          "type": "object",
+          "properties": {
+            "skills_on_disk": { "type": "number" },
+            "core_skills": { "type": "number" },
+            "matrix_version": { "type": ["string", "null"] },
+            "capint_package": { "type": "string" }
+          }
+        }
+      }
+    },
+    "RecoverRequest": {
+      "type": "object",
+      "properties": {
+        "apply": { "type": "boolean", "default": false },
+        "latest": { "type": "boolean", "default": true }
+      }
+    },
+    "FeedbackRequest": {
+      "type": "object",
+      "properties": {
+        "rating": { "type": "integer", "minimum": 1, "maximum": 5 },
+        "comment": { "type": "string", "maxLength": 2000 },
+        "source": { "type": "string", "default": "ui" }
+      }
+    }
+  },
+  "paths": {
+    "/api/health": {
+      "get": { "response": { "$ref": "#/definitions/HealthResponse" } }
+    },
+    "/api/route": {
+      "post": {
+        "request": { "$ref": "#/definitions/RouteRequest" },
+        "response": { "$ref": "#/definitions/RouteResponse" }
+      }
+    },
+    "/api/recover": {
+      "post": {
+        "request": { "$ref": "#/definitions/RecoverRequest" },
+        "response": { "type": "object" }
+      }
+    },
+    "/api/feedback": {
+      "post": {
+        "request": { "$ref": "#/definitions/FeedbackRequest" },
+        "response": { "type": "object", "properties": { "ok": { "type": "boolean" } } }
+      }
+    }
+  }
+}

package/scripts/generate-schema-docs.mjs

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+import crypto from "crypto";
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const root = path.join(__dirname, "..");
+const schemaDir = path.join(root, "schemas");
+const outDir = path.join(root, "docs", "generated");
+
+const SCHEMAS = [
+  "execution-intent.v1.json",
+  "explanation.v2.json",
+  "ui-api.v1.json",
+  "explanation.v1.json"
+];
+
+function propsTable(schema) {
+  const props = schema.properties || {};
+  const req = new Set(schema.required || []);
+  const lines = ["| Field | Type | Required |", "|-------|------|----------|"];
+  for (const [name, def] of Object.entries(props)) {
+    const type = def.enum ? def.enum.join(" \\| ") : def.type || def.$ref || "object";
+    lines.push(`| \`${name}\` | ${type} | ${req.has(name) ? "yes" : "no"} |`);
+  }
+  return lines.join("\n");
+}
+
+function renderSchemaDoc(fileName, schema) {
+  const title = schema.title || fileName;
+  return `# ${title}
+
+> Auto-generated from \`schemas/${fileName}\`. Do not edit by hand.
+
+**$id:** \`${schema.$id || ""}\`
+
+## Properties
+
+${propsTable(schema)}
+
+## Raw schema
+
+\`\`\`json
+${JSON.stringify(schema, null, 2)}
+\`\`\`
+`;
+}
+
+function hashContent(content) {
+  return crypto.createHash("sha256").update(content).digest("hex").slice(0, 16);
+}
+
+function generate() {
+  fs.mkdirSync(outDir, { recursive: true });
+  const written = [];
+  for (const file of SCHEMAS) {
+    const src = path.join(schemaDir, file);
+    if (!fs.existsSync(src)) continue;
+    const schema = JSON.parse(fs.readFileSync(src, "utf-8"));
+    const base = file.replace(/\.json$/, "");
+    const md = renderSchemaDoc(file, schema);
+    const dest = path.join(outDir, `${base}.md`);
+    fs.writeFileSync(dest, md, "utf-8");
+    written.push(dest);
+  }
+  const index = `# CapInt generated schema docs
+
+${SCHEMAS.filter((f) => fs.existsSync(path.join(schemaDir, f)))
+  .map((f) => `- [${f.replace(/\.json$/, "")}](./${f.replace(/\.json$/, "")}.md)`)
+  .join("\n")}
+`;
+  fs.writeFileSync(path.join(outDir, "README.md"), index, "utf-8");
+  return written;
+}
+
+function check() {
+  const tmp = [];
+  for (const file of SCHEMAS) {
+    const src = path.join(schemaDir, file);
+    if (!fs.existsSync(src)) continue;
+    const schema = JSON.parse(fs.readFileSync(src, "utf-8"));
+    const expected = renderSchemaDoc(file, schema);
+    const dest = path.join(outDir, `${file.replace(/\.json$/, "")}.md`);
+    if (!fs.existsSync(dest)) {
+      console.error(`missing generated doc: ${path.relative(root, dest)}`);
+      process.exit(1);
+    }
+    const actual = fs.readFileSync(dest, "utf-8");
+    if (hashContent(actual) !== hashContent(expected)) {
+      console.error(`stale generated doc: ${path.relative(root, dest)} — run: node scripts/generate-schema-docs.mjs`);
+      process.exit(1);
+    }
+    tmp.push(dest);
+  }
+  console.log(`schema docs check ok (${tmp.length} files)`);
+}
+
+if (process.argv.includes("--check")) {
+  check();
+} else {
+  const files = generate();
+  console.log(`generated ${files.length} schema docs → docs/generated/`);
+}

package/scripts/release-check.mjs

@@ -21,6 +21,12 @@ const steps = [
   ["upgrade", ["node", "tests/upgrade.test.mjs"]],
   ["local-adapters", ["node", "tests/local-adapters.test.mjs"]],
   ["explanation", ["node", "tests/explanation.test.mjs"]],
+  ["providers-doctor", ["node", "tests/providers-doctor.test.mjs"]],
+  ["stack", ["node", "tests/stack.test.mjs"]],
+  ["skill-audit", ["node", "tests/skill-audit.test.mjs"]],
+  ["cli-ui-parity", ["node", "tests/cli-ui-parity.test.mjs"]],
+  ["generate-schema-docs", ["node", "scripts/generate-schema-docs.mjs"]],
+  ["schema-docs-check", ["node", "scripts/generate-schema-docs.mjs", "--check"]],
   ["workspace-boundary", ["node", "tests/workspace-boundary.test.mjs"]],
   ["skill-disable", ["node", "tests/skill-disable.test.mjs"]],
   ["recover", ["node", "tests/recover.test.mjs"]],
@@ -33,6 +39,10 @@ const steps = [
   ["pipeline-smoke", ["node", "bin/capint.js", "pipeline", "i18n çeviri", "--force"]],
   ["doctor-smoke", ["node", "bin/capint.js", "doctor"]],
   ["audit-smoke", ["node", "bin/capint.js", "audit", "--json"]],
+  ["skill-audit-smoke", ["node", "bin/capint.js", "skill", "audit", "--json"]],
+  ["feedback-smoke", ["node", "bin/capint.js", "feedback", "--summary", "--json"]],
+  ["providers-doctor-smoke", ["node", "bin/capint.js", "providers", "doctor", "--json"]],
+  ["stack-doctor-smoke", ["node", "bin/capint.js", "stack", "doctor", "--json"]],
   ["consult-smoke", ["node", "bin/capint.js", "consult", "debug login", "--json"]],
   ["status-smoke", ["node", "bin/capint.js", "status", "--json"]]
 ];

package/skills/prismx-skill-gateway/SKILL.md

@@ -37,12 +37,19 @@ You are the **invisible skill router**. Every task request passes through you fi
 | `not_installed` | Do not pretend it exists. Use fallback or suggest `prismx skill add <name>`. |
 | `project_added` | Treat as first-class for this project after reading its `SKILL.md`. |
 
-## PrismX Context Check (Before Routing)
+## Context Check (Before Routing)
+
+**CapInt project (root):**
+1. Read `HANDOFF.md` if present → active task context
+2. Skim `DONE.md` → don't rebuild completed work
+3. Session rules: `AGENT.md` + gateway (this file)
+
+**PrismX legacy (`.prismx/`):**
 1. Read `.prismx/HANDOFF.md` → current task context
 2. Read `.prismx/CURRENT_TASK.md` → today's focus (if present)
 3. Check `.prismx/DONE.md` → don't rebuild completed features
-4. New session → prefer `session-context-primer` before heavy work
-5. Check complexity weight → 🟢 skip brainstorming, 🔴 always brainstorm first
+
+Then: new session → prefer `session-context-primer` before heavy work; check complexity weight → 🟢 skip brainstorming, 🔴 always brainstorm first
 
 ## Quick Routing Table
 | Keywords | Preferred Skill(s) | If Missing |

package/src/commands/doctor.js

@@ -29,6 +29,15 @@ module.exports = async function doctor(_args, flags) {
     for (const i of report.issues) console.log(`  x ${i}`);
     console.log("");
   }
+  if (report.actions?.length) {
+    console.log("Suggested actions:");
+    for (const a of report.actions) console.log(`  → ${a.label} (${a.command})`);
+    console.log("");
+  }
+  if (report.summary_plain) {
+    console.log(`Summary: ${report.summary_plain}`);
+    console.log("");
+  }
   console.log(report.hint);
   console.log("");
 

package/src/commands/feedback.js

@@ -0,0 +1,29 @@
+module.exports = async function feedback(args, flags) {
+  const rootDir = process.cwd();
+  const { summarizeFeedback } = require("../lib/feedback");
+  const sub = args[0];
+
+  if (sub === "summary" || flags.summary || (!sub && flags.json)) {
+    const summary = summarizeFeedback(rootDir);
+    if (flags.json) {
+      console.log(JSON.stringify(summary, null, 2));
+      return;
+    }
+    console.log("\n## CapInt feedback (local)\n");
+    console.log(`Entries: ${summary.count}`);
+    console.log(`Rated: ${summary.rated_count}`);
+    console.log(`Average: ${summary.average_rating ?? "—"}`);
+    if (Object.keys(summary.by_source).length) {
+      console.log("By source:");
+      for (const [k, v] of Object.entries(summary.by_source)) console.log(`  ${k}: ${v}`);
+    }
+    console.log("");
+    return;
+  }
+
+  console.log(`
+capint feedback — local wizard feedback (stored under .capint/feedback/)
+
+  capint feedback --summary [--json]
+`);
+};

package/src/commands/init.js

@@ -69,6 +69,18 @@ module.exports = async function init(args, flags) {
     console.log("\nIDE sync skipped (--no-ide-sync). Run: capint ide sync");
   }
   console.log("\nNext: open GUNLUK.md — then chat your first task (no terminal needed)");
+  console.log("       capint stack setup     — workflows + graphify + agentmemory checklist");
   console.log("       capint route \"i18n\"  (optional preview)");
+  console.log("Stack doc: docs/capint-stack.md");
   console.log("Conflict policy: existing files without capint managed blocks are never overwritten.\n");
+
+  if (flags.stack) {
+    const { runStackSetup, formatStackSummary } = require("../lib/stack");
+    const stackResult = await runStackSetup(rootDir, { installGraphifyRule: !flags["no-graphify-install"] });
+    console.log("## Stack setup (post-init)\n");
+    for (const step of stackResult.steps) {
+      console.log(`  [${step.status}] ${step.id}: ${step.action}`);
+    }
+    console.log(`\n${formatStackSummary(stackResult.doctor)}\n`);
+  }
 };

package/src/commands/providers.js

@@ -0,0 +1,54 @@
+module.exports = async function providers(args, flags) {
+  const sub = args[0];
+  const rootDir = process.cwd();
+  const { runProvidersDoctor } = require("../lib/providers/doctor");
+
+  if (sub !== "doctor") {
+    console.log(`
+capint providers — memory/graph sidecar diagnostics
+
+  capint providers doctor [--json]
+
+Recipe: docs/capint-stack.md (detail: docs/recipes/memory-graph-pairing.md)
+`);
+    if (!sub) return;
+    console.error(`Unknown subcommand: ${sub}`);
+    process.exit(1);
+  }
+
+  const report = await runProvidersDoctor(rootDir);
+
+  if (flags.json) {
+    console.log(JSON.stringify(report, null, 2));
+    return;
+  }
+
+  console.log("\n## CapInt providers doctor\n");
+  console.log(`Recipe: ${report.recipe}\n`);
+
+  console.log("Environment:");
+  console.log(`  CAPINT_LOCAL_CONTEXT: ${report.env.CAPINT_LOCAL_CONTEXT || "(unset)"}`);
+  console.log(`  CAPINT_MEMORY: ${report.env.CAPINT_MEMORY || "(unset)"}`);
+  console.log(`  CAPINT_GRAPH: ${report.env.CAPINT_GRAPH || "(unset)"}`);
+  console.log(`  local_context hot-path: ${report.env.local_context_enabled ? "on" : "off"}\n`);
+
+  for (const tier of Object.values(report.tiers)) {
+    const icon = tier.status === "ok" ? "✓" : tier.status === "partial" || tier.status === "cli_only" ? "~" : "✗";
+    console.log(`${icon} ${tier.label} — ${tier.status}`);
+    if (tier.id === "tier0_local") {
+      for (const p of tier.paths) console.log(`    ${p.exists ? "✓" : "✗"} ${p.path}`);
+    }
+    if (tier.id === "tier1_graphify" && tier.artifacts_found?.length) {
+      for (const p of tier.artifacts_found) console.log(`    ✓ ${p}`);
+    }
+    if (tier.id === "tier2_agentmemory" && tier.health?.error) {
+      console.log(`    ${tier.health.error}`);
+    }
+  }
+
+  if (report.recommendations.length) {
+    console.log("\nRecommendations:");
+    for (const r of report.recommendations) console.log(`  - ${r}`);
+  }
+  console.log("");
+};

package/src/commands/skill.js

@@ -18,6 +18,7 @@ capint skill — disable / enable / pin without deleting files
   capint skill disable <name>
   capint skill enable <name>
   capint skill pin <name>     promote to registry project_added tier
+  capint skill audit [--json]   orphan / ghost / unreferenced skill report
 
 Overlay: ${OVERLAY_PATH}
 `);
@@ -85,6 +86,32 @@ Overlay: ${OVERLAY_PATH}
     return;
   }
 
+  if (sub === "audit") {
+    const { runSkillAudit } = require("../lib/skill-audit");
+    const report = runSkillAudit(rootDir);
+    if (flags.json) {
+      console.log(JSON.stringify(report, null, 2));
+      if (!report.pass) process.exit(report.exit_code);
+      return;
+    }
+    console.log("\n## Skill audit\n");
+    console.log(`Result: ${report.pass ? "PASS" : "FAIL"}`);
+    console.log(
+      `Findings: ${report.summary.issues} issues, ${report.summary.warnings} warnings, ${report.summary.info} info`
+    );
+    console.log(`Skills on disk: ${report.summary.skills_on_disk} · Registry: ${report.summary.registry_count}\n`);
+    for (const f of report.findings) {
+      console.log(`  [${f.level}] ${f.message}`);
+    }
+    if (report.recommendations.length) {
+      console.log("\nRecommendations:");
+      for (const r of report.recommendations) console.log(`  - ${r}`);
+    }
+    console.log("");
+    if (!report.pass) process.exit(report.exit_code);
+    return;
+  }
+
   if (sub === "pin") {
     if (!name) {
       console.error("Usage: capint skill pin <name>");

package/src/commands/stack.js

@@ -0,0 +1,97 @@
+const {
+  runStackDoctor,
+  runStackSetup,
+  syncGraphArtifacts,
+  detectGraphPaths,
+  formatStackSummary,
+  STACK_DOC
+} = require("../lib/stack");
+
+module.exports = async function stack(args, flags) {
+  const sub = args[0];
+  const rootDir = process.cwd();
+
+  if (!sub || sub === "help" || flags.help) {
+    console.log(`
+capint stack — unified CapInt + workflows + graphify + agentmemory
+
+  capint stack doctor [--json]     4-layer health (replaces mental model of providers only)
+  capint stack setup [--json]      post-init wiring checklist + .capint/stack.json
+  capint stack graph paths         suggest /graphify folders for this repo
+  capint stack graph sync          copy graphify-out/ → CapInt paths
+
+Doc: ${STACK_DOC}
+`);
+    return;
+  }
+
+  if (sub === "doctor") {
+    const report = await runStackDoctor(rootDir);
+    if (flags.json) {
+      console.log(JSON.stringify(report, null, 2));
+      return;
+    }
+    console.log("\n## CapInt stack doctor\n");
+    console.log(formatStackSummary(report));
+    console.log("");
+    if (report.graph_paths.suggested.length) {
+      console.log(`Suggested graphify: ${report.graph_paths.cursor_command}\n`);
+    }
+    if (report.recommendations.length) {
+      console.log("Next:");
+      for (const r of report.recommendations) console.log(`  - ${r}`);
+      console.log("");
+    }
+    return;
+  }
+
+  if (sub === "setup") {
+    const result = await runStackSetup(rootDir, { installGraphifyRule: !flags["no-graphify-install"] });
+    if (flags.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    console.log("\n## CapInt stack setup\n");
+    console.log(`Wrote ${result.manifest ? ".capint/stack.json" : "manifest"}\n`);
+    for (const step of result.steps) {
+      console.log(`  [${step.status}] ${step.id}: ${step.action}`);
+      if (step.then) console.log(`         then: ${step.then}`);
+      if (step.detail && step.status !== "ok") console.log(`         (${step.detail})`);
+    }
+    console.log(`\n${formatStackSummary(result.doctor)}\n`);
+    return;
+  }
+
+  if (sub === "graph" && args[1] === "paths") {
+    const paths = detectGraphPaths(rootDir);
+    if (flags.json) {
+      console.log(JSON.stringify(paths, null, 2));
+      return;
+    }
+    console.log("\n## Graph paths for this project\n");
+    console.log(`Dirs found: ${paths.existing_dirs.join(", ") || "(none — will use .)"}`);
+    console.log(`Cursor: ${paths.cursor_command}`);
+    console.log(`Then:   capint stack graph sync\n`);
+    return;
+  }
+
+  if (sub === "graph" && args[1] === "sync") {
+    const result = syncGraphArtifacts(rootDir);
+    if (flags.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    if (!result.ok) {
+      console.error(result.error || "Nothing to sync");
+      process.exit(1);
+    }
+    console.log("\n## Graph synced to CapInt paths\n");
+    for (const a of result.actions) console.log(`  ✓ ${a}`);
+    console.log("\nRun: capint stack doctor\n");
+    return;
+  }
+
+  console.error(`Unknown: capint stack ${args.join(" ")}`);
+  console.error("Try: capint stack help");
+  process.exit(1);
+};

package/src/lib/audit.js

@@ -2,6 +2,7 @@ const fs = require("fs");
 const path = require("path");
 const { runDoctor } = require("./doctor");
 const { loadMatrix } = require("./route-engine");
+const { runSkillAudit } = require("./skill-audit");
 
 const EXPECTED_AGENT_MARKERS = ["Execution Intent", "confirm", "parseIntent"];
 
@@ -89,6 +90,12 @@ function runAudit(rootDir) {
     findings.push({ level: "warning", code: "doctor", message: w });
   }
 
+  const skillAudit = runSkillAudit(rootDir);
+  for (const f of skillAudit.findings) {
+    findings.push(f);
+  }
+  recommendations.push(...skillAudit.recommendations);
+
   const issueCount = findings.filter((f) => f.level === "issue").length;
   const warningCount = findings.filter((f) => f.level === "warning").length;
 
@@ -100,7 +107,8 @@ function runAudit(rootDir) {
     summary: { issues: issueCount, warnings: warningCount, info: findings.filter((f) => f.level === "info").length },
     findings,
     recommendations: [...new Set(recommendations)],
-    doctor_pass: doctor.pass
+    doctor_pass: doctor.pass,
+    skill_audit: skillAudit.summary
   };
 }
 

package/src/lib/contract.js

@@ -36,6 +36,15 @@ function validateExplanationShape(explanation, errors) {
   if (typeof explanation.reason_summary !== "string") {
     errors.push("explanation.reason_summary must be string");
   }
+  if (explanation.reason_plain != null && typeof explanation.reason_plain !== "string") {
+    errors.push("explanation.reason_plain must be string when present");
+  }
+  if (explanation.tooltip != null && typeof explanation.tooltip !== "string") {
+    errors.push("explanation.tooltip must be string when present");
+  }
+  if (explanation.locale != null && !["tr", "en"].includes(explanation.locale)) {
+    errors.push("explanation.locale must be tr or en when present");
+  }
   if (!Array.isArray(explanation.files_to_read)) {
     errors.push("explanation.files_to_read must be array");
   }

package/src/lib/doctor.js

@@ -1,8 +1,9 @@
 const fs = require("fs");
 const path = require("path");
 const { loadMatrix } = require("./route-engine");
-const { validateExecutionIntent } = require("./contract");
 const { loadDisabledSkills } = require("./disabled-skills");
+const { listBackups } = require("./recover");
+const { resolveLocale, t } = require("./i18n");
 
 function loadRegistry(rootDir) {
   const p = path.join(rootDir, "registry.json");
@@ -22,7 +23,60 @@ function skillsOnDisk(rootDir) {
     .filter((n) => fs.existsSync(path.join(skillsDir, n, "SKILL.md")));
 }
 
-function runDoctor(rootDir) {
+function buildDoctorActions({ issues, warnings, rootDir, locale }) {
+  const loc = resolveLocale(locale);
+  const actions = [];
+  const hasConfigIssue = issues.some(
+    (i) => i.includes("matrix") || i.includes("registry") || i.includes("parse error")
+  );
+  const { groups } = listBackups(rootDir);
+
+  if (hasConfigIssue && groups.length) {
+    actions.push({
+      id: "recover_latest",
+      safe: true,
+      command: "capint recover --latest --apply",
+      label_tr: t("ui.recover.apply", "tr"),
+      label_en: t("ui.recover.apply", "en"),
+      label: t("ui.recover.apply", loc)
+    });
+  }
+
+  for (const w of warnings) {
+    const m = w.match(/^core skill disabled: (\S+)/);
+    if (m) {
+      actions.push({
+        id: "enable_core",
+        safe: true,
+        skill: m[1],
+        command: `capint skill enable ${m[1]}`,
+        label_tr: `Core skill'i aç: ${m[1]}`,
+        label_en: `Re-enable core skill: ${m[1]}`,
+        label: loc === "en" ? `Re-enable core skill: ${m[1]}` : `Core skill'i aç: ${m[1]}`
+      });
+    }
+  }
+
+  return actions;
+}
+
+function buildSummaryPlain({ pass, issues, warnings, locale }) {
+  const loc = resolveLocale(locale);
+  if (pass && !warnings.length) return t("doctor.summary.ok", loc);
+  if (issues.some((i) => i.includes("matrix") || i.includes("registry"))) {
+    return t("doctor.summary.registry", loc);
+  }
+  if (warnings.some((w) => w.includes("disabled"))) {
+    return t("doctor.summary.disabled", loc);
+  }
+  if (!pass) {
+    return loc === "en" ? "Configuration issues found — see details below." : "Yapılandırma sorunları var — aşağıdaki detaylara bak.";
+  }
+  return loc === "en" ? "Healthy with minor warnings." : "Genel olarak sağlıklı; küçük uyarılar var.";
+}
+
+function runDoctor(rootDir, options = {}) {
+  const locale = resolveLocale(options.locale);
   const issues = [];
   const warnings = [];
   const ok = [];
@@ -44,6 +98,11 @@ function runDoctor(rootDir) {
       ...(registry.optional || []),
       ...(registry.project_added || [])
     ]);
+    for (const name of disk) {
+      if (!allReg.has(name)) {
+        warnings.push(`Skill on disk but not in registry: ${name}`);
+      }
+    }
     for (const name of registry.core || []) {
       if (!disk.has(name)) warnings.push(`core skill missing on disk: ${name}`);
     }
@@ -100,6 +159,9 @@ function runDoctor(rootDir) {
     hint = "Re-enable core skills: capint skill enable <name>";
   }
 
+  const actions = buildDoctorActions({ issues, warnings, rootDir, locale });
+  const summary_plain = buildSummaryPlain({ pass, issues, warnings, locale });
+
   return {
     pass,
     exit_code: pass ? 0 : 1,
@@ -107,7 +169,11 @@ function runDoctor(rootDir) {
     warnings,
     ok,
     auto_fix: false,
-    hint
+    hint,
+    actions,
+    summary_plain,
+    summary_plain_tr: buildSummaryPlain({ pass, issues, warnings, locale: "tr" }),
+    summary_plain_en: buildSummaryPlain({ pass, issues, warnings, locale: "en" })
   };
 }
 

package/src/lib/execution-policy.js

@@ -3,6 +3,7 @@ const path = require("path");
 const { resolveOrchestration } = require("./orchestration");
 const { disabledSet, overlayParseError } = require("./disabled-skills");
 const { buildExplanation } = require("./explanation");
+const { resolveLocale } = require("./i18n");
 const { matchKeywords } = require("./intent-parser");
 const { defaultConfirmOverride } = require("./env-flags");
 const { detectWorkspaceBoundary } = require("./workspace-boundary");
@@ -157,7 +158,8 @@ function buildExecutionPolicy({ rawText, routeResult, memoryStrategy, matrix, pa
     rootDir,
     matchKeywords,
     resolutionStatus: installStatus.resolution_status,
-    confirmDefaultOption: confirmBlock.default_option
+    confirmDefaultOption: confirmBlock.default_option,
+    locale: resolveLocale()
   });
 
   const out = {