@fenglimg/fabric-server 2.0.0-rc.25 → 2.0.0-rc.27

package/dist/{chunk-HAXROPQM.js → chunk-NZSGNQKE.js}

@@ -184,6 +184,46 @@ var EVENT_LEDGER_DEFAULT_RETENTION_DAYS = 30;
 var EVENT_LEDGER_SIZE_WARN_BYTES = 50 * 1024 * 1024;
 var EVENT_LEDGER_ARCHIVE_DIR = ".fabric/events.archive";
 var warnedOversize = false;
+var knownEventTypesCache = null;
+function getKnownEventTypes() {
+  if (knownEventTypesCache !== null) return knownEventTypesCache;
+  const set = /* @__PURE__ */ new Set();
+  for (const opt of eventLedgerEventSchema.options) {
+    const shape = opt.shape;
+    if (shape && typeof shape.event_type?.value === "string") {
+      set.add(shape.event_type.value);
+    }
+  }
+  knownEventTypesCache = set;
+  return set;
+}
+function classifyRejection(line, index) {
+  let parsed;
+  try {
+    parsed = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  if (parsed === null || typeof parsed !== "object") return null;
+  if ("schema_version" in parsed && parsed.schema_version !== 1 && (typeof parsed.schema_version === "number" || parsed.schema_version === null)) {
+    return {
+      kind: "schema_version_unsupported",
+      line_index: index,
+      schema_version: parsed.schema_version,
+      snippet_first_120: line.slice(0, 120)
+    };
+  }
+  const known = getKnownEventTypes();
+  if (typeof parsed.event_type === "string" && !known.has(parsed.event_type)) {
+    return {
+      kind: "event_type_unknown",
+      line_index: index,
+      event_type: parsed.event_type,
+      snippet_first_120: line.slice(0, 120)
+    };
+  }
+  return null;
+}
 async function appendEventLedgerEvent(projectRoot, event) {
   const eventPath = getEventLedgerPath(projectRoot);
   const nextEvent = eventLedgerEventSchema.parse({
@@ -238,8 +278,20 @@ async function readEventLedger(projectRoot, options = {}) {
       snippet_first_120: partialLine.slice(0, 120)
     });
   }
-  const events = lines.map((line) => line.trim()).filter((line) => line.length > 0).map((line, index) => parseEventLedgerLine(line, index)).filter((entry) => entry !== null).filter((entry) => options.event_type === void 0 || entry.event_type === options.event_type).filter((entry) => options.since === void 0 || entry.ts >= options.since).filter((entry) => options.correlation_id === void 0 || entry.correlation_id === options.correlation_id).filter((entry) => options.session_id === void 0 || entry.session_id === options.session_id);
-  return { events, warnings };
+  const trimmed = lines.map((line) => line.trim()).filter((line) => line.length > 0);
+  const events = [];
+  for (let i = 0; i < trimmed.length; i++) {
+    const line = trimmed[i];
+    const parsed = parseEventLedgerLine(line, i);
+    if (parsed !== null) {
+      events.push(parsed);
+      continue;
+    }
+    const rejection = classifyRejection(line, i);
+    if (rejection !== null) warnings.push(rejection);
+  }
+  const filtered = events.filter((entry) => options.event_type === void 0 || entry.event_type === options.event_type).filter((entry) => options.since === void 0 || entry.ts >= options.since).filter((entry) => options.correlation_id === void 0 || entry.correlation_id === options.correlation_id).filter((entry) => options.session_id === void 0 || entry.session_id === options.session_id);
+  return { events: filtered, warnings };
 }
 async function truncateLedgerToLastNewline(path2) {
   const raw = await readFile2(path2);
@@ -951,16 +1003,18 @@ function extractRuleDescription(source) {
   }
   const heading = /^#\s+(.+?)\s*$/mu.exec(source);
   const summary = heading?.[1]?.trim();
-  if (summary === void 0 || summary.length === 0) {
+  const knowledge = frontmatter !== null ? extractKnowledgeFieldsFromFrontmatter(frontmatter[1]) : void 0;
+  const isStructurallyAKnowledgeEntry = summary !== void 0 && summary.length > 0 ? true : knowledge !== void 0 && (knowledge.id !== void 0 || knowledge.knowledge_type !== void 0 || knowledge.tags !== void 0 && knowledge.tags.length > 0);
+  if (!isStructurallyAKnowledgeEntry) {
     return void 0;
   }
-  const knowledge = frontmatter !== null ? extractKnowledgeFieldsFromFrontmatter(frontmatter[1]) : void 0;
+  const synthesizedSummary = summary !== void 0 && summary.length > 0 ? summary : knowledge?.id ?? (knowledge?.tags !== void 0 && knowledge.tags.length > 0 ? `(unnamed; tags: ${knowledge.tags.join(", ")})` : "(unnamed knowledge entry)");
   return {
-    summary,
+    summary: synthesizedSummary,
     intent_clues: [],
     tech_stack: [],
     impact: [],
-    must_read_if: summary,
+    must_read_if: synthesizedSummary,
     // v2.0-rc.22: when frontmatter is present, merge its knowledge fields;
     // when fully absent (no `---` block), all knowledge fields stay
     // undefined, matching the original heading-only fallback contract.
@@ -1473,10 +1527,9 @@ async function reconcileKnowledge(projectRoot, opts) {
 // src/services/serve-lock.ts
 import fs from "fs";
 import path from "path";
-import { createTranslator, detectNodeLocale } from "@fenglimg/fabric-shared";
+import { createTranslator, resolveFabricLocale } from "@fenglimg/fabric-shared";
 import { IOFabricError as IOFabricError2 } from "@fenglimg/fabric-shared/errors";
 var LOCK_FILENAME = ".serve.lock";
-var t = createTranslator(detectNodeLocale());
 var ServeLockHeldError = class extends IOFabricError2 {
   code = "SERVE_LOCK_HELD";
   httpStatus = 423;
@@ -1504,6 +1557,7 @@ function acquireLock(projectRoot, opts) {
     } catch {
     }
     if (state && state.pid && state.pid !== process.pid && isAlive(state.pid) && !opts?.force) {
+      const t = createTranslator(resolveFabricLocale(projectRoot));
       throw new ServeLockHeldError(
         `serve lock held by live PID ${state.pid}`,
         {
@@ -1554,6 +1608,7 @@ function checkLockOrThrow(projectRoot, opts) {
     return;
   }
   if (opts?.force) return;
+  const t = createTranslator(resolveFabricLocale(projectRoot));
   throw new ServeLockHeldError(
     `serve lock held by live PID ${state.pid}`,
     {
@@ -1574,6 +1629,7 @@ import { minimatch } from "minimatch";
 import {
   agentsMetaSchema as agentsMetaSchema4,
   AgentsMetaCountersSchema,
+  createTranslator as createTranslator2,
   forensicReportSchema,
   parseKnowledgeId as parseKnowledgeId2,
   knowledgeTestIndexSchema as knowledgeTestIndexSchema2,
@@ -1583,7 +1639,8 @@ import {
   BOOTSTRAP_MARKER_END,
   BOOTSTRAP_REGEX,
   ONBOARD_SLOT_NAMES,
-  ONBOARD_SLOT_TOTAL
+  ONBOARD_SLOT_TOTAL,
+  resolveFabricLocale as resolveFabricLocale2
 } from "@fenglimg/fabric-shared";
 import { detectFramework } from "@fenglimg/fabric-shared/node";
 import { atomicWriteJson as atomicWriteJson2, atomicWriteText as atomicWriteText4 } from "@fenglimg/fabric-shared/node/atomic-write";
@@ -1669,6 +1726,7 @@ var TARGET_FILE_PATHS = [
 ];
 async function runDoctorReport(target) {
   const projectRoot = normalizeTarget(target);
+  const t = createTranslator2(resolveFabricLocale2(projectRoot));
   const framework = detectFramework(projectRoot);
   const entryPoints = collectEntryPoints(projectRoot);
   const [
@@ -1722,91 +1780,95 @@ async function runDoctorReport(target) {
   const skillMdYamlInvalid = inspectSkillMdYamlInvalid(projectRoot);
   const onboardCoverage = inspectOnboardCoverage(projectRoot);
   const checks = [
-    createBootstrapAnchorCheck(bootstrapAnchor),
+    createBootstrapAnchorCheck(t, bootstrapAnchor),
     // v2.0.0-rc.19 TASK-004: bootstrap marker migration check sits adjacent to
     // the anchor check — both are bootstrap-file invariants. fixable_error
     // when any of the four target paths still carries the legacy marker.
-    createBootstrapMarkerMigrationCheck(bootstrapMarkerMigration),
+    createBootstrapMarkerMigrationCheck(t, bootstrapMarkerMigration),
     // v2.0.0-rc.19 TASK-005: L1 + L2 byte-level drift detection sit immediately
     // after the marker migration check. Order: anchor existence → migration →
     // L1 (canonical ↔ snapshot) → L2 (snapshot+rules ↔ three-end blocks).
-    createL1BootstrapSnapshotDriftCheck(l1BootstrapSnapshotDrift),
-    createL2ManagedBlockDriftCheck(l2ManagedBlockDrift),
-    createKnowledgeDirMissingCheck(knowledgeDirMissing),
+    createL1BootstrapSnapshotDriftCheck(t, l1BootstrapSnapshotDrift),
+    createL2ManagedBlockDriftCheck(t, l2ManagedBlockDrift),
+    createKnowledgeDirMissingCheck(t, knowledgeDirMissing),
     // v2.0.0-rc.22 TASK-006: baseline filename format. Sits adjacent to
     // knowledge_dir_missing — both are knowledge-layout invariants. manual_error
     // kind; resolution is manual file deletion (rc.23 TASK-012 (F8a) removed
     // the baseline-emit pipeline, so no auto-fix exists).
-    createBaselineFilenameFormatCheck(baselineFilenameFormat),
-    createForensicCheck(forensic, framework.kind, entryPoints.length),
+    createBaselineFilenameFormatCheck(t, baselineFilenameFormat),
+    createForensicCheck(t, forensic, framework.kind, entryPoints.length),
     // v2.0: removed `createInitContextCheck` — `.fabric/init-context.json`
     // is owned by the AI-side client init skill, not by `fabric install` CLI.
     // The file's absence is a legitimate post-init state when the skill has
     // not yet run, so flagging it as a doctor manual_error misrepresents
     // ownership.
-    createMetaCheck(meta),
-    createRuleContentRefCheck(meta),
+    createMetaCheck(t, meta),
+    createRuleContentRefCheck(t, meta),
     // v2.0 / rc.2: `createRuleSectionsCheck` removed — it parsed v1.x
     // [MANDATORY_INJECTION] sections out of legacy rule files, a structural
     // concept that has no v2 equivalent. rc.4 will introduce a dedicated v2
     // lint suite for the new knowledge frontmatter contract.
-    createKnowledgeTestIndexCheck(knowledgeTestIndex),
-    createEventLedgerCheck(eventLedger),
-    createEventLedgerPartialWriteCheck(eventLedger),
-    createMcpConfigInWrongFileCheck(mcpConfigInWrongFile),
-    createMetaManuallyDivergedCheck(metaManuallyDiverged),
-    createKnowledgeDirUnindexedCheck(knowledgeDirUnindexed),
-    createStableIdCollisionCheck(stableIdCollision),
-    createCounterDesyncCheck(counterDesync),
-    createFilesystemEditFallbackCheck(filesystemEditFallback),
+    createKnowledgeTestIndexCheck(t, knowledgeTestIndex),
+    createEventLedgerCheck(t, eventLedger),
+    createEventLedgerPartialWriteCheck(t, eventLedger),
+    // v2.0.0-rc.27 TASK-010 (audit §2.24): forward-compat warning surface for
+    // events.jsonl rows that fail Zod validation because of unknown
+    // schema_version or event_type tokens. Previously silently dropped.
+    createEventLedgerSchemaCompatCheck(t, eventLedger),
+    createMcpConfigInWrongFileCheck(t, mcpConfigInWrongFile),
+    createMetaManuallyDivergedCheck(t, metaManuallyDiverged),
+    createKnowledgeDirUnindexedCheck(t, knowledgeDirUnindexed),
+    createStableIdCollisionCheck(t, stableIdCollision),
+    createCounterDesyncCheck(t, counterDesync),
+    createFilesystemEditFallbackCheck(t, filesystemEditFallback),
     // rc.4 TASK-001: read-side lint checks #16-18. Findings only — mutation
     // + event emission lands in TASK-003 behind --apply-lint.
-    createOrphanDemoteCheck(orphanDemote),
-    createStaleArchiveCheck(staleArchive),
-    createPendingOverdueCheck(pendingOverdue),
+    createOrphanDemoteCheck(t, orphanDemote),
+    createStaleArchiveCheck(t, staleArchive),
+    createPendingOverdueCheck(t, pendingOverdue),
     // rc.4 TASK-002: read-side integrity checks #19-21. Stable_id duplicate
     // runs first in this trio — it is the most critical integrity break and
     // surfaces ahead of layer-mismatch / index-drift in the report so a
     // human operator triages the collision before reasoning about counter
     // state. Index drift is the only fixable_error of the three; stable_id
     // duplicate and layer mismatch require manual triage (rename / move).
-    createStableIdDuplicateCheck(stableIdDuplicate),
-    createLayerMismatchCheck(layerMismatch),
-    createIndexDriftCheck(indexDrift),
+    createStableIdDuplicateCheck(t, stableIdDuplicate),
+    createLayerMismatchCheck(t, layerMismatch),
+    createIndexDriftCheck(t, indexDrift),
     // rc.5 TASK-010: read-side underseeded-corpus check (#22). Info kind —
     // does not bump report status. Recommends running the fabric-import skill
     // to backfill knowledge when the corpus is below the threshold floor.
-    createUnderseededCheck(underseeded),
+    createUnderseededCheck(t, underseeded),
     // rc.5 TASK-013 (C4): relevance_paths hygiene checks #23/#24/#25.
     // All three are flag-only in rc.5 (no apply-lint mutations).
     //   #23 narrow_no_paths        — warning kind (silent recall risk)
     //   #24 relevance_paths_dangling — warning kind (glob → zero matches)
     //   #25 relevance_paths_drift  — info kind (git-log heuristic; noisy)
-    createNarrowNoPathsCheck(narrowNoPaths),
-    createRelevancePathsDanglingCheck(relevancePathsDangling),
-    createRelevancePathsDriftCheck(relevancePathsDrift),
+    createNarrowNoPathsCheck(t, narrowNoPaths),
+    createRelevancePathsDanglingCheck(t, relevancePathsDangling),
+    createRelevancePathsDriftCheck(t, relevancePathsDrift),
     // rc.6 TASK-023 (E6): narrow_too_few (lint #26). Info kind; both arms
     // (structural + telemetry) recommend the same fabric-import action.
-    createNarrowTooFewCheck(narrowTooFew),
+    createNarrowTooFewCheck(t, narrowTooFew),
     // rc.6 TASK-021 (E3): session-hints cache hygiene (lint #27). Info kind.
-    createSessionHintsStaleCheck(sessionHintsStale),
+    createSessionHintsStaleCheck(t, sessionHintsStale),
     // rc.23 TASK-010 (e): stale .fabric/.serve.lock advisory. Info kind —
     // does not bump report status. `--fix` unlinks the corpse and emits
     // `serve_lock_cleared`.
-    createStaleServeLockCheck(staleServeLock),
+    createStaleServeLockCheck(t, staleServeLock),
     // v2.0.0-rc.9 TASK-003 (A3): relevance fields back-fill (lint #28).
     // Info kind — applies to pending entries only; canonical entries get
     // the fields written verbatim by fab_review.approve/modify.
-    createRelevanceFieldsMissingCheck(relevanceFieldsMissing),
+    createRelevanceFieldsMissingCheck(t, relevanceFieldsMissing),
     // rc.12 lint #29: skill_md_yaml_invalid. Warning kind — surfaces
     // SKILL.md frontmatter that Codex CLI silently drops at load.
-    createSkillMdYamlInvalidCheck(skillMdYamlInvalid),
+    createSkillMdYamlInvalidCheck(t, skillMdYamlInvalid),
     // v2.0.0-rc.23 TASK-014 (F8c): Onboard coverage advisory. Info kind.
     // Surfaces uncovered S5 onboard slots and recommends /fabric-archive
     // first-run phase. Sits adjacent to Skill markdown YAML — both are
     // Skill-adjacent advisories. --fix never mutates onboard state.
-    createOnboardCoverageCheck(onboardCoverage),
-    createPreexistingRootFilesCheck(preexistingRootFiles)
+    createOnboardCoverageCheck(t, onboardCoverage),
+    createPreexistingRootFilesCheck(t, preexistingRootFiles)
     // v2.0 / rc.2: `createLegacyClientPathCheck` removed. The schema now
     // rejects retired clientPaths keys (windsurf/rooCode/geminiCLI) at Zod
     // parse time, so the soft-deprecation warn-and-fix path no longer has a
@@ -1901,7 +1963,8 @@ async function runDoctorFix(target) {
     "knowledge_test_index_missing",
     "knowledge_test_index_stale",
     "content_ref_missing",
-    "knowledge_dir_unindexed"
+    "knowledge_dir_unindexed",
+    "meta_manually_diverged"
   ];
   if (before.fixable_errors.some((issue) => reconcileCodes.includes(issue.code)) || before.warnings.some((issue) => reconcileCodes.includes(issue.code))) {
     await reconcileKnowledge(projectRoot, { trigger: "doctor" });
@@ -2483,7 +2546,19 @@ async function inspectEventLedger(projectRoot) {
   const path2 = getEventLedgerPath(projectRoot);
   const exists = existsSync4(path2);
   if (!exists) {
-    return { exists: false, writable: false, parseable: false, hasPartialWrite: false, partialWriteByteOffset: 0, partialWriteByteLength: 0, path: path2 };
+    return {
+      exists: false,
+      writable: false,
+      parseable: false,
+      hasPartialWrite: false,
+      partialWriteByteOffset: 0,
+      partialWriteByteLength: 0,
+      schemaVersionUnsupportedCount: 0,
+      eventTypeUnknownCount: 0,
+      schemaVersionSamples: [],
+      eventTypeSamples: [],
+      path: path2
+    };
   }
   try {
     await access(path2, constants.W_OK);
@@ -2491,6 +2566,25 @@ async function inspectEventLedger(projectRoot) {
     const raw = await readFile5(path2, "utf8");
     const invalidLine = raw.split(/\r?\n/u).map((line) => line.trim()).filter(Boolean).find((line) => !isValidJsonLine(line));
     const partialWarning = warnings.find((w) => w.kind === "partial_write_at_tail");
+    const schemaVersionSamples = [];
+    const eventTypeSamples = [];
+    let schemaVersionUnsupportedCount = 0;
+    let eventTypeUnknownCount = 0;
+    for (const w of warnings) {
+      if (w.kind === "schema_version_unsupported") {
+        schemaVersionUnsupportedCount += 1;
+        const token = String(w.schema_version);
+        if (!schemaVersionSamples.includes(token) && schemaVersionSamples.length < 3) {
+          schemaVersionSamples.push(token);
+        }
+      } else if (w.kind === "event_type_unknown") {
+        eventTypeUnknownCount += 1;
+        const token = String(w.event_type);
+        if (!eventTypeSamples.includes(token) && eventTypeSamples.length < 3) {
+          eventTypeSamples.push(token);
+        }
+      }
+    }
     return {
       exists: true,
       writable: true,
@@ -2498,6 +2592,10 @@ async function inspectEventLedger(projectRoot) {
       hasPartialWrite: partialWarning !== void 0,
       partialWriteByteOffset: partialWarning?.byte_offset ?? 0,
       partialWriteByteLength: partialWarning?.byte_length ?? 0,
+      schemaVersionUnsupportedCount,
+      eventTypeUnknownCount,
+      schemaVersionSamples,
+      eventTypeSamples,
       path: path2,
       error: invalidLine === void 0 ? void 0 : "events.jsonl contains an invalid JSON line."
     };
@@ -2509,6 +2607,10 @@ async function inspectEventLedger(projectRoot) {
       hasPartialWrite: false,
       partialWriteByteOffset: 0,
       partialWriteByteLength: 0,
+      schemaVersionUnsupportedCount: 0,
+      eventTypeUnknownCount: 0,
+      schemaVersionSamples: [],
+      eventTypeSamples: [],
       path: path2,
       error: error instanceof Error ? error.message : String(error)
     };
@@ -2568,21 +2670,25 @@ async function inspectBootstrapMarkerMigration(target) {
   }
   return { filesNeedingMigration };
 }
-function createBootstrapMarkerMigrationCheck(inspection) {
+function createBootstrapMarkerMigrationCheck(t, inspection) {
   if (inspection.filesNeedingMigration.length === 0) {
     return okCheck(
-      "Bootstrap marker migration",
-      "No legacy fabric:knowledge-base markers detected in bootstrap target files."
+      t("doctor.check.bootstrap_marker_migration.name"),
+      t("doctor.check.bootstrap_marker_migration.ok")
     );
   }
   const list = inspection.filesNeedingMigration.join(", ");
+  const count = inspection.filesNeedingMigration.length;
   return issueCheck(
-    "Bootstrap marker migration",
+    t("doctor.check.bootstrap_marker_migration.name"),
     "error",
     "fixable_error",
     "bootstrap_marker_migration_required",
-    `${inspection.filesNeedingMigration.length} file${inspection.filesNeedingMigration.length === 1 ? "" : "s"} still carry the legacy fabric:knowledge-base bootstrap marker: ${list}.`,
-    "Run `fab doctor --fix` to migrate to fabric:bootstrap marker"
+    t(`doctor.check.bootstrap_marker_migration.message.${count === 1 ? "singular" : "plural"}`, {
+      count: String(count),
+      list
+    }),
+    t("doctor.check.bootstrap_marker_migration.remediation")
   );
 }
 async function inspectL1BootstrapSnapshotDrift(target) {
@@ -2601,20 +2707,20 @@ async function inspectL1BootstrapSnapshotDrift(target) {
   }
   return { status: "drift", canonical: BOOTSTRAP_CANONICAL, onDisk };
 }
-function createL1BootstrapSnapshotDriftCheck(inspection) {
+function createL1BootstrapSnapshotDriftCheck(t, inspection) {
   if (inspection.status === "drift") {
     return issueCheck(
-      "Bootstrap snapshot drift",
+      t("doctor.check.bootstrap_snapshot_drift.name"),
       "error",
       "fixable_error",
       "bootstrap_snapshot_drift",
-      ".fabric/AGENTS.md content diverges byte-for-byte from BOOTSTRAP_CANONICAL.",
-      "Run `fab doctor --fix` to restore canonical bootstrap snapshot"
+      t("doctor.check.bootstrap_snapshot_drift.message.drift"),
+      t("doctor.check.bootstrap_snapshot_drift.remediation.drift")
     );
   }
   return okCheck(
-    "Bootstrap snapshot drift",
-    inspection.status === "ok" ? ".fabric/AGENTS.md byte-equals BOOTSTRAP_CANONICAL." : ".fabric/AGENTS.md absent \u2014 delegated to bootstrap_anchor_missing."
+    t("doctor.check.bootstrap_snapshot_drift.name"),
+    inspection.status === "ok" ? t("doctor.check.bootstrap_snapshot_drift.ok.ok") : t("doctor.check.bootstrap_snapshot_drift.ok.missing_delegated")
   );
 }
 async function inspectL2ManagedBlockDrift(target) {
@@ -2706,39 +2812,46 @@ ${projectRules}`;
   }
   return { status: "drift", drifted };
 }
-function createL2ManagedBlockDriftCheck(inspection) {
+function createL2ManagedBlockDriftCheck(t, inspection) {
   if (inspection.status === "drift") {
     const list = inspection.drifted.map((d) => d.path).join(", ");
+    const count = inspection.drifted.length;
     return issueCheck(
-      "Managed block drift",
+      t("doctor.check.managed_block_drift.name"),
       "error",
       "fixable_error",
       "managed_block_drift",
-      `${inspection.drifted.length} three-end managed block${inspection.drifted.length === 1 ? "" : "s"} diverge from expected body (snapshot + optional project-rules concat): ${list}.`,
-      "Run `fab doctor --fix` to restore three-end managed blocks from canonical"
+      t(`doctor.check.managed_block_drift.message.${count === 1 ? "singular" : "plural"}`, {
+        count: String(count),
+        list
+      }),
+      t("doctor.check.managed_block_drift.remediation")
     );
   }
   return okCheck(
-    "Managed block drift",
-    inspection.status === "ok" ? "Three-end managed blocks byte-equal expectedBody." : "No three-end managed blocks detected \u2014 propagation pending or legacy-marker state."
+    t("doctor.check.managed_block_drift.name"),
+    inspection.status === "ok" ? t("doctor.check.managed_block_drift.ok.ok") : t("doctor.check.managed_block_drift.ok.no_managed_block")
   );
 }
-function createBootstrapAnchorCheck(inspection) {
+function createBootstrapAnchorCheck(t, inspection) {
   if (!inspection.hasAgentsMd && !inspection.hasClaudeMd) {
     return issueCheck(
-      "Bootstrap anchor",
+      t("doctor.check.bootstrap_anchor.name"),
       "error",
       "fixable_error",
       "bootstrap_anchor_missing",
-      "Neither AGENTS.md nor CLAUDE.md exists at the repo root. Fabric requires a bootstrap anchor file at the project root.",
-      "Run `fabric install` to generate the AGENTS.md / CLAUDE.md bootstrap anchor at the repo root."
+      t("doctor.check.bootstrap_anchor.message.missing"),
+      t("doctor.check.bootstrap_anchor.remediation.missing")
     );
   }
   const present = [
     inspection.hasAgentsMd ? "AGENTS.md" : null,
     inspection.hasClaudeMd ? "CLAUDE.md" : null
   ].filter((entry) => entry !== null).join(", ");
-  return okCheck("Bootstrap anchor", `Bootstrap anchor present at repo root: ${present}.`);
+  return okCheck(
+    t("doctor.check.bootstrap_anchor.name"),
+    t("doctor.check.bootstrap_anchor.ok", { present })
+  );
 }
 function inspectKnowledgeDirMissing(projectRoot) {
   const knowledgeRoot = join6(projectRoot, ".fabric", "knowledge");
@@ -2799,154 +2912,310 @@ function inspectBaselineFilenameFormat(projectRoot) {
   offenders.sort((a, b) => a.path.localeCompare(b.path));
   return { offenders };
 }
-function createBaselineFilenameFormatCheck(inspection) {
+function createBaselineFilenameFormatCheck(t, inspection) {
   if (inspection.offenders.length === 0) {
     return okCheck(
-      "Baseline filename format",
-      "All baseline knowledge files use the canonical `${id}--${slug}.md` filename format."
+      t("doctor.check.baseline_filename_format.name"),
+      t("doctor.check.baseline_filename_format.ok")
     );
   }
   const first = inspection.offenders[0];
   const detail = `${first.stable_id} at ${first.path}`;
+  const count = inspection.offenders.length;
   return issueCheck(
-    "Baseline filename format",
+    t("doctor.check.baseline_filename_format.name"),
     "error",
     "manual_error",
     "lint-baseline-filename-format",
-    `${inspection.offenders.length} baseline knowledge file${inspection.offenders.length === 1 ? "" : "s"} use${inspection.offenders.length === 1 ? "s" : ""} the deprecated bare-slug filename format and must be migrated to \`\${id}--\${slug}.md\`. First: ${detail}.`,
-    "Delete the legacy bare-slug baseline file(s) manually \u2014 the baseline pipeline was removed in rc.23 and is no longer an auto-fix path."
+    t(`doctor.check.baseline_filename_format.message.${count === 1 ? "singular" : "plural"}`, {
+      count: String(count),
+      detail
+    }),
+    t("doctor.check.baseline_filename_format.remediation")
   );
 }
-function createKnowledgeDirMissingCheck(inspection) {
+function createKnowledgeDirMissingCheck(t, inspection) {
   if (inspection.missingSubdirs.length > 0) {
     const list = inspection.missingSubdirs.join(", ");
+    const count = inspection.missingSubdirs.length;
     return issueCheck(
-      "Knowledge layout",
+      t("doctor.check.knowledge_dir_missing.name"),
       "error",
       "fixable_error",
       "knowledge_dir_missing",
-      `${inspection.missingSubdirs.length} required knowledge subdir${inspection.missingSubdirs.length === 1 ? " is" : "s are"} missing: ${list}.`,
-      "Run `fab doctor --fix` to create the missing .fabric/knowledge/* subdirectories."
+      t(`doctor.check.knowledge_dir_missing.message.${count === 1 ? "singular" : "plural"}`, {
+        count: String(count),
+        list
+      }),
+      t("doctor.check.knowledge_dir_missing.remediation")
     );
   }
   return okCheck(
-    "Knowledge layout",
-    `All ${KNOWLEDGE_SUBDIRS3.length} required .fabric/knowledge/* subdirectories exist.`
+    t("doctor.check.knowledge_dir_missing.name"),
+    t("doctor.check.knowledge_dir_missing.ok", { count: String(KNOWLEDGE_SUBDIRS3.length) })
   );
 }
-function createForensicCheck(forensic, frameworkKind, entryPointCount) {
+function createForensicCheck(t, forensic, frameworkKind, entryPointCount) {
   if (!forensic.present) {
     return issueCheck(
-      "Scan evidence",
+      t("doctor.check.forensic.name"),
       "error",
       "manual_error",
       "forensic_missing",
-      `${forensic.error ?? ".fabric/forensic.json is missing."} Live scan detects ${frameworkKind} with ${entryPointCount} entry point${entryPointCount === 1 ? "" : "s"}.`,
-      "Run `fab install` to regenerate .fabric/forensic.json."
+      t(`doctor.check.forensic.message.missing.${entryPointCount === 1 ? "singular" : "plural"}`, {
+        error: forensic.error ?? t("doctor.check.forensic.message.missing-default"),
+        frameworkKind,
+        count: String(entryPointCount)
+      }),
+      t("doctor.check.forensic.remediation")
     );
   }
   if (!forensic.valid) {
-    return issueCheck("Scan evidence", "error", "manual_error", "forensic_invalid", forensic.error ?? ".fabric/forensic.json is invalid.", "Run `fab install` to regenerate .fabric/forensic.json.");
+    return issueCheck(
+      t("doctor.check.forensic.name"),
+      "error",
+      "manual_error",
+      "forensic_invalid",
+      forensic.error ?? t("doctor.check.forensic.message.invalid-default"),
+      t("doctor.check.forensic.remediation")
+    );
   }
-  return okCheck("Scan evidence", `.fabric/forensic.json is valid for ${forensic.report?.framework.kind ?? "unknown"}.`);
+  return okCheck(
+    t("doctor.check.forensic.name"),
+    t("doctor.check.forensic.ok", { frameworkKind: forensic.report?.framework.kind ?? "unknown" })
+  );
 }
-function createMetaCheck(meta) {
+function createMetaCheck(t, meta) {
   if (!meta.present) {
-    return issueCheck("Agents metadata", "error", "fixable_error", "agents_meta_missing", ".fabric/agents.meta.json is missing.", "Run `fab doctor --fix` to rebuild agents.meta.json from .fabric/knowledge/.");
+    return issueCheck(
+      t("doctor.check.agents_meta.name"),
+      "error",
+      "fixable_error",
+      "agents_meta_missing",
+      t("doctor.check.agents_meta.message.missing"),
+      t("doctor.check.agents_meta.remediation.missing")
+    );
   }
   if (!meta.valid) {
-    return issueCheck("Agents metadata", "error", "manual_error", "agents_meta_invalid", meta.readError ?? ".fabric/agents.meta.json is invalid.", "Delete .fabric/agents.meta.json and run `fab doctor --fix` to regenerate it.");
+    return issueCheck(
+      t("doctor.check.agents_meta.name"),
+      "error",
+      "manual_error",
+      "agents_meta_invalid",
+      meta.readError ?? t("doctor.check.agents_meta.message.invalid-default"),
+      t("doctor.check.agents_meta.remediation.invalid")
+    );
   }
   if (meta.stale) {
     return issueCheck(
-      "Agents metadata",
+      t("doctor.check.agents_meta.name"),
       "warn",
       "warning",
       "agents_meta_stale",
-      `.fabric/agents.meta.json revision ${meta.revision} does not match .fabric/knowledge derived revision ${meta.computedRevision ?? "<unknown>"}.`,
-      "Benign \u2014 engine auto-heals on next plan-context/get-sections call. Run `fab doctor --fix` for explicit reconciliation."
+      t("doctor.check.agents_meta.message.stale", {
+        revision: meta.revision,
+        computedRevision: meta.computedRevision ?? "<unknown>"
+      }),
+      t("doctor.check.agents_meta.remediation.stale")
     );
   }
-  return okCheck("Agents metadata", `.fabric/agents.meta.json revision ${meta.revision} is aligned with .fabric/knowledge.`);
+  return okCheck(
+    t("doctor.check.agents_meta.name"),
+    t("doctor.check.agents_meta.ok", { revision: meta.revision })
+  );
 }
-function createRuleContentRefCheck(meta) {
+function createRuleContentRefCheck(t, meta) {
   if (!meta.valid) {
-    return issueCheck("Rule content refs", "error", "manual_error", "content_refs_unavailable", "Cannot inspect content_ref entries until agents.meta.json is valid.", "Fix agents.meta.json first: run `fab doctor --fix`.");
+    return issueCheck(
+      t("doctor.check.rule_content_refs.name"),
+      "error",
+      "manual_error",
+      "content_refs_unavailable",
+      t("doctor.check.rule_content_refs.message.unavailable"),
+      t("doctor.check.rule_content_refs.remediation.unavailable")
+    );
   }
   if (meta.invalidContentRefs.length > 0) {
+    const count = meta.invalidContentRefs.length;
     return issueCheck(
-      "Rule content refs",
+      t("doctor.check.rule_content_refs.name"),
       "error",
       "manual_error",
       "content_ref_outside_rules",
-      `${meta.invalidContentRefs.length} content_ref entr${meta.invalidContentRefs.length === 1 ? "y is" : "ies are"} outside .fabric/knowledge.`,
-      "Edit agents.meta.json to ensure all content_ref values point inside .fabric/knowledge/{type}/ (team) or ~/.fabric/knowledge/{type}/ (personal)."
+      t(`doctor.check.rule_content_refs.message.outside.${count === 1 ? "singular" : "plural"}`, {
+        count: String(count)
+      }),
+      t("doctor.check.rule_content_refs.remediation.outside")
     );
   }
   if (meta.missingContentRefs.length > 0) {
+    const count = meta.missingContentRefs.length;
     return issueCheck(
-      "Rule content refs",
+      t("doctor.check.rule_content_refs.name"),
       "error",
       "fixable_error",
       "content_ref_missing",
-      `${meta.missingContentRefs.length} content_ref target${meta.missingContentRefs.length === 1 ? "" : "s"} are missing. Run \`fab doctor --fix\` to reconcile.`,
-      "Run `fab doctor --fix` to reconcile agents.meta.json with the files present in .fabric/knowledge/."
+      t(`doctor.check.rule_content_refs.message.missing.${count === 1 ? "singular" : "plural"}`, {
+        count: String(count)
+      }),
+      t("doctor.check.rule_content_refs.remediation.missing")
     );
   }
-  return okCheck("Rule content refs", "All content_ref entries resolve to .fabric/knowledge files.");
+  return okCheck(t("doctor.check.rule_content_refs.name"), t("doctor.check.rule_content_refs.ok"));
 }
-function createKnowledgeTestIndexCheck(index) {
+function createKnowledgeTestIndexCheck(t, index) {
   if (!index.present) {
-    return issueCheck("Knowledge-test index", "error", "fixable_error", "knowledge_test_index_missing", index.error, "Run `fab doctor --fix` to rebuild .fabric/.cache/knowledge-test.index.json.");
+    return issueCheck(
+      t("doctor.check.knowledge_test_index.name"),
+      "error",
+      "fixable_error",
+      "knowledge_test_index_missing",
+      index.error,
+      t("doctor.check.knowledge_test_index.remediation.missing")
+    );
   }
   if (!index.valid) {
-    return issueCheck("Knowledge-test index", "error", "manual_error", "knowledge_test_index_invalid", index.error, "Delete .fabric/.cache/knowledge-test.index.json and run `fab doctor --fix` to regenerate it.");
+    return issueCheck(
+      t("doctor.check.knowledge_test_index.name"),
+      "error",
+      "manual_error",
+      "knowledge_test_index_invalid",
+      index.error,
+      t("doctor.check.knowledge_test_index.remediation.invalid")
+    );
   }
   if (index.stale) {
-    return issueCheck("Knowledge-test index", "error", "fixable_error", "knowledge_test_index_stale", ".fabric/.cache/knowledge-test.index.json is stale.", "Run `fab doctor --fix` to rebuild the knowledge-test index.");
+    return issueCheck(
+      t("doctor.check.knowledge_test_index.name"),
+      "error",
+      "fixable_error",
+      "knowledge_test_index_stale",
+      t("doctor.check.knowledge_test_index.message.stale"),
+      t("doctor.check.knowledge_test_index.remediation.stale")
+    );
   }
-  return okCheck("Knowledge-test index", `${index.linkCount} link${index.linkCount === 1 ? "" : "s"} and ${index.orphanCount} orphan annotation${index.orphanCount === 1 ? "" : "s"} indexed.`);
+  return okCheck(
+    t("doctor.check.knowledge_test_index.name"),
+    t(
+      `doctor.check.knowledge_test_index.ok.${index.linkCount === 1 ? "link_singular" : "link_plural"}.${index.orphanCount === 1 ? "orphan_singular" : "orphan_plural"}`,
+      { linkCount: String(index.linkCount), orphanCount: String(index.orphanCount) }
+    )
+  );
 }
-function createEventLedgerCheck(ledger) {
+function createEventLedgerCheck(t, ledger) {
   if (!ledger.exists) {
-    return issueCheck("Event ledger", "error", "fixable_error", "event_ledger_missing", ".fabric/events.jsonl is missing.", "Run `fab doctor --fix` to create .fabric/events.jsonl.");
+    return issueCheck(
+      t("doctor.check.event_ledger.name"),
+      "error",
+      "fixable_error",
+      "event_ledger_missing",
+      t("doctor.check.event_ledger.message.missing"),
+      t("doctor.check.event_ledger.remediation.missing")
+    );
   }
   if (!ledger.writable) {
-    return issueCheck("Event ledger", "error", "manual_error", "event_ledger_not_writable", ledger.error ?? ".fabric/events.jsonl is not writable.", "Check file permissions on .fabric/events.jsonl and ensure no other process holds a write lock.");
+    return issueCheck(
+      t("doctor.check.event_ledger.name"),
+      "error",
+      "manual_error",
+      "event_ledger_not_writable",
+      ledger.error ?? t("doctor.check.event_ledger.message.not_writable-default"),
+      t("doctor.check.event_ledger.remediation.not_writable")
+    );
   }
   if (!ledger.parseable) {
-    return issueCheck("Event ledger", "error", "manual_error", "event_ledger_invalid", ledger.error ?? ".fabric/events.jsonl is invalid.", "Delete .fabric/events.jsonl and run `fab doctor --fix` to recreate it.");
+    return issueCheck(
+      t("doctor.check.event_ledger.name"),
+      "error",
+      "manual_error",
+      "event_ledger_invalid",
+      ledger.error ?? t("doctor.check.event_ledger.message.invalid-default"),
+      t("doctor.check.event_ledger.remediation.invalid")
+    );
   }
-  return okCheck("Event ledger", ".fabric/events.jsonl exists, is writable, and is parseable.");
+  return okCheck(t("doctor.check.event_ledger.name"), t("doctor.check.event_ledger.ok"));
 }
-function createMcpConfigInWrongFileCheck(inspection) {
+function createMcpConfigInWrongFileCheck(t, inspection) {
   if (inspection.hasWrongEntry) {
     return issueCheck(
-      "Claude MCP config location",
+      t("doctor.check.mcp_config_in_wrong_file.name"),
       "error",
       "fixable_error",
       "mcp_config_in_wrong_file",
-      `.claude/settings.json contains mcpServers.fabric \u2014 this file is for hooks/permissions only. Run --fix to remove it, then re-run fab install to write .mcp.json.`,
-      "Run `fab doctor --fix` to remove mcpServers.fabric from .claude/settings.json, then run `fab install` to write .mcp.json."
+      t("doctor.check.mcp_config_in_wrong_file.message"),
+      t("doctor.check.mcp_config_in_wrong_file.remediation")
     );
   }
-  return okCheck("Claude MCP config location", "mcpServers.fabric is not in .claude/settings.json.");
+  return okCheck(
+    t("doctor.check.mcp_config_in_wrong_file.name"),
+    t("doctor.check.mcp_config_in_wrong_file.ok")
+  );
 }
-function createEventLedgerPartialWriteCheck(ledger) {
+function createEventLedgerSchemaCompatCheck(t, ledger) {
   if (!ledger.exists || !ledger.writable) {
-    return okCheck("Event ledger partial write", "No partial-write check needed (ledger missing or not writable).");
+    return okCheck(
+      t("doctor.check.event_ledger_schema_compat.name"),
+      t("doctor.check.event_ledger_schema_compat.ok.skipped")
+    );
+  }
+  const hasUnsupportedVersion = ledger.schemaVersionUnsupportedCount > 0;
+  const hasUnknownEventType = ledger.eventTypeUnknownCount > 0;
+  if (!hasUnsupportedVersion && !hasUnknownEventType) {
+    return okCheck(
+      t("doctor.check.event_ledger_schema_compat.name"),
+      t("doctor.check.event_ledger_schema_compat.ok.clean")
+    );
+  }
+  const parts = [];
+  if (hasUnsupportedVersion) {
+    parts.push(
+      t("doctor.check.event_ledger_schema_compat.message.schema_version", {
+        count: String(ledger.schemaVersionUnsupportedCount),
+        samples: ledger.schemaVersionSamples.join(", ")
+      })
+    );
+  }
+  if (hasUnknownEventType) {
+    parts.push(
+      t("doctor.check.event_ledger_schema_compat.message.event_type", {
+        count: String(ledger.eventTypeUnknownCount),
+        samples: ledger.eventTypeSamples.join(", ")
+      })
+    );
+  }
+  return issueCheck(
+    t("doctor.check.event_ledger_schema_compat.name"),
+    "warn",
+    "warning",
+    "event_ledger_schema_compat",
+    parts.join(" "),
+    t("doctor.check.event_ledger_schema_compat.remediation")
+  );
+}
+function createEventLedgerPartialWriteCheck(t, ledger) {
+  if (!ledger.exists || !ledger.writable) {
+    return okCheck(
+      t("doctor.check.event_ledger_partial_write.name"),
+      t("doctor.check.event_ledger_partial_write.ok.skipped")
+    );
   }
   if (ledger.hasPartialWrite) {
     return issueCheck(
-      "Event ledger partial write",
+      t("doctor.check.event_ledger_partial_write.name"),
       "error",
       "fixable_error",
       "event_ledger_partial_write",
-      `events.jsonl has a partial write at byte offset ${ledger.partialWriteByteOffset} (${ledger.partialWriteByteLength} corrupted bytes). Run --fix to truncate and preserve corrupted bytes.`,
-      "Run `fab doctor --fix` to truncate the partial write and restore events.jsonl to a valid state."
+      t("doctor.check.event_ledger_partial_write.message", {
+        byteOffset: String(ledger.partialWriteByteOffset),
+        byteLength: String(ledger.partialWriteByteLength)
+      }),
+      t("doctor.check.event_ledger_partial_write.remediation")
     );
   }
-  return okCheck("Event ledger partial write", "events.jsonl has no partial trailing write.");
+  return okCheck(
+    t("doctor.check.event_ledger_partial_write.name"),
+    t("doctor.check.event_ledger_partial_write.ok.clean")
+  );
 }
 function okCheck(name, message) {
   return { name, status: "ok", message };
@@ -2966,7 +3235,8 @@ function collectIssues(checks, kind) {
   return checks.filter((check) => check.kind === kind).map((check) => ({
     code: check.code ?? check.name,
     name: check.name,
-    message: check.message
+    message: check.message,
+    actionHint: check.actionHint
   }));
 }
 function findIssue(issues, code) {
@@ -3053,18 +3323,24 @@ function collectMdFilesUnder(out, projectRoot, rootDir, relPrefix) {
     }
   }
 }
-function createKnowledgeDirUnindexedCheck(inspection) {
+function createKnowledgeDirUnindexedCheck(t, inspection) {
   if (inspection.unindexedFiles.length > 0) {
+    const count = inspection.unindexedFiles.length;
     return issueCheck(
-      "Knowledge dir unindexed",
+      t("doctor.check.knowledge_dir_unindexed.name"),
       "error",
       "fixable_error",
       "knowledge_dir_unindexed",
-      `${inspection.unindexedFiles.length} .md file${inspection.unindexedFiles.length === 1 ? "" : "s"} in .fabric/knowledge/ not indexed in agents.meta.json. Run \`fab doctor --fix\` to index the missing knowledge files.`,
-      "Run `fab doctor --fix` to index the missing knowledge files."
+      t(`doctor.check.knowledge_dir_unindexed.message.${count === 1 ? "singular" : "plural"}`, {
+        count: String(count)
+      }),
+      t("doctor.check.knowledge_dir_unindexed.remediation")
     );
   }
-  return okCheck("Knowledge dir unindexed", "All .fabric/knowledge/ .md files are indexed in agents.meta.json.");
+  return okCheck(
+    t("doctor.check.knowledge_dir_unindexed.name"),
+    t("doctor.check.knowledge_dir_unindexed.ok")
+  );
 }
 async function inspectStableIdCollisions(projectRoot) {
   const found = [];
@@ -3147,7 +3423,7 @@ function inspectCounterDesync(meta) {
       ["guideline", "GLD"],
       ["pitfall", "PIT"],
       ["process", "PRO"]
-    ].find(([t2]) => t2 === parsed.type)?.[1];
+    ].find(([t]) => t === parsed.type)?.[1];
     if (typeCode === void 0) {
       continue;
     }
@@ -3175,61 +3451,84 @@ function inspectCounterDesync(meta) {
     correctedCounters: desyncs.length === 0 ? null : corrected
   };
 }
-function createCounterDesyncCheck(inspection) {
+function createCounterDesyncCheck(t, inspection) {
   if (inspection.desyncs.length > 0) {
     const first = inspection.desyncs[0];
-    const detail = `counters.${first.layer}.${first.type} = ${first.current} but observed K${first.layer === "KP" ? "P" : "T"}-${first.type}-${String(first.observed).padStart(4, "0")}`;
+    const observedId = `K${first.layer === "KP" ? "P" : "T"}-${first.type}-${String(first.observed).padStart(4, "0")}`;
+    const count = inspection.desyncs.length;
     return issueCheck(
-      "Knowledge counter desync",
+      t("doctor.check.counter_desync.name"),
       "error",
       "fixable_error",
       "counter_desync",
-      `${inspection.desyncs.length} knowledge counter${inspection.desyncs.length === 1 ? "" : "s"} desynced from observed stable_ids. ${detail}. Run \`fab doctor --fix\` to bump counters.`,
-      "Run `fab doctor --fix` to bump agents.meta.json counters to the maximum observed counter value."
+      t(`doctor.check.counter_desync.message.${count === 1 ? "singular" : "plural"}`, {
+        count: String(count),
+        counterPath: `counters.${first.layer}.${first.type}`,
+        current: String(first.current),
+        observedId
+      }),
+      t("doctor.check.counter_desync.remediation")
     );
   }
-  return okCheck("Knowledge counter desync", "agents.meta.json counters envelope is consistent with observed stable_ids.");
+  return okCheck(t("doctor.check.counter_desync.name"), t("doctor.check.counter_desync.ok"));
 }
-function createStableIdCollisionCheck(inspection) {
+function createStableIdCollisionCheck(t, inspection) {
   if (inspection.collisions.length > 0) {
     const first = inspection.collisions[0];
-    const detail = inspection.collisions.length === 1 ? `stable_id "${first.stable_id}" is declared in ${first.files.length} files: ${first.files.join(", ")}.` : `${inspection.collisions.length} stable_id collision${inspection.collisions.length === 1 ? "" : "s"} detected. First: "${first.stable_id}" in ${first.files.join(", ")}.`;
+    const count = inspection.collisions.length;
     return issueCheck(
-      "Stable ID collision",
+      t("doctor.check.stable_id_collision.name"),
       "warn",
       "warning",
       "stable_id_collision",
-      `${detail} Edit one of the knowledge files to use a unique stable_id.`,
-      "Edit one of the colliding knowledge files to declare a different `id: K[PT]-XXX-NNNN` frontmatter value."
+      t(`doctor.check.stable_id_collision.message.${count === 1 ? "singular" : "plural"}`, {
+        count: String(count),
+        stableId: first.stable_id,
+        fileCount: String(first.files.length),
+        files: first.files.join(", ")
+      }),
+      t("doctor.check.stable_id_collision.remediation")
     );
   }
-  return okCheck("Stable ID collision", "No declared stable_id collisions found in .fabric/knowledge/.");
+  return okCheck(t("doctor.check.stable_id_collision.name"), t("doctor.check.stable_id_collision.ok"));
 }
-function createMetaManuallyDivergedCheck(inspection) {
+function createMetaManuallyDivergedCheck(t, inspection) {
   if (!inspection.readable) {
-    return okCheck("Meta manual divergence", "agents.meta.json not readable; skipping divergence check.");
+    return okCheck(
+      t("doctor.check.meta_manually_diverged.name"),
+      t("doctor.check.meta_manually_diverged.ok.unreadable")
+    );
   }
   if (inspection.extraMetaEntries.length > 0) {
+    const count = inspection.extraMetaEntries.length;
     return issueCheck(
-      "Meta manual divergence",
+      t("doctor.check.meta_manually_diverged.name"),
       "warn",
       "warning",
       "meta_manually_diverged",
-      `agents.meta.json has ${inspection.extraMetaEntries.length} entr${inspection.extraMetaEntries.length === 1 ? "y" : "ies"} with no backing file on disk. Run --fix to reconcile.`,
-      "Run `fab doctor --fix` to reconcile agents.meta.json with the rule files currently on disk."
+      t(`doctor.check.meta_manually_diverged.message.extra.${count === 1 ? "singular" : "plural"}`, {
+        count: String(count)
+      }),
+      t("doctor.check.meta_manually_diverged.remediation.extra")
     );
   }
   if (inspection.hashMismatchEntries.length > 0) {
+    const count = inspection.hashMismatchEntries.length;
     return issueCheck(
-      "Meta manual divergence",
+      t("doctor.check.meta_manually_diverged.name"),
       "warn",
       "warning",
       "meta_manually_diverged",
-      `agents.meta.json has ${inspection.hashMismatchEntries.length} entr${inspection.hashMismatchEntries.length === 1 ? "y" : "ies"} whose hash does not match the file on disk. Run --fix to reconcile.`,
-      "Run `fab doctor --fix` to reconcile agents.meta.json with the current rule file contents."
+      t(`doctor.check.meta_manually_diverged.message.hash.${count === 1 ? "singular" : "plural"}`, {
+        count: String(count)
+      }),
+      t("doctor.check.meta_manually_diverged.remediation.hash")
     );
   }
-  return okCheck("Meta manual divergence", "agents.meta.json is consistent with rule files on disk.");
+  return okCheck(
+    t("doctor.check.meta_manually_diverged.name"),
+    t("doctor.check.meta_manually_diverged.ok.consistent")
+  );
 }
 function inspectPreexistingRootFiles(projectRoot) {
   const candidates = ["CLAUDE.md", "AGENTS.md"];
@@ -3295,36 +3594,44 @@ async function inspectFilesystemEditFallback(projectRoot) {
   }
   return { synthesized: orphanIds.length, synthesizedStableIds: orphanIds };
 }
-function createFilesystemEditFallbackCheck(inspection) {
+function createFilesystemEditFallbackCheck(t, inspection) {
   if (inspection.synthesized === 0) {
     return okCheck(
-      "Filesystem-edit fallback",
-      "No orphan canonical knowledge entries detected; events.jsonl promotion trail is complete."
+      t("doctor.check.filesystem_edit_fallback.name"),
+      t("doctor.check.filesystem_edit_fallback.ok")
     );
   }
   const sample = inspection.synthesizedStableIds.slice(0, 3).join(", ");
   return {
-    name: "Filesystem-edit fallback",
+    name: t("doctor.check.filesystem_edit_fallback.name"),
     status: "ok",
     kind: "info",
     code: "knowledge_promoted_synthesized",
     fixable: false,
-    message: `Synthesized ${inspection.synthesized} knowledge_promoted event${inspection.synthesized === 1 ? "" : "s"} for orphan canonical entries (${sample}${inspection.synthesizedStableIds.length > 3 ? ", ..." : ""}). Reason='${SYNTHESIZED_PROMOTED_REASON}'.`,
-    actionHint: "These entries were moved into .fabric/knowledge/<type>/ outside fab_review.approve. The synthesized events restore audit-trail completeness."
+    message: t(
+      `doctor.check.filesystem_edit_fallback.message.synthesized.${inspection.synthesized === 1 ? "singular" : "plural"}`,
+      {
+        count: String(inspection.synthesized),
+        sample,
+        suffix: inspection.synthesizedStableIds.length > 3 ? ", ..." : "",
+        reason: SYNTHESIZED_PROMOTED_REASON
+      }
+    ),
+    actionHint: t("doctor.check.filesystem_edit_fallback.remediation.synthesized")
   };
 }
-function createPreexistingRootFilesCheck(inspection) {
+function createPreexistingRootFilesCheck(t, inspection) {
   if (inspection.detected.length === 0) {
-    return okCheck("Preexisting root markdown", "No CLAUDE.md or AGENTS.md detected at project root.");
+    return okCheck(t("doctor.check.preexisting_root_files.name"), t("doctor.check.preexisting_root_files.ok"));
   }
   return {
-    name: "Preexisting root markdown",
+    name: t("doctor.check.preexisting_root_files.name"),
     status: "ok",
     kind: "info",
     code: "preexisting_root_claude_md",
     fixable: false,
-    message: `${inspection.detected.join(", ")} detected at project root. These root files are not auto-loaded by Fabric MCP.`,
-    actionHint: "Move knowledge content to `.fabric/knowledge/{type}/` if you want it available in MCP responses."
+    message: t("doctor.check.preexisting_root_files.message", { files: inspection.detected.join(", ") }),
+    actionHint: t("doctor.check.preexisting_root_files.remediation")
   };
 }
 async function buildLastConsumedIndex(projectRoot) {
@@ -3822,114 +4129,156 @@ function readUnderseedThresholdFromConfig(projectRoot) {
   }
   return DEFAULT_UNDERSEED_NODE_THRESHOLD;
 }
-function createOrphanDemoteCheck(inspection) {
+function createOrphanDemoteCheck(t, inspection) {
   if (inspection.candidates.length === 0) {
     return okCheck(
-      "Knowledge orphan demote",
-      "No canonical knowledge entries exceed their maturity-keyed inactivity threshold."
+      t("doctor.check.orphan_demote.name"),
+      t("doctor.check.orphan_demote.ok")
     );
   }
   const first = inspection.candidates[0];
   const detail = `${first.stable_id} (${first.maturity}, ${first.age_days}d inactive at ${first.path})`;
+  const count = inspection.candidates.length;
   return issueCheck(
-    "Knowledge orphan demote",
+    t("doctor.check.orphan_demote.name"),
     "warn",
     "warning",
     "knowledge_orphan_demote_required",
-    `${inspection.candidates.length} canonical knowledge entr${inspection.candidates.length === 1 ? "y exceeds" : "ies exceed"} their maturity-keyed inactivity threshold (stable=${ORPHAN_DEMOTE_THRESHOLD_DAYS.stable}d / endorsed=${ORPHAN_DEMOTE_THRESHOLD_DAYS.endorsed}d / draft=${ORPHAN_DEMOTE_THRESHOLD_DAYS.draft}d). First: ${detail}.`,
-    "Run `fab doctor --apply-lint` (rc.4 TASK-003) to demote orphan entries one maturity tier."
+    t(`doctor.check.orphan_demote.message.${count === 1 ? "singular" : "plural"}`, {
+      count: String(count),
+      stableDays: String(ORPHAN_DEMOTE_THRESHOLD_DAYS.stable),
+      endorsedDays: String(ORPHAN_DEMOTE_THRESHOLD_DAYS.endorsed),
+      draftDays: String(ORPHAN_DEMOTE_THRESHOLD_DAYS.draft),
+      detail
+    }),
+    t("doctor.check.orphan_demote.remediation")
   );
 }
-function createStaleArchiveCheck(inspection) {
+function createStaleArchiveCheck(t, inspection) {
   if (inspection.candidates.length === 0) {
     return okCheck(
-      "Knowledge stale archive",
-      "No draft knowledge entries exceed the additional stale-archive quiet window."
+      t("doctor.check.stale_archive.name"),
+      t("doctor.check.stale_archive.ok")
     );
   }
   const first = inspection.candidates[0];
   const detail = `${first.stable_id} (${first.age_days}d inactive at ${first.path}) \u2192 ${first.archive_path}`;
+  const count = inspection.candidates.length;
   return issueCheck(
-    "Knowledge stale archive",
+    t("doctor.check.stale_archive.name"),
     "warn",
     "warning",
     "knowledge_stale_archive_required",
-    `${inspection.candidates.length} draft knowledge entr${inspection.candidates.length === 1 ? "y is" : "ies are"} stale beyond the demote+${STALE_ARCHIVE_ADDITIONAL_DAYS}d additional quiet window. First: ${detail}.`,
-    "Run `fab doctor --apply-lint` (rc.4 TASK-003) to move stale entries into `.fabric/.archive/<type>/`."
+    t(`doctor.check.stale_archive.message.${count === 1 ? "singular" : "plural"}`, {
+      count: String(count),
+      additionalDays: String(STALE_ARCHIVE_ADDITIONAL_DAYS),
+      detail
+    }),
+    t("doctor.check.stale_archive.remediation")
   );
 }
-function createPendingOverdueCheck(inspection) {
+function createPendingOverdueCheck(t, inspection) {
   if (inspection.candidates.length === 0) {
     return okCheck(
-      "Knowledge pending overdue",
-      "No pending knowledge entries exceed the 14-day review threshold."
+      t("doctor.check.pending_overdue.name"),
+      t("doctor.check.pending_overdue.ok")
     );
   }
   const first = inspection.candidates[0];
   const detail = `${first.path} (${first.age_days}d old)`;
+  const count = inspection.candidates.length;
   return issueCheck(
-    "Knowledge pending overdue",
+    t("doctor.check.pending_overdue.name"),
     "warn",
     "warning",
     "knowledge_pending_overdue",
-    `${inspection.candidates.length} pending knowledge entr${inspection.candidates.length === 1 ? "y has" : "ies have"} been awaiting review for more than ${PENDING_OVERDUE_THRESHOLD_DAYS} days. First: ${detail}.`,
-    "Review pending entries via the fabric-review Skill (`/fabric-review`) and approve, reject, defer, or modify."
+    t(`doctor.check.pending_overdue.message.${count === 1 ? "singular" : "plural"}`, {
+      count: String(count),
+      thresholdDays: String(PENDING_OVERDUE_THRESHOLD_DAYS),
+      detail
+    }),
+    t("doctor.check.pending_overdue.remediation")
   );
 }
-function createUnderseededCheck(inspection) {
+function createUnderseededCheck(t, inspection) {
   if (!inspection.underseeded) {
     return okCheck(
-      "Knowledge underseeded",
-      `Knowledge corpus has ${inspection.node_count} canonical entries (>= ${inspection.threshold}).`
+      t("doctor.check.underseeded.name"),
+      t("doctor.check.underseeded.ok", {
+        count: String(inspection.node_count),
+        threshold: String(inspection.threshold)
+      })
     );
   }
   return issueCheck(
-    "Knowledge underseeded",
+    t("doctor.check.underseeded.name"),
     "ok",
     "info",
     "knowledge_underseeded",
-    `Knowledge corpus has only ${inspection.node_count} canonical entr${inspection.node_count === 1 ? "y" : "ies"} (< ${inspection.threshold} threshold). The plan_context retrieval surface is below its useful floor.`,
-    "Run the fabric-import Skill (`/fabric-import`) to backfill knowledge from git history and existing docs."
+    t(`doctor.check.underseeded.message.${inspection.node_count === 1 ? "singular" : "plural"}`, {
+      count: String(inspection.node_count),
+      threshold: String(inspection.threshold)
+    }),
+    t("doctor.check.underseeded.remediation")
   );
 }
-function createSessionHintsStaleCheck(inspection) {
+function createSessionHintsStaleCheck(t, inspection) {
   if (inspection.candidates.length === 0) {
     return okCheck(
-      "Knowledge session-hints stale",
-      `No session-hints cache files older than ${SESSION_HINTS_STALE_DAYS} days under .fabric/.cache/.`
+      t("doctor.check.session_hints_stale.name"),
+      t("doctor.check.session_hints_stale.ok", {
+        days: String(SESSION_HINTS_STALE_DAYS)
+      })
     );
   }
   const first = inspection.candidates[0];
   const detail = `${first.path} (${first.age_days}d old)`;
+  const count = inspection.candidates.length;
   return issueCheck(
-    "Knowledge session-hints stale",
+    t("doctor.check.session_hints_stale.name"),
     "ok",
     "info",
     "knowledge_session_hints_stale",
-    `${inspection.candidates.length} session-hints cache file${inspection.candidates.length === 1 ? "" : "s"} under .fabric/.cache/ ${inspection.candidates.length === 1 ? "is" : "are"} older than ${SESSION_HINTS_STALE_DAYS} days. First: ${detail}.`,
-    "Run `fab doctor --apply-lint` to delete stale session-hints cache files."
+    t(`doctor.check.session_hints_stale.message.${count === 1 ? "singular" : "plural"}`, {
+      count: String(count),
+      days: String(SESSION_HINTS_STALE_DAYS),
+      detail
+    }),
+    t("doctor.check.session_hints_stale.remediation")
   );
 }
-function createStaleServeLockCheck(inspection) {
+function createStaleServeLockCheck(t, inspection) {
   if (!inspection.present) {
-    return okCheck("Serve lock", "No .fabric/.serve.lock present.");
+    return okCheck(
+      t("doctor.check.stale_serve_lock.name"),
+      t("doctor.check.stale_serve_lock.ok.no_lock")
+    );
   }
   if (inspection.pidAlive) {
     return okCheck(
-      "Serve lock",
-      `.fabric/.serve.lock held by live PID ${inspection.pid}.`
+      t("doctor.check.stale_serve_lock.name"),
+      t("doctor.check.stale_serve_lock.ok.live_pid", {
+        pid: String(inspection.pid)
+      })
     );
   }
   const days = Math.floor(inspection.ageMs / MS_PER_DAY);
   const hours = Math.floor(inspection.ageMs / (60 * 60 * 1e3));
-  const acquiredAgo = days >= 1 ? `${days} day${days === 1 ? "" : "s"} ago` : `${hours} hour${hours === 1 ? "" : "s"} ago`;
+  const acquiredAgo = days >= 1 ? t(`doctor.check.stale_serve_lock.age.day.${days === 1 ? "singular" : "plural"}`, {
+    count: String(days)
+  }) : t(`doctor.check.stale_serve_lock.age.hour.${hours === 1 ? "singular" : "plural"}`, {
+    count: String(hours)
+  });
   return issueCheck(
-    "Serve lock",
+    t("doctor.check.stale_serve_lock.name"),
     "ok",
     "info",
     "stale_serve_lock",
-    `[advisory] .fabric/.serve.lock holds dead PID ${inspection.pid} (acquired ${acquiredAgo}). Run \`fab doctor --fix\` to remove.`,
-    "Run `fab doctor --fix` to remove the stale .fabric/.serve.lock."
+    t("doctor.check.stale_serve_lock.message.dead_pid", {
+      pid: String(inspection.pid),
+      acquiredAgo
+    }),
+    t("doctor.check.stale_serve_lock.remediation.dead_pid")
   );
 }
 function extractKnowledgeFrontmatterRelevanceScope(source) {
@@ -4128,64 +4477,81 @@ function readRecentGitTouchedPaths(projectRoot, windowDays) {
   }
   return Array.from(set);
 }
-function createNarrowNoPathsCheck(inspection) {
+function createNarrowNoPathsCheck(t, inspection) {
   if (inspection.candidates.length === 0) {
     return okCheck(
-      "Knowledge narrow without paths",
-      "No narrow-scope canonical entries have an empty relevance_paths array."
+      t("doctor.check.narrow_no_paths.name"),
+      t("doctor.check.narrow_no_paths.ok")
     );
   }
   const first = inspection.candidates[0];
   const detail = `${first.stable_id} (${first.path})`;
+  const count = inspection.candidates.length;
   return issueCheck(
-    "Knowledge narrow without paths",
+    t("doctor.check.narrow_no_paths.name"),
     "warn",
     "warning",
     "knowledge_narrow_no_paths",
-    `${inspection.candidates.length} narrow-scope canonical entr${inspection.candidates.length === 1 ? "y has" : "ies have"} an empty relevance_paths array (silent recall risk \u2014 narrow without anchors can never match a target path). First: ${detail}.`,
-    "Either add path anchors to relevance_paths or widen the entry's relevance_scope to broad."
+    t(`doctor.check.narrow_no_paths.message.${count === 1 ? "singular" : "plural"}`, {
+      count: String(count),
+      detail
+    }),
+    t("doctor.check.narrow_no_paths.remediation")
   );
 }
-function createRelevancePathsDanglingCheck(inspection) {
+function createRelevancePathsDanglingCheck(t, inspection) {
   if (inspection.entries.length === 0) {
     return okCheck(
-      "Knowledge relevance_paths dangling",
-      "All relevance_paths globs resolve to at least one file under the workspace root."
+      t("doctor.check.relevance_paths_dangling.name"),
+      t("doctor.check.relevance_paths_dangling.ok")
     );
   }
   const first = inspection.entries[0];
   const detail = `${first.stable_id} at ${first.path} \u2192 \`${first.dangling_glob}\` (0 matches)`;
+  const count = inspection.entries.length;
   return issueCheck(
-    "Knowledge relevance_paths dangling",
+    t("doctor.check.relevance_paths_dangling.name"),
     "warn",
     "warning",
     "knowledge_relevance_paths_dangling",
-    `${inspection.entries.length} relevance_paths glob${inspection.entries.length === 1 ? " resolves" : "s resolve"} to zero files in the current workspace. First: ${detail}.`,
-    "Update the entry's relevance_paths to remove globs that no longer match any files, or use `fab_review.modify` to rewrite the anchor set."
+    t(`doctor.check.relevance_paths_dangling.message.${count === 1 ? "singular" : "plural"}`, {
+      count: String(count),
+      detail
+    }),
+    t("doctor.check.relevance_paths_dangling.remediation")
   );
 }
-function createRelevancePathsDriftCheck(inspection) {
+function createRelevancePathsDriftCheck(t, inspection) {
   if (!inspection.git_available) {
     return okCheck(
-      "Knowledge relevance_paths drift",
-      `Skipped (git history unavailable; cannot evaluate ${RELEVANCE_PATHS_DRIFT_WINDOW_DAYS}d drift window).`
+      t("doctor.check.relevance_paths_drift.name"),
+      t("doctor.check.relevance_paths_drift.ok.skipped", {
+        windowDays: String(RELEVANCE_PATHS_DRIFT_WINDOW_DAYS)
+      })
     );
   }
   if (inspection.candidates.length === 0) {
     return okCheck(
-      "Knowledge relevance_paths drift",
-      `All narrow-scope canonical entries have at least one relevance_path touched in the last ${RELEVANCE_PATHS_DRIFT_WINDOW_DAYS}d.`
+      t("doctor.check.relevance_paths_drift.name"),
+      t("doctor.check.relevance_paths_drift.ok.fresh", {
+        windowDays: String(RELEVANCE_PATHS_DRIFT_WINDOW_DAYS)
+      })
     );
   }
   const first = inspection.candidates[0];
   const detail = `${first.stable_id} at ${first.path} (globs: ${first.globs.join(", ")})`;
+  const count = inspection.candidates.length;
   return issueCheck(
-    "Knowledge relevance_paths drift",
+    t("doctor.check.relevance_paths_drift.name"),
     "ok",
     "info",
     "knowledge_relevance_paths_drift",
-    `${inspection.candidates.length} narrow-scope canonical entr${inspection.candidates.length === 1 ? "y has" : "ies have"} relevance_paths whose globs match no file touched in the last ${RELEVANCE_PATHS_DRIFT_WINDOW_DAYS}d of git history. First: ${detail}.`,
-    "Review whether the entry is still relevant \u2014 use `fab_review.modify` to refresh the anchors or `fab_review.reject` to archive."
+    t(`doctor.check.relevance_paths_drift.message.${count === 1 ? "singular" : "plural"}`, {
+      count: String(count),
+      windowDays: String(RELEVANCE_PATHS_DRIFT_WINDOW_DAYS),
+      detail
+    }),
+    t("doctor.check.relevance_paths_drift.remediation")
   );
 }
 function inspectRelevanceFieldsMissing(projectRoot) {
@@ -4328,11 +4694,11 @@ async function applyRelevanceFieldsMissing(candidate) {
     };
   }
 }
-function createRelevanceFieldsMissingCheck(inspection) {
+function createRelevanceFieldsMissingCheck(t, inspection) {
   if (inspection.candidates.length === 0) {
     return okCheck(
-      "Knowledge relevance fields missing",
-      "All pending entries declare both relevance_scope and relevance_paths."
+      t("doctor.check.relevance_fields_missing.name"),
+      t("doctor.check.relevance_fields_missing.ok")
     );
   }
   const first = inspection.candidates[0];
@@ -4340,13 +4706,17 @@ function createRelevanceFieldsMissingCheck(inspection) {
   if (first.missing_scope) missingParts.push("relevance_scope");
   if (first.missing_paths) missingParts.push("relevance_paths");
   const detail = `${first.pending_path} (missing: ${missingParts.join(", ")})`;
+  const count = inspection.candidates.length;
   return issueCheck(
-    "Knowledge relevance fields missing",
+    t("doctor.check.relevance_fields_missing.name"),
     "ok",
     "info",
     "knowledge_relevance_fields_missing",
-    `${inspection.candidates.length} pending entr${inspection.candidates.length === 1 ? "y is" : "ies are"} missing relevance_scope and/or relevance_paths in frontmatter. First: ${detail}.`,
-    "Run `fab doctor --apply-lint` to back-fill the schema defaults (relevance_scope: broad, relevance_paths: [])."
+    t(`doctor.check.relevance_fields_missing.message.${count === 1 ? "singular" : "plural"}`, {
+      count: String(count),
+      detail
+    }),
+    t("doctor.check.relevance_fields_missing.remediation")
   );
 }
 var SKILL_MD_FRONTMATTER_ROOTS = [".claude/skills", ".codex/skills"];
@@ -4417,23 +4787,26 @@ function extractSkillFrontmatterLines(raw) {
   }
   return null;
 }
-function createSkillMdYamlInvalidCheck(inspection) {
+function createSkillMdYamlInvalidCheck(t, inspection) {
   if (inspection.candidates.length === 0) {
     return okCheck(
-      "Skill markdown YAML",
-      "All .claude/.codex SKILL.md frontmatter values parse as strict YAML."
+      t("doctor.check.skill_md_yaml_invalid.name"),
+      t("doctor.check.skill_md_yaml_invalid.ok")
     );
   }
   const first = inspection.candidates[0];
   const detail = `${first.path}:${first.line} (key \`${first.key}\` value contains an unquoted ': ' \u2014 preview: \`${first.preview}\`)`;
   const plural = inspection.candidates.length === 1;
   return issueCheck(
-    "Skill markdown YAML",
+    t("doctor.check.skill_md_yaml_invalid.name"),
     "warn",
     "warning",
     "skill_md_yaml_invalid",
-    `${inspection.candidates.length} SKILL.md frontmatter ${plural ? "value contains" : "values contain"} an unquoted ': ' that strict YAML parsers reject (Claude Code tolerates it; Codex CLI drops the skill at load). First: ${detail}.`,
-    'Quote the value with double quotes (`description: "\u2026"`) or rewrite the inner `key: value` token to `key=value`.'
+    t(`doctor.check.skill_md_yaml_invalid.message.${plural ? "singular" : "plural"}`, {
+      count: String(inspection.candidates.length),
+      detail
+    }),
+    t("doctor.check.skill_md_yaml_invalid.remediation")
   );
 }
 var KNOWLEDGE_CANONICAL_TYPE_DIRS_FOR_ONBOARD = [
@@ -4528,55 +4901,83 @@ function readFrontmatterScalar(content, key) {
   }
   return void 0;
 }
-function createOnboardCoverageCheck(inspection) {
+function createOnboardCoverageCheck(t, inspection) {
   const filledCount = ONBOARD_SLOT_NAMES.filter(
     (slot) => inspection.filled[slot].length > 0
   ).length;
   if (inspection.missing.length === 0) {
     return okCheck(
-      "Onboard coverage",
-      `Onboard coverage: ${filledCount}/${ONBOARD_SLOT_TOTAL} \u2713 (opted-out: ${inspection.opted_out.length}).`
+      t("doctor.check.onboard_coverage.name"),
+      t("doctor.check.onboard_coverage.ok.complete", {
+        filledCount: String(filledCount),
+        total: String(ONBOARD_SLOT_TOTAL),
+        optedOutCount: String(inspection.opted_out.length)
+      })
     );
   }
   return issueCheck(
-    "Onboard coverage",
+    t("doctor.check.onboard_coverage.name"),
     "ok",
     "info",
     "onboard_coverage_incomplete",
-    `Onboard slots not yet covered: [${inspection.missing.join(", ")}]. ${filledCount}/${ONBOARD_SLOT_TOTAL} filled; ${inspection.opted_out.length} opted-out.`,
-    "Run /fabric-archive to onboard \u2014 the Skill's first-run phase will tour the project and propose pending entries for each unclaimed slot."
+    t("doctor.check.onboard_coverage.message.incomplete", {
+      missingSlots: inspection.missing.join(", "),
+      filledCount: String(filledCount),
+      total: String(ONBOARD_SLOT_TOTAL),
+      optedOutCount: String(inspection.opted_out.length)
+    }),
+    t("doctor.check.onboard_coverage.remediation.incomplete")
   );
 }
-function createNarrowTooFewCheck(inspection) {
+function createNarrowTooFewCheck(t, inspection) {
   const { structural_flagged, telemetry_flagged } = inspection;
   if (!structural_flagged && !telemetry_flagged) {
     const ratioPct = (inspection.narrow_ratio * 100).toFixed(0);
-    const teleNote = inspection.telemetry_skipped ? "telemetry skipped (no edit-counter fires in window)" : `silence rate ${(inspection.silence_rate * 100).toFixed(0)}% over ${SILENCE_WINDOW_DAYS}d`;
+    const teleNote = inspection.telemetry_skipped ? t("doctor.check.narrow_too_few.message.telemetry_skipped") : t("doctor.check.narrow_too_few.message.telemetry_window", {
+      silencePct: (inspection.silence_rate * 100).toFixed(0),
+      windowDays: String(SILENCE_WINDOW_DAYS)
+    });
     return okCheck(
-      "Knowledge narrow too few",
-      `Narrow-with-paths ratio ${ratioPct}% (${inspection.narrow_with_paths_count}/${inspection.total_canonical_entries}); ${teleNote}.`
+      t("doctor.check.narrow_too_few.name"),
+      t("doctor.check.narrow_too_few.ok", {
+        ratioPct,
+        narrowCount: String(inspection.narrow_with_paths_count),
+        totalCount: String(inspection.total_canonical_entries),
+        teleNote
+      })
     );
   }
   const parts = [];
   if (structural_flagged) {
     const ratioPct = (inspection.narrow_ratio * 100).toFixed(0);
     parts.push(
-      `narrow-with-paths share ${ratioPct}% (${inspection.narrow_with_paths_count}/${inspection.total_canonical_entries}) below ${(NARROW_RATIO_THRESHOLD * 100).toFixed(0)}% threshold`
+      t("doctor.check.narrow_too_few.message.structural", {
+        ratioPct,
+        narrowCount: String(inspection.narrow_with_paths_count),
+        totalCount: String(inspection.total_canonical_entries),
+        thresholdPct: (NARROW_RATIO_THRESHOLD * 100).toFixed(0)
+      })
     );
   }
   if (telemetry_flagged) {
     const silencePct = (inspection.silence_rate * 100).toFixed(0);
     parts.push(
-      `narrow-hook silence rate ${silencePct}% (${inspection.silence_fires_in_window}/${inspection.total_edit_fires_in_window}) over ${SILENCE_WINDOW_DAYS}d above ${(SILENCE_RATE_THRESHOLD * 100).toFixed(0)}% threshold`
+      t("doctor.check.narrow_too_few.message.telemetry", {
+        silencePct,
+        silenceFires: String(inspection.silence_fires_in_window),
+        totalFires: String(inspection.total_edit_fires_in_window),
+        windowDays: String(SILENCE_WINDOW_DAYS),
+        thresholdPct: (SILENCE_RATE_THRESHOLD * 100).toFixed(0)
+      })
     );
   }
   return issueCheck(
-    "Knowledge narrow too few",
+    t("doctor.check.narrow_too_few.name"),
     "ok",
     "info",
     "knowledge_narrow_too_few",
-    `Narrow-scope KB coverage is below the useful floor: ${parts.join("; ")}.`,
-    "Run the fabric-import Skill (`/fabric-import`) to re-seed narrow anchors against the current codebase."
+    t("doctor.check.narrow_too_few.message.summary", { parts: parts.join("; ") }),
+    t("doctor.check.narrow_too_few.remediation")
   );
 }
 function resolvePersonalKnowledgeRoot() {
@@ -4713,58 +5114,70 @@ function inspectIndexDrift(projectRoot, meta) {
   );
   return { drifts };
 }
-function createStableIdDuplicateCheck(inspection) {
+function createStableIdDuplicateCheck(t, inspection) {
   if (inspection.duplicates.length === 0) {
     return okCheck(
-      "Knowledge stable_id duplicate",
-      "No canonical knowledge files share a stable_id across team / personal trees."
+      t("doctor.check.stable_id_duplicate.name"),
+      t("doctor.check.stable_id_duplicate.ok")
     );
   }
   const first = inspection.duplicates[0];
   const detail = `${first.stable_id} appears in ${first.paths.length} files: ${first.paths.join(", ")}`;
+  const count = inspection.duplicates.length;
   return issueCheck(
-    "Knowledge stable_id duplicate",
+    t("doctor.check.stable_id_duplicate.name"),
     "error",
     "manual_error",
     "knowledge_stable_id_duplicate",
-    `${inspection.duplicates.length} stable_id${inspection.duplicates.length === 1 ? "" : "s"} duplicated across canonical knowledge files (path-decoupled identity invariant). First: ${detail}.`,
-    "Manually rename one of the colliding files to a fresh `<prefix>-<type>-<counter>--<slug>.md` allocated via the canonical id allocator; do not edit by hand."
+    t(`doctor.check.stable_id_duplicate.message.${count === 1 ? "singular" : "plural"}`, {
+      count: String(count),
+      detail
+    }),
+    t("doctor.check.stable_id_duplicate.remediation")
   );
 }
-function createLayerMismatchCheck(inspection) {
+function createLayerMismatchCheck(t, inspection) {
   if (inspection.mismatches.length === 0) {
     return okCheck(
-      "Knowledge layer mismatch",
-      "All canonical knowledge files are physically located under the layer their stable_id prefix declares."
+      t("doctor.check.layer_mismatch.name"),
+      t("doctor.check.layer_mismatch.ok")
     );
   }
   const first = inspection.mismatches[0];
   const detail = `${first.stable_id} at ${first.path} (located in ${first.located_in}, expected ${first.expected_layer})`;
+  const count = inspection.mismatches.length;
   return issueCheck(
-    "Knowledge layer mismatch",
+    t("doctor.check.layer_mismatch.name"),
     "error",
     "manual_error",
     "knowledge_layer_mismatch",
-    `${inspection.mismatches.length} canonical knowledge file${inspection.mismatches.length === 1 ? "" : "s"} are physically misaligned with their stable_id layer prefix (KT-* must live under team/, KP-* under personal/). First: ${detail}.`,
-    "Move the file to the correct layer root, or use the fabric-review modify flow to flip its layer (which renames the stable_id prefix accordingly)."
+    t(`doctor.check.layer_mismatch.message.${count === 1 ? "singular" : "plural"}`, {
+      count: String(count),
+      detail
+    }),
+    t("doctor.check.layer_mismatch.remediation")
   );
 }
-function createIndexDriftCheck(inspection) {
+function createIndexDriftCheck(t, inspection) {
   if (inspection.drifts.length === 0) {
     return okCheck(
-      "Knowledge index drift",
-      "agents.meta.json counters envelope is at or above the highest existing canonical counter for every (layer, type) pair."
+      t("doctor.check.index_drift.name"),
+      t("doctor.check.index_drift.ok")
     );
   }
   const first = inspection.drifts[0];
   const detail = `${first.layer}.${first.type} counter=${first.counter} but max_observed=${first.max_observed} (would propose counters.${first.layer}.${first.type}=${first.proposed_after})`;
+  const count = inspection.drifts.length;
   return issueCheck(
-    "Knowledge index drift",
+    t("doctor.check.index_drift.name"),
     "error",
     "fixable_error",
     "knowledge_index_drift",
-    `${inspection.drifts.length} (layer, type) counter slot${inspection.drifts.length === 1 ? "" : "s"} have drifted below the observed canonical maximum (next allocate would collide). First: ${detail}.`,
-    "Run `fab doctor --apply-lint` (rc.4 TASK-003) to bump agents.meta.json counters to max_observed + 1."
+    t(`doctor.check.index_drift.message.${count === 1 ? "singular" : "plural"}`, {
+      count: String(count),
+      detail
+    }),
+    t("doctor.check.index_drift.remediation")
   );
 }
 async function migrateBootstrapMarkers(projectRoot) {
@@ -5137,7 +5550,7 @@ async function runDoctorCiteCoverage(projectRoot, options) {
         break;
     }
   }
-  const filteredTurns = options.client === "all" ? assistantTurns : assistantTurns.filter((t2) => t2.client === options.client);
+  const filteredTurns = options.client === "all" ? assistantTurns : assistantTurns.filter((t) => t.client === options.client);
   let clientSessionIds = null;
   if (options.client !== "all") {
     clientSessionIds = /* @__PURE__ */ new Set();