@fenglimg/fabric-server 2.0.0-rc.23 → 2.0.0-rc.26

package/dist/{chunk-IRB77C6E.js → chunk-RHWIDD6A.js}

@@ -428,6 +428,27 @@ import {
   parseKnowledgeId
 } from "@fenglimg/fabric-shared";
 import { atomicWriteText as atomicWriteText3 } from "@fenglimg/fabric-shared/node/atomic-write";
+async function loadKbIdTypeMap(projectRootInput) {
+  const projectRoot = normalizeProjectRoot(projectRootInput);
+  const metaPath = join4(projectRoot, ".fabric", "agents.meta.json");
+  const meta = await readExistingMeta(metaPath);
+  const map = /* @__PURE__ */ new Map();
+  if (meta === void 0) {
+    return map;
+  }
+  for (const node of Object.values(meta.nodes)) {
+    const stableId = node.stable_id;
+    if (stableId === void 0 || !isKnowledgeStableId(stableId)) {
+      continue;
+    }
+    const knowledgeType = node.description?.knowledge_type;
+    if (knowledgeType === void 0) {
+      continue;
+    }
+    map.set(stableId, knowledgeType);
+  }
+  return map;
+}
 async function buildKnowledgeMeta(projectRootInput) {
   const projectRoot = normalizeProjectRoot(projectRootInput);
   assertExistingDirectory(projectRoot);
@@ -1452,10 +1473,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;
@@ -1483,6 +1503,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}`,
         {
@@ -1533,6 +1554,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}`,
     {
@@ -1553,6 +1575,7 @@ import { minimatch } from "minimatch";
 import {
   agentsMetaSchema as agentsMetaSchema4,
   AgentsMetaCountersSchema,
+  createTranslator as createTranslator2,
   forensicReportSchema,
   parseKnowledgeId as parseKnowledgeId2,
   knowledgeTestIndexSchema as knowledgeTestIndexSchema2,
@@ -1562,7 +1585,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";
@@ -1648,6 +1672,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 [
@@ -1701,91 +1726,91 @@ 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),
+    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
@@ -2547,21 +2572,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) {
@@ -2580,20 +2609,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) {
@@ -2685,39 +2714,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");
@@ -2778,154 +2814,269 @@ 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 createEventLedgerPartialWriteCheck(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_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 };
@@ -2945,7 +3096,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) {
@@ -3032,18 +3184,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 = [];
@@ -3126,7 +3284,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;
     }
@@ -3154,61 +3312,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"];
@@ -3274,36 +3455,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) {
@@ -3801,114 +3990,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) {
@@ -4107,64 +4338,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) {
@@ -4307,11 +4555,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];
@@ -4319,13 +4567,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"];
@@ -4396,23 +4648,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 = [
@@ -4507,55 +4762,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() {
@@ -4692,58 +4975,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) {
@@ -4963,6 +5258,40 @@ async function ensureCitePolicyActivatedMarker(projectRoot) {
     return { marker_ts: 0, emitted_now: false };
   }
 }
+async function ensureCiteContractPolicyActivatedMarker(projectRoot) {
+  let driftStatus;
+  try {
+    const inspection = await inspectL1BootstrapSnapshotDrift(projectRoot);
+    driftStatus = inspection.status;
+  } catch {
+    driftStatus = "drift";
+  }
+  if (driftStatus !== "ok") {
+    return { marker_ts: 0, emitted_now: false, blocked_by: "bootstrap_drift" };
+  }
+  let existing;
+  try {
+    const { events } = await readEventLedger(projectRoot, {
+      event_type: "cite_contract_policy_activated"
+    });
+    if (events.length > 0) {
+      existing = events[0];
+    }
+  } catch {
+    return { marker_ts: 0, emitted_now: false, blocked_by: null };
+  }
+  if (existing !== void 0) {
+    return { marker_ts: existing.ts, emitted_now: false, blocked_by: null };
+  }
+  try {
+    const stored = await appendEventLedgerEvent(projectRoot, {
+      event_type: "cite_contract_policy_activated"
+    });
+    return { marker_ts: stored.ts, emitted_now: true, blocked_by: null };
+  } catch {
+    return { marker_ts: 0, emitted_now: false, blocked_by: null };
+  }
+}
 function parseNoneSentinel(kbLineRaw) {
   if (typeof kbLineRaw !== "string" || kbLineRaw.length === 0) return "unspecified";
   const m = kbLineRaw.match(/^KB:\s*none\b\s*(?:\[([^\]]*)\])?\s*$/i);
@@ -5000,7 +5329,10 @@ function matchesRelevancePath(editPath, relevancePaths) {
   return false;
 }
 async function runDoctorCiteCoverage(projectRoot, options) {
+  const layerFilter = options.layer ?? "all";
   const marker = await ensureCitePolicyActivatedMarker(projectRoot);
+  const contractMarker = await ensureCiteContractPolicyActivatedMarker(projectRoot);
+  const idTypeMap = await loadKbIdTypeMap(projectRoot);
   const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
   const zeroMetrics = {
     edits_touched: 0,
@@ -5009,6 +5341,20 @@ async function runDoctorCiteCoverage(projectRoot, options) {
     expected_but_missed: 0,
     total_turns: 0
   };
+  const contractStatus = contractMarker.blocked_by === "bootstrap_drift" ? "skipped:bootstrap_drift" : contractMarker.marker_ts === 0 ? "awaiting_marker" : "ok";
+  const zeroContractMetrics = {
+    decisions_cited: 0,
+    pitfalls_cited: 0,
+    contract_with: 0,
+    contract_missing: 0,
+    hard_violated: 0,
+    cite_id_unresolved: 0,
+    skip_count: {}
+  };
+  const zeroLayerType = {
+    team: {},
+    personal: {}
+  };
   if (marker.marker_ts === 0) {
     return {
       status: "skipped",
@@ -5016,11 +5362,17 @@ async function runDoctorCiteCoverage(projectRoot, options) {
       marker_emitted_now: false,
       since_ts: options.since,
       client_filter: options.client,
+      layer_filter: layerFilter,
       metrics: zeroMetrics,
+      contract_metrics_status: contractStatus,
+      contract_metrics: zeroContractMetrics,
+      per_layer_type: zeroLayerType,
+      contract_marker_ts: contractMarker.marker_ts,
       generated_at: generatedAt
     };
   }
   const effectiveSince = Math.max(marker.marker_ts, options.since);
+  const contractEffectiveSince = contractStatus === "ok" ? Math.max(contractMarker.marker_ts, options.since) : Number.POSITIVE_INFINITY;
   let ledgerEvents = [];
   try {
     const result = await readEventLedger(projectRoot, { since: effectiveSince });
@@ -5032,7 +5384,12 @@ async function runDoctorCiteCoverage(projectRoot, options) {
       marker_emitted_now: marker.emitted_now,
       since_ts: effectiveSince,
       client_filter: options.client,
+      layer_filter: layerFilter,
       metrics: zeroMetrics,
+      contract_metrics_status: contractStatus,
+      contract_metrics: zeroContractMetrics,
+      per_layer_type: zeroLayerType,
+      contract_marker_ts: contractMarker.marker_ts,
       generated_at: generatedAt
     };
   }
@@ -5054,7 +5411,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();
@@ -5125,6 +5482,80 @@ async function runDoctorCiteCoverage(projectRoot, options) {
     perClientAccum.set(client, existing);
   };
   const sessionCitedKbs = /* @__PURE__ */ new Map();
+  const sessionEditPaths = /* @__PURE__ */ new Map();
+  for (const edit of editEvents) {
+    const sid = edit.session_id;
+    if (typeof sid !== "string" || sid.length === 0) continue;
+    const list = sessionEditPaths.get(sid) ?? [];
+    list.push(normalizePath(edit.path));
+    sessionEditPaths.set(sid, list);
+  }
+  let decisionsCited = 0;
+  let pitfallsCited = 0;
+  let contractWith = 0;
+  let contractMissing = 0;
+  let hardViolated = 0;
+  let citeIdUnresolved = 0;
+  const skipCount = {};
+  const layerTypeAccum = { team: {}, personal: {} };
+  const bumpLayerType = (citeId, type) => {
+    const layer = citeId.startsWith("KP-") ? "personal" : citeId.startsWith("KT-") ? "team" : null;
+    if (layer === null) return;
+    layerTypeAccum[layer][type] = (layerTypeAccum[layer][type] ?? 0) + 1;
+  };
+  const passesLayerFilter = (citeId) => {
+    if (layerFilter === "all") return true;
+    if (layerFilter === "team") return citeId.startsWith("KT-");
+    return citeId.startsWith("KP-");
+  };
+  const evaluateOperatorViolation = (sessionId, operators) => {
+    const editPaths = typeof sessionId === "string" && sessionId.length > 0 ? sessionEditPaths.get(sessionId) ?? [] : [];
+    for (const op of operators) {
+      switch (op.kind) {
+        case "edit": {
+          let matched = false;
+          for (const p of editPaths) {
+            if (minimatch(p, op.target, { dot: true, matchBase: false })) {
+              matched = true;
+              break;
+            }
+          }
+          if (!matched) return true;
+          break;
+        }
+        case "not_edit": {
+          for (const p of editPaths) {
+            if (minimatch(p, op.target, { dot: true, matchBase: false })) {
+              return true;
+            }
+          }
+          break;
+        }
+        case "require": {
+          let found = false;
+          for (const p of editPaths) {
+            if (p.includes(op.target)) {
+              found = true;
+              break;
+            }
+          }
+          if (!found) return true;
+          break;
+        }
+        case "forbid": {
+          for (const p of editPaths) {
+            if (p.includes(op.target)) {
+              return true;
+            }
+          }
+          break;
+        }
+        default:
+          break;
+      }
+    }
+    return false;
+  };
   let totalTurns = 0;
   let qualifyingCites = 0;
   let recalledUnverified = 0;
@@ -5174,6 +5605,40 @@ async function runDoctorCiteCoverage(projectRoot, options) {
         m.recalled_unverified += 1;
       });
     }
+    if (contractStatus === "ok" && turn.ts >= contractEffectiveSince) {
+      const commitments = turn.cite_commitments ?? [];
+      for (let i = 0; i < turn.cite_ids.length; i += 1) {
+        const citeId = turn.cite_ids[i];
+        if (typeof citeId !== "string" || citeId.length === 0) continue;
+        if (!passesLayerFilter(citeId)) continue;
+        const kbType = idTypeMap.get(citeId);
+        if (kbType === void 0) {
+          citeIdUnresolved += 1;
+          bumpLayerType(citeId, "unresolved");
+          continue;
+        }
+        bumpLayerType(citeId, kbType);
+        if (kbType === "decision" || kbType === "pitfall") {
+          if (kbType === "decision") decisionsCited += 1;
+          else pitfallsCited += 1;
+          const commitment = commitments[i];
+          const operators = commitment?.operators ?? [];
+          const skipReason = commitment?.skip_reason ?? null;
+          if (skipReason !== null) {
+            skipCount[skipReason] = (skipCount[skipReason] ?? 0) + 1;
+            continue;
+          }
+          if (operators.length === 0) {
+            contractMissing += 1;
+            continue;
+          }
+          contractWith += 1;
+          if (evaluateOperatorViolation(sid, operators)) {
+            hardViolated += 1;
+          }
+        }
+      }
+    }
   }
   let editsTouched = 0;
   let expectedButMissed = 0;
@@ -5208,19 +5673,96 @@ async function runDoctorCiteCoverage(projectRoot, options) {
       perClient[client] = m;
     }
   }
+  const contractMetrics = {
+    decisions_cited: decisionsCited,
+    pitfalls_cited: pitfallsCited,
+    contract_with: contractWith,
+    contract_missing: contractMissing,
+    hard_violated: hardViolated,
+    cite_id_unresolved: citeIdUnresolved,
+    skip_count: skipCount
+  };
   return {
     status: "ok",
     marker_ts: marker.marker_ts,
     marker_emitted_now: marker.emitted_now,
     since_ts: effectiveSince,
     client_filter: options.client,
+    layer_filter: layerFilter,
     metrics,
     ...perClient !== void 0 ? { per_client: perClient } : {},
     ...Object.keys(dismissedHistogram).length > 0 ? { dismissed_reason_histogram: dismissedHistogram } : {},
     ...Object.keys(noneHistogram).length > 0 ? { none_reason_histogram: noneHistogram } : {},
+    contract_metrics_status: contractStatus,
+    contract_metrics: contractMetrics,
+    per_layer_type: layerTypeAccum,
+    contract_marker_ts: contractMarker.marker_ts,
+    generated_at: generatedAt
+  };
+}
+async function runDoctorArchiveHistory(projectRoot, options) {
+  const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const nowMs = Date.now();
+  let events = [];
+  try {
+    const result = await readEventLedger(projectRoot, {
+      event_type: "session_archive_attempted",
+      since: options.since
+    });
+    events = result.events;
+  } catch {
+    return {
+      entries: [],
+      total: 0,
+      since_ms: options.since,
+      generated_at: generatedAt
+    };
+  }
+  const mostRecentBySession = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (event.event_type !== "session_archive_attempted") {
+      continue;
+    }
+    const sessionId = event.session_id;
+    if (typeof sessionId !== "string" || sessionId.length === 0) {
+      continue;
+    }
+    const prior = mostRecentBySession.get(sessionId);
+    if (prior === void 0 || event.ts > prior.ts) {
+      mostRecentBySession.set(sessionId, event);
+    }
+  }
+  const entries = [];
+  for (const [sessionId, event] of mostRecentBySession.entries()) {
+    const ageHours = Math.max(
+      0,
+      Math.floor((nowMs - event.covered_through_ts) / 36e5)
+    );
+    entries.push({
+      session_id_short: truncateSessionId(sessionId),
+      last_attempted_at: new Date(event.ts).toISOString(),
+      outcome: event.outcome,
+      candidates_proposed: event.candidates_proposed,
+      covered_through_ts: event.covered_through_ts,
+      age_since_covered_hours: ageHours
+    });
+  }
+  entries.sort(
+    (a, b) => a.last_attempted_at < b.last_attempted_at ? 1 : a.last_attempted_at > b.last_attempted_at ? -1 : 0
+  );
+  return {
+    entries,
+    total: entries.length,
+    since_ms: options.since,
     generated_at: generatedAt
   };
 }
+function truncateSessionId(sessionId) {
+  if (sessionId.length <= 8) {
+    return sessionId;
+  }
+  return `${sessionId.slice(0, 8)}...`;
+}
 function createFixMessage(fixed, report) {
   const fixedText = fixed.length === 0 ? "No deterministic doctor fixes were needed." : `Applied ${fixed.length} deterministic doctor fix${fixed.length === 1 ? "" : "es"}.`;
   const manualText = report.manual_errors.length === 0 ? "No manual errors remain." : `${report.manual_errors.length} manual error${report.manual_errors.length === 1 ? "" : "s"} remain.`;
@@ -5734,6 +6276,7 @@ export {
   appendEventLedgerEvent,
   readEventLedger,
   flushAndSyncEventLedger,
+  loadKbIdTypeMap,
   buildKnowledgeMeta,
   writeKnowledgeMeta,
   computeKnowledgeBasedAgentsMeta,
@@ -5758,5 +6301,6 @@ export {
   runDoctorFix,
   runDoctorApplyLint,
   runDoctorCiteCoverage,
+  runDoctorArchiveHistory,
   enrichDescriptions
 };