truthmark 1.2.3 → 1.3.0

package/dist/main.js

@@ -245,6 +245,7 @@ var resolveWorktreePath = (repository, relativePath) => {
 };
 
 // src/templates/init-files.ts
+import path3 from "path";
 import { stringify } from "yaml";
 
 // src/config/schema.ts
@@ -265,7 +266,7 @@ var DEFAULT_PLATFORMS = [
 var truthmarkConfigSchema = {
   type: "object",
   additionalProperties: false,
-  required: ["version", "authority", "realization"],
+  required: ["version", "authority"],
   properties: {
     version: {
       type: "integer",
@@ -361,16 +362,6 @@ var truthmarkConfigSchema = {
       items: {
         type: "string"
       }
-    },
-    realization: {
-      type: "object",
-      additionalProperties: false,
-      required: ["enabled"],
-      properties: {
-        enabled: {
-          type: "boolean"
-        }
-      }
     }
   }
 };
@@ -382,7 +373,7 @@ var DEFAULT_DOCS_HIERARCHY = {
     ai: "docs/ai",
     standards: "docs/standards",
     architecture: "docs/architecture",
-    features: "docs/features"
+    truth: "docs/truth"
   },
   routing: {
     root_index: "docs/truthmark/areas.md",
@@ -397,7 +388,7 @@ var DEFAULT_AUTHORITY = [
   `${DEFAULT_DOCS_HIERARCHY.roots.ai}/**/*.md`,
   `${DEFAULT_DOCS_HIERARCHY.roots.standards}/**/*.md`,
   `${DEFAULT_DOCS_HIERARCHY.roots.architecture}/**/*.md`,
-  `${DEFAULT_DOCS_HIERARCHY.roots.features}/**/*.md`
+  `${DEFAULT_DOCS_HIERARCHY.roots.truth}/**/*.md`
 ];
 var DEFAULT_INSTRUCTION_TARGETS = ["AGENTS.md"];
 var createDefaultRawConfig = () => ({
@@ -414,10 +405,7 @@ var createDefaultRawConfig = () => ({
     required: [],
     recommended: ["status", "doc_type", "last_reviewed", "source_of_truth"]
   },
-  ignore: ["node_modules/**", "vendor/**", "dist/**", "build/**"],
-  realization: {
-    enabled: true
-  }
+  ignore: ["node_modules/**", "vendor/**", "dist/**", "build/**"]
 });
 var createDefaultConfig = () => ({
   version: 1,
@@ -438,13 +426,299 @@ var createDefaultConfig = () => ({
     required: [],
     recommended: ["status", "doc_type", "last_reviewed", "source_of_truth"]
   },
-  ignore: ["node_modules/**", "vendor/**", "dist/**", "build/**"],
-  realization: {
-    enabled: true
-  }
+  ignore: ["node_modules/**", "vendor/**", "dist/**", "build/**"]
 });
 
+// src/routing/areas.ts
+import { parse } from "yaml";
+var TRUTH_DOCUMENT_KINDS = [
+  "behavior",
+  "contract",
+  "architecture",
+  "workflow",
+  "operations",
+  "test-behavior"
+];
+var slugify = (value) => {
+  return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+};
+var createAreaDiagnostic = (message, area, severity = "error") => {
+  return {
+    category: "area-index",
+    severity,
+    message,
+    area
+  };
+};
+var parseListSection = (sectionLines) => {
+  return sectionLines.map((line) => line.trim()).filter((line) => line.startsWith("- ")).map((line) => line.slice(2).trim()).filter((line) => line.length > 0);
+};
+var isTruthDocumentKind = (value) => {
+  return typeof value === "string" && TRUTH_DOCUMENT_KINDS.includes(value);
+};
+var inferTruthDocumentKindFromPath = (documentPath, options = {}) => {
+  const normalizedPath = documentPath.replaceAll("\\", "/");
+  const truthDocsRoot = options.truthDocsRoot?.replaceAll("\\", "/").replace(/\/+$/u, "");
+  if (truthDocsRoot && normalizedPath.startsWith(`${truthDocsRoot}/`) || normalizedPath.startsWith("docs/truth/")) {
+    return "behavior";
+  }
+  if (normalizedPath.startsWith("docs/contracts/") || normalizedPath.startsWith("docs/contract/") || normalizedPath.startsWith("docs/api/")) {
+    return "contract";
+  }
+  if (normalizedPath.startsWith("docs/architecture/")) {
+    return "architecture";
+  }
+  if (normalizedPath.startsWith("docs/workflows/") || normalizedPath.startsWith("docs/workflow/")) {
+    return "workflow";
+  }
+  if (normalizedPath.startsWith("docs/operations/") || normalizedPath.startsWith("docs/platform/")) {
+    return "operations";
+  }
+  if (normalizedPath.startsWith("docs/testing/") || normalizedPath.startsWith("docs/tests/")) {
+    return "test-behavior";
+  }
+  return null;
+};
+var findTruthDocumentsYamlFenceRange = (sectionLines) => {
+  const trimmedLines = sectionLines.map((line) => line.trim());
+  const openingFenceIndex = trimmedLines.findIndex((line) => /^```(?:yaml|yml)?$/u.test(line));
+  if (openingFenceIndex === -1) {
+    return null;
+  }
+  const closingFenceIndex = trimmedLines.findIndex(
+    (line, index) => index > openingFenceIndex && line === "```"
+  );
+  return {
+    openingFenceIndex,
+    closingFenceIndex: closingFenceIndex === -1 ? null : closingFenceIndex
+  };
+};
+var parseTruthDocumentsFromList = (sectionLines, areaName, options) => {
+  const diagnostics = [];
+  const truthDocuments = parseListSection(sectionLines);
+  const truthDocumentEntries = truthDocuments.map((documentPath) => {
+    const inferredKind = inferTruthDocumentKindFromPath(documentPath, options);
+    if (!inferredKind) {
+      diagnostics.push(
+        createAreaDiagnostic(
+          `Truth document ${documentPath} does not match a known kind path convention; defaulting to behavior.`,
+          areaName,
+          "review"
+        )
+      );
+    }
+    return {
+      path: documentPath,
+      kind: inferredKind ?? "behavior",
+      kindSource: inferredKind ? "inferred" : "defaulted"
+    };
+  });
+  return {
+    truthDocuments,
+    truthDocumentEntries,
+    diagnostics
+  };
+};
+var parseTruthDocumentsFromYaml = (sectionLines, areaName) => {
+  const yamlFenceRange = findTruthDocumentsYamlFenceRange(sectionLines);
+  if (!yamlFenceRange) {
+    return {
+      truthDocuments: [],
+      truthDocumentEntries: [],
+      diagnostics: []
+    };
+  }
+  if (yamlFenceRange.closingFenceIndex === null) {
+    return {
+      truthDocuments: [],
+      truthDocumentEntries: [],
+      diagnostics: [
+        createAreaDiagnostic(
+          `Area ${areaName} has an unterminated fenced YAML Truth documents block.`,
+          areaName
+        )
+      ]
+    };
+  }
+  let parsedBlock;
+  try {
+    parsedBlock = parse(
+      sectionLines.slice(yamlFenceRange.openingFenceIndex + 1, yamlFenceRange.closingFenceIndex).join("\n")
+    );
+  } catch (error) {
+    return {
+      truthDocuments: [],
+      truthDocumentEntries: [],
+      diagnostics: [
+        createAreaDiagnostic(
+          `Area ${areaName} has invalid YAML truth document metadata: ${error instanceof Error ? error.message : String(error)}.`,
+          areaName
+        )
+      ]
+    };
+  }
+  const rawEntries = parsedBlock && typeof parsedBlock === "object" && "truth_documents" in parsedBlock ? parsedBlock.truth_documents : null;
+  if (!Array.isArray(rawEntries)) {
+    return {
+      truthDocuments: [],
+      truthDocumentEntries: [],
+      diagnostics: [
+        createAreaDiagnostic(
+          `Area ${areaName} must define a truth_documents array inside the fenced YAML block.`,
+          areaName
+        )
+      ]
+    };
+  }
+  const diagnostics = [];
+  const truthDocumentEntries = [];
+  for (const rawEntry of rawEntries) {
+    const path12 = rawEntry && typeof rawEntry === "object" && "path" in rawEntry ? rawEntry.path : null;
+    const kind = rawEntry && typeof rawEntry === "object" && "kind" in rawEntry ? rawEntry.kind : null;
+    if (typeof path12 !== "string" || path12.trim().length === 0 || !isTruthDocumentKind(kind)) {
+      diagnostics.push(
+        createAreaDiagnostic(
+          `Area ${areaName} truth_documents entries must include non-empty path and valid kind fields.`,
+          areaName
+        )
+      );
+      continue;
+    }
+    truthDocumentEntries.push({
+      path: path12.trim(),
+      kind,
+      kindSource: "explicit"
+    });
+  }
+  return {
+    truthDocuments: truthDocumentEntries.map((entry) => entry.path),
+    truthDocumentEntries,
+    diagnostics
+  };
+};
+var parseTruthDocumentsSection = (sectionLines, areaName, options) => {
+  const yamlFenceRange = findTruthDocumentsYamlFenceRange(sectionLines);
+  if (!yamlFenceRange) {
+    return parseTruthDocumentsFromList(sectionLines, areaName, options);
+  }
+  const yamlResult = parseTruthDocumentsFromYaml(sectionLines, areaName);
+  if (yamlResult.diagnostics.length > 0 || yamlFenceRange.closingFenceIndex === null) {
+    return yamlResult;
+  }
+  return yamlResult;
+};
+var parseAreasMarkdown = (source, options = {}) => {
+  const lines = source.split("\n");
+  const diagnostics = [];
+  const areas = [];
+  const truthDocumentReferences = [];
+  const areaFileReferences = [];
+  let areaIndex = 0;
+  let currentAreaName = null;
+  let currentSections = /* @__PURE__ */ new Map();
+  let currentSectionName = null;
+  const flushArea = () => {
+    if (!currentAreaName) {
+      return;
+    }
+    const truthDocumentResult = parseTruthDocumentsSection(
+      currentSections.get("Truth documents") ?? [],
+      currentAreaName,
+      options
+    );
+    const { truthDocuments, truthDocumentEntries } = truthDocumentResult;
+    const areaFiles = parseListSection(currentSections.get("Area files") ?? []);
+    const codeSurface = parseListSection(currentSections.get("Code surface") ?? []);
+    const updateTruthWhen = parseListSection(currentSections.get("Update truth when") ?? []);
+    const areaKey = slugify(currentAreaName);
+    const areaId = areaKey.length > 0 ? areaKey : `area-${areaIndex}`;
+    const hasTruthDocuments = truthDocuments.length > 0;
+    const hasAreaFiles = areaFiles.length > 0;
+    areaIndex += 1;
+    diagnostics.push(...truthDocumentResult.diagnostics);
+    if (hasTruthDocuments) {
+      truthDocumentReferences.push({
+        id: areaId,
+        name: currentAreaName,
+        key: areaKey,
+        truthDocuments,
+        truthDocumentEntries
+      });
+    }
+    if (hasTruthDocuments === hasAreaFiles || codeSurface.length === 0 || updateTruthWhen.length === 0) {
+      diagnostics.push(
+        createAreaDiagnostic(
+          `Area ${currentAreaName} must define exactly one of Truth documents or Area files, plus Code surface and Update truth when sections.`,
+          currentAreaName
+        )
+      );
+    } else if (hasAreaFiles) {
+      areaFileReferences.push({
+        id: areaId,
+        name: currentAreaName,
+        key: areaKey,
+        areaFiles,
+        codeSurface,
+        updateTruthWhen
+      });
+    } else {
+      areas.push({
+        id: areaId,
+        name: currentAreaName,
+        key: areaKey,
+        truthDocuments,
+        truthDocumentEntries,
+        codeSurface,
+        updateTruthWhen
+      });
+    }
+    currentAreaName = null;
+    currentSections = /* @__PURE__ */ new Map();
+    currentSectionName = null;
+  };
+  for (const line of lines) {
+    const areaHeadingMatch = line.match(/^\s{0,3}##\s+(.*)$/u);
+    if (areaHeadingMatch) {
+      flushArea();
+      currentAreaName = areaHeadingMatch[1]?.trim() ?? null;
+      continue;
+    }
+    if (!currentAreaName) {
+      continue;
+    }
+    if (/^(Truth documents|Area files|Code surface|Update truth when):$/u.test(line.trim())) {
+      currentSectionName = line.trim().slice(0, -1);
+      currentSections.set(currentSectionName, []);
+      continue;
+    }
+    if (currentSectionName) {
+      currentSections.get(currentSectionName)?.push(line);
+    }
+  }
+  flushArea();
+  return {
+    areas,
+    truthDocumentReferences,
+    areaFileReferences,
+    diagnostics
+  };
+};
+
+// src/truth/docs.ts
+var DEFAULT_TRUTH_DOCS_ROOT = DEFAULT_DOCS_HIERARCHY.roots.truth;
+var resolveTruthDocsRoot = (config) => {
+  return config.docs.roots.truth ?? DEFAULT_TRUTH_DOCS_ROOT;
+};
+
 // src/templates/init-files.ts
+var asRelativePath = (value) => {
+  return value.split(path3.sep).join("/");
+};
+var currentDate = () => (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+var resolveRelativePath = (fromPath, toPath) => {
+  return asRelativePath(path3.relative(path3.dirname(fromPath), toPath));
+};
+var truthRoot = resolveTruthDocsRoot;
 var renderConfigTemplate = () => {
   return stringify(createDefaultRawConfig());
 };
@@ -455,13 +729,17 @@ var renderHierarchicalAreasIndexTemplate = (config) => {
   const defaultArea = config.docs.routing.defaultArea;
   const childPath = `${config.docs.routing.areaFilesRoot}/${defaultArea}.md`;
   const title = titleCase(defaultArea);
+  const sourceOfTruth = resolveRelativePath(
+    config.docs.routing.rootIndex,
+    ".truthmark/config.yml"
+  );
   return [
     "---",
     "status: active",
     "doc_type: route-index",
-    "last_reviewed: 2026-05-09",
+    `last_reviewed: ${currentDate()}`,
     "source_of_truth:",
-    "  - ../../.truthmark/config.yml",
+    `  - ${sourceOfTruth}`,
     "---",
     "",
     "# Truthmark Areas",
@@ -483,15 +761,17 @@ var renderHierarchicalAreasIndexTemplate = (config) => {
 var renderChildAreaTemplate = (config) => {
   const defaultArea = config.docs.routing.defaultArea;
   const title = titleCase(defaultArea);
-  const featureRoot = config.docs.roots.features ?? config.docs.roots.features_current ?? "docs/features";
-  const leafTruthDoc = `${featureRoot}/${defaultArea}/overview.md`;
+  const truthDocsRoot = truthRoot(config);
+  const leafTruthDoc = `${truthDocsRoot}/${defaultArea}/overview.md`;
+  const templatePath = `${config.docs.routing.areaFilesRoot}/${defaultArea}.md`;
+  const sourceOfTruth = resolveRelativePath(templatePath, ".truthmark/config.yml");
   return [
     "---",
     "status: active",
     "doc_type: area-route",
-    "last_reviewed: 2026-05-09",
+    `last_reviewed: ${currentDate()}`,
     "source_of_truth:",
-    "  - ../../../.truthmark/config.yml",
+    `  - ${sourceOfTruth}`,
     "---",
     "",
     `# ${title} Areas`,
@@ -499,7 +779,11 @@ var renderChildAreaTemplate = (config) => {
     `## ${title}`,
     "",
     "Truth documents:",
-    `- ${leafTruthDoc}`,
+    "```yaml",
+    "truth_documents:",
+    `  - path: ${leafTruthDoc}`,
+    "    kind: behavior",
+    "```",
     "",
     "Code surface:",
     "- src/**",
@@ -509,41 +793,51 @@ var renderChildAreaTemplate = (config) => {
     ""
   ].join("\n");
 };
-var renderFeatureRootReadmeTemplate = () => {
+var renderTruthRootReadmeTemplate = (config = createDefaultConfig()) => {
+  const templatePath = `${truthRoot(config)}/README.md`;
+  const sourceOfTruth = resolveRelativePath(
+    templatePath,
+    config.docs.routing.rootIndex
+  );
   return [
     "---",
     "status: active",
     "doc_type: index",
-    "last_reviewed: 2026-05-09",
+    `last_reviewed: ${currentDate()}`,
     "source_of_truth:",
-    "  - ../../truthmark/areas.md",
+    `  - ${sourceOfTruth}`,
     "---",
     "",
-    "# Feature Docs",
+    "# Truth Docs",
     "",
-    "This directory is an index for current feature behavior docs organized by the configured Truthmark hierarchy.",
+    "This directory is an index for current truth docs organized by the configured Truthmark hierarchy.",
     "",
-    "README.md files are indexes, not Truth Sync targets. Keep behavior truth in bounded leaf docs under `<domain>/<behavior>.md`.",
+    "README.md files are indexes, not Truth Sync targets. Keep bounded truth in leaf docs under `<domain>/<behavior>.md`.",
     ""
   ].join("\n");
 };
-var renderFeatureDomainReadmeTemplate = (config) => {
+var renderTruthDomainReadmeTemplate = (config) => {
   const defaultArea = config.docs.routing.defaultArea;
   const title = titleCase(defaultArea);
+  const templatePath = `${truthRoot(config)}/${defaultArea}/README.md`;
+  const sourceOfTruth = resolveRelativePath(
+    templatePath,
+    `${config.docs.routing.areaFilesRoot}/${defaultArea}.md`
+  );
   return [
     "---",
     "status: active",
     "doc_type: index",
-    "last_reviewed: 2026-05-09",
+    `last_reviewed: ${currentDate()}`,
     "source_of_truth:",
-    `  - ../../truthmark/areas/${defaultArea}.md`,
+    `  - ${sourceOfTruth}`,
     "---",
     "",
-    `# ${title} Feature Docs`,
+    `# ${title} Truth Docs`,
     "",
-    `This directory indexes bounded ${title.toLowerCase()} feature truth docs.`,
+    `This directory indexes bounded ${title.toLowerCase()} truth docs.`,
     "",
-    "README.md files are indexes, not Truth Sync targets. Keep behavior truth in bounded leaf docs in this directory.",
+    "README.md files are indexes, not Truth Sync targets. Keep bounded truth in leaf docs in this directory.",
     "",
     "Current leaf docs:",
     "",
@@ -551,13 +845,19 @@ var renderFeatureDomainReadmeTemplate = (config) => {
     ""
   ].join("\n");
 };
-var FEATURE_DOC_TEMPLATE_PATH = "docs/templates/feature-doc.md";
-var renderFeatureDocTemplateFile = () => {
+var BEHAVIOR_DOC_TEMPLATE_PATH = "docs/templates/behavior-doc.md";
+var CONTRACT_DOC_TEMPLATE_PATH = "docs/templates/contract-doc.md";
+var ARCHITECTURE_DOC_TEMPLATE_PATH = "docs/templates/architecture-doc.md";
+var WORKFLOW_DOC_TEMPLATE_PATH = "docs/templates/workflow-doc.md";
+var OPERATIONS_DOC_TEMPLATE_PATH = "docs/templates/operations-doc.md";
+var TEST_BEHAVIOR_DOC_TEMPLATE_PATH = "docs/templates/test-behavior-doc.md";
+var renderBehaviorDocTemplateFile = () => {
   return [
     "---",
     "status: active",
-    "doc_type: feature",
-    "last_reviewed: 2026-05-12",
+    "doc_type: behavior",
+    "truth_kind: behavior",
+    `last_reviewed: ${currentDate()}`,
     "source_of_truth:",
     "  - {{source_of_truth}}",
     "---",
@@ -585,7 +885,7 @@ var renderFeatureDocTemplateFile = () => {
     "Keep README.md files as indexes only.",
     "-->",
     "",
-    "This doc was created from the editable feature-doc template at {{template_path}}.",
+    "This doc was created from the editable behavior-doc template at {{template_path}}.",
     "",
     "## Current Behavior",
     "",
@@ -637,29 +937,134 @@ var renderFeatureDocTemplateFile = () => {
     ""
   ].join("\n");
 };
+var renderTypedTruthDocTemplate = (truthKind, docType, title, sections) => {
+  const placeholderNameForSection = (section) => {
+    return section.replace(/^#+\s+/u, "").toLowerCase().replaceAll(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+  };
+  return [
+    "---",
+    "status: active",
+    `doc_type: ${docType}`,
+    `truth_kind: ${truthKind}`,
+    `last_reviewed: ${currentDate()}`,
+    "source_of_truth:",
+    "  - {{source_of_truth}}",
+    "---",
+    "",
+    `# ${title}`,
+    "",
+    "## Purpose",
+    "",
+    "{{purpose}}",
+    "",
+    "## Scope",
+    "",
+    "{{scope}}",
+    "",
+    ...sections.flatMap((section) => [
+      section,
+      "",
+      `{{${placeholderNameForSection(section)}}}`,
+      ""
+    ]),
+    "## Product Decisions",
+    "",
+    "{{decision}}",
+    "",
+    "## Rationale",
+    "",
+    "{{rationale}}",
+    "",
+    "## Non-Goals",
+    "",
+    "{{non_goals}}",
+    "",
+    "## Maintenance Notes",
+    "",
+    "{{maintenance_notes}}",
+    ""
+  ].join("\n");
+};
+var renderContractDocTemplateFile = () => {
+  return renderTypedTruthDocTemplate("contract", "contract", "{{title}}", [
+    "## Contract Surface",
+    "## Inputs",
+    "## Outputs",
+    "## Errors And Diagnostics",
+    "## Compatibility Rules",
+    "## Versioning And Migration"
+  ]);
+};
+var renderArchitectureDocTemplateFile = () => {
+  return renderTypedTruthDocTemplate("architecture", "architecture", "{{title}}", [
+    "## System Role",
+    "## Boundaries",
+    "## Components",
+    "## Data And Control Flow",
+    "## Ownership",
+    "## Cross-Cutting Constraints"
+  ]);
+};
+var renderWorkflowDocTemplateFile = () => {
+  return renderTypedTruthDocTemplate("workflow", "behavior", "{{title}}", [
+    "## Triggers",
+    "## Inputs",
+    "## Execution Model",
+    "## Steps",
+    "## State, Retry, And Failure Behavior",
+    "## Outputs"
+  ]);
+};
+var renderOperationsDocTemplateFile = () => {
+  return renderTypedTruthDocTemplate("operations", "behavior", "{{title}}", [
+    "## Operational Surface",
+    "## Runtime Topology",
+    "## Configuration",
+    "## Permissions",
+    "## Deployment And Rollback",
+    "## Availability And Observability"
+  ]);
+};
+var renderTestBehaviorDocTemplateFile = () => {
+  return renderTypedTruthDocTemplate("test-behavior", "behavior", "{{title}}", [
+    "## Test Surface",
+    "## Fixtures And Data Model",
+    "## Execution Model",
+    "## Assertions And Invariants",
+    "## Isolation Rules",
+    "## Reporting And Failure Semantics"
+  ]);
+};
 var renderTemplate = (template, values) => {
   return Object.entries(values).reduce((rendered, [key, value]) => {
     return rendered.split(`{{${key}}}`).join(value);
   }, template);
 };
-var renderFeatureLeafDocTemplate = (config, template = renderFeatureDocTemplateFile()) => {
+var renderBehaviorLeafDocTemplate = (config, template = renderBehaviorDocTemplateFile()) => {
   const defaultArea = config.docs.routing.defaultArea;
   const title = titleCase(defaultArea);
+  const templatePath = `${truthRoot(config)}/${defaultArea}/overview.md`;
+  const sourceOfTruth = resolveRelativePath(
+    templatePath,
+    `${config.docs.routing.areaFilesRoot}/${defaultArea}.md`
+  );
+  const today = currentDate();
   return renderTemplate(template, {
     area: defaultArea,
     contracts: "- External contracts should link to the nearest canonical contract doc when one exists.",
-    core_rules: "- Feature README files are indexes; behavior truth belongs in bounded leaf docs.",
+    core_rules: "- Truth README files are indexes; behavior truth belongs in bounded leaf docs.",
     current_behavior: "- Document current behavior here when implementation changes make repository truth incomplete.",
-    decision: "- Decision (2026-05-09): Feature README files are indexes; behavior truth belongs in bounded leaf docs.",
+    decision: `- Decision (${today}): Truth README files are indexes; behavior truth belongs in bounded leaf docs.`,
     flows_and_states: "- None beyond current behavior.",
     maintenance_notes: "- Update this doc when routed implementation changes alter current behavior, rules, contracts, or decisions.",
     non_goals: "- This doc is not a catch-all for unrelated repository behavior.",
     purpose: `Describe why the default ${title.toLowerCase()} behavior surface exists and what outcome it protects.`,
     rationale: "Bounded leaf docs keep agent context focused and prevent large products from accumulating unreviewable feature manuals.",
     scope: `This bounded leaf truth doc owns the default ${title.toLowerCase()} behavior surface created by Truthmark.`,
-    source_of_truth: `../../truthmark/areas/${defaultArea}.md`,
-    template_path: FEATURE_DOC_TEMPLATE_PATH,
-    title: `${title} Overview`
+    source_of_truth: sourceOfTruth,
+    template_path: BEHAVIOR_DOC_TEMPLATE_PATH,
+    title: `${title} Overview`,
+    truth_kind: "behavior"
   });
 };
 
@@ -745,7 +1150,7 @@ import fs7 from "fs/promises";
 // src/config/load.ts
 import fs4 from "fs/promises";
 import { Ajv } from "ajv";
-import { parse } from "yaml";
+import { parse as parse2 } from "yaml";
 var ajv = new Ajv({ allErrors: true });
 var validateTruthmarkConfig = ajv.compile(truthmarkConfigSchema);
 var toConfigDiagnostic = (message, file) => {
@@ -762,12 +1167,13 @@ var normalizeConfig = (rawConfig) => {
     roots: { ...DEFAULT_DOCS_HIERARCHY.roots },
     routing: { ...DEFAULT_DOCS_HIERARCHY.routing }
   };
+  const roots = { ...DEFAULT_DOCS_HIERARCHY.roots, ...rawDocs.roots };
   return {
     version: rawConfig.version,
     platforms: rawConfig.platforms ?? [...DEFAULT_PLATFORMS],
     docs: {
       layout: rawDocs.layout,
-      roots: { ...rawDocs.roots },
+      roots,
       routing: {
         rootIndex: rawDocs.routing.root_index,
         areaFilesRoot: rawDocs.routing.area_files_root,
@@ -781,10 +1187,7 @@ var normalizeConfig = (rawConfig) => {
       required: rawConfig.frontmatter?.required ?? [],
       recommended: rawConfig.frontmatter?.recommended ?? []
     },
-    ignore: rawConfig.ignore ?? [],
-    realization: {
-      enabled: rawConfig.realization.enabled
-    }
+    ignore: rawConfig.ignore ?? []
   };
 };
 var loadConfig = async (rootDir) => {
@@ -806,7 +1209,7 @@ var loadConfig = async (rootDir) => {
   }
   let parsedConfig;
   try {
-    parsedConfig = parse(source);
+    parsedConfig = parse2(source);
   } catch (error) {
     return {
       status: "invalid",
@@ -845,8 +1248,7 @@ var loadConfig = async (rootDir) => {
 import fs5 from "fs/promises";
 import fg from "fast-glob";
 var KNOWN_DEFAULT_ROOTS = [
-  DEFAULT_DOCS_HIERARCHY.roots.features,
-  "docs/features/current",
+  DEFAULT_DOCS_HIERARCHY.roots.truth,
   "docs/api",
   DEFAULT_DOCS_HIERARCHY.roots.architecture,
   DEFAULT_DOCS_HIERARCHY.roots.standards,
@@ -860,20 +1262,28 @@ var hasMarkdownFiles = async (rootDir, root) => {
   });
   return matches.length > 0;
 };
-var readFeatureDocTemplate = async (rootDir) => {
+var truthRoot2 = resolveTruthDocsRoot;
+var rootIndexReferencesChildRoute = async (rootDir, rootIndexPath, childRoutePath) => {
+  const rootIndexSource = await fs5.readFile(resolveRepoPath(rootDir, rootIndexPath), "utf8");
+  const parsedRootIndex = parseAreasMarkdown(rootIndexSource);
+  return parsedRootIndex.areaFileReferences.some(
+    (areaReference) => areaReference.areaFiles.includes(childRoutePath)
+  );
+};
+var readBehaviorDocTemplate = async (rootDir) => {
   try {
-    return await fs5.readFile(resolveRepoPath(rootDir, FEATURE_DOC_TEMPLATE_PATH), "utf8");
+    return await fs5.readFile(resolveRepoPath(rootDir, BEHAVIOR_DOC_TEMPLATE_PATH), "utf8");
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
-      return renderFeatureDocTemplateFile();
+      return renderBehaviorDocTemplateFile();
     }
     throw error;
   }
 };
 var scaffoldHierarchy = async (rootDir, config) => {
   const results = [];
-  const featureRoot = config.docs.roots.features ?? config.docs.roots.features_current ?? "docs/features";
-  const featureDomainRoot = `${featureRoot}/${config.docs.routing.defaultArea}`;
+  const truthDocsRoot = truthRoot2(config);
+  const truthDomainRoot = `${truthDocsRoot}/${config.docs.routing.defaultArea}`;
   const childRoutePath = `${config.docs.routing.areaFilesRoot}/${config.docs.routing.defaultArea}.md`;
   results.push(
     await ensureRepoFile(
@@ -882,30 +1292,55 @@ var scaffoldHierarchy = async (rootDir, config) => {
       renderHierarchicalAreasIndexTemplate(config)
     )
   );
-  results.push(await ensureRepoFile(rootDir, childRoutePath, renderChildAreaTemplate(config)));
+  if (await rootIndexReferencesChildRoute(rootDir, config.docs.routing.rootIndex, childRoutePath)) {
+    results.push(await ensureRepoFile(rootDir, childRoutePath, renderChildAreaTemplate(config)));
+  }
+  results.push(
+    await ensureRepoFile(
+      rootDir,
+      `${truthDocsRoot}/README.md`,
+      renderTruthRootReadmeTemplate(config)
+    )
+  );
   results.push(
     await ensureRepoFile(
       rootDir,
-      `${featureRoot}/README.md`,
-      renderFeatureRootReadmeTemplate()
+      `${truthDomainRoot}/README.md`,
+      renderTruthDomainReadmeTemplate(config)
     )
   );
+  results.push(
+    await ensureRepoFile(rootDir, BEHAVIOR_DOC_TEMPLATE_PATH, renderBehaviorDocTemplateFile())
+  );
+  results.push(
+    await ensureRepoFile(rootDir, CONTRACT_DOC_TEMPLATE_PATH, renderContractDocTemplateFile())
+  );
   results.push(
     await ensureRepoFile(
       rootDir,
-      `${featureDomainRoot}/README.md`,
-      renderFeatureDomainReadmeTemplate(config)
+      ARCHITECTURE_DOC_TEMPLATE_PATH,
+      renderArchitectureDocTemplateFile()
     )
   );
   results.push(
-    await ensureRepoFile(rootDir, FEATURE_DOC_TEMPLATE_PATH, renderFeatureDocTemplateFile())
+    await ensureRepoFile(rootDir, WORKFLOW_DOC_TEMPLATE_PATH, renderWorkflowDocTemplateFile())
+  );
+  results.push(
+    await ensureRepoFile(rootDir, OPERATIONS_DOC_TEMPLATE_PATH, renderOperationsDocTemplateFile())
+  );
+  results.push(
+    await ensureRepoFile(
+      rootDir,
+      TEST_BEHAVIOR_DOC_TEMPLATE_PATH,
+      renderTestBehaviorDocTemplateFile()
+    )
   );
-  const featureDocTemplate = await readFeatureDocTemplate(rootDir);
+  const behaviorDocTemplate = await readBehaviorDocTemplate(rootDir);
   results.push(
     await ensureRepoFile(
       rootDir,
-      `${featureDomainRoot}/overview.md`,
-      renderFeatureLeafDocTemplate(config, featureDocTemplate)
+      `${truthDomainRoot}/overview.md`,
+      renderBehaviorLeafDocTemplate(config, behaviorDocTemplate)
     )
   );
   return results;
@@ -929,70 +1364,128 @@ var detectHierarchyMigrationDiagnostics = async (rootDir, config) => {
   return diagnostics;
 };
 
-// src/agents/shared.ts
-var DECISION_TRUTH_INSTRUCTIONS = [
-  "Decision truth lives in the canonical doc it governs.",
-  "Date active decisions inline when added or changed, for example `Decision (2026-05-09): ...`.",
-  "Do not create separate timestamped ADR logs or planning tickets for active decisions.",
-  "Replace old active decisions instead of appending separate timestamped decision logs; Git history is the audit trail.",
-  "Update Product Decisions and Rationale when a behavior change comes from a decision change."
+// src/truth/evidence.ts
+var renderClaimEvidenceCheckedSection = (items) => {
+  return [
+    "Evidence checked:",
+    ...items.map((item) => {
+      return [
+        `- Claim: ${item.claim}`,
+        `  Evidence: ${item.evidence.join(" / ")}`,
+        `  Result: ${item.result}`
+      ].join("\n");
+    })
+  ].join("\n");
+};
+var renderAuditEvidenceCheckedSection = (items) => {
+  return [
+    "Evidence checked:",
+    ...items.map((item) => {
+      return [
+        `- Finding: ${item.finding}`,
+        `  Evidence: ${item.evidence.join(" / ")}`,
+        `  Suggested fix: ${item.suggestedFix}`,
+        `  Confidence: ${item.confidence}`
+      ].join("\n");
+    })
+  ].join("\n");
+};
+
+// src/agents/shared.ts
+var DECISION_TRUTH_INSTRUCTIONS = [
+  "Decision truth lives in the canonical doc it governs; date active decisions inline when added or changed.",
+  "Do not create separate active-decision ADR/planning logs; replace the active decision and let Git history carry the audit trail.",
+  "Update Product Decisions and Rationale when a decision changes behavior."
 ].join("\n");
 var EVIDENCE_AUTHORITY_INSTRUCTIONS = [
   "Repository instruction docs such as docs/ai/repo-rules.md remain instruction authority.",
   "Implementation code and canonical truth docs are inspected evidence for current behavior; they do not silently override workflow write boundaries."
 ].join("\n");
+var REPOSITORY_INTELLIGENCE_INSTRUCTIONS = [
+  "Repository intelligence artifacts are optional derived context: RepoIndex, RouteMap, ImpactSet, and ContextPack may guide routing, context selection, and verification planning when available.",
+  "They do not override checkout evidence, canonical truth docs, route files, or workflow write boundaries.",
+  "If unavailable, inspect .truthmark/config.yml, route files, source files, truth docs, and tests directly, then report that repository-intelligence artifacts were not generated."
+].join("\n");
 var FEATURE_DOC_TEMPLATE_INSTRUCTIONS = [
-  "When creating or updating a feature doc, read docs/templates/feature-doc.md and follow its frontmatter, heading order, and section intent.",
-  "When updating an existing feature doc, align existing feature docs to the template standard while preserving authored content that remains accurate.",
-  "If docs/templates/feature-doc.md is missing, use the built-in minimal feature-doc structure with Current Behavior, Product Decisions, and Rationale sections.",
-  "Teams may edit docs/templates/feature-doc.md to define their local feature-doc standard."
+  "When creating or updating a truth doc, inspect the routed truth kind and use the matching `docs/templates/<kind>-doc.md` template.",
+  "Supported kinds: behavior, contract, architecture, workflow, operations, and test-behavior.",
+  "Align existing docs to that template while preserving accurate authored content.",
+  "If the template is missing, use Scope, Product Decisions, Rationale, and the kind-specific current-truth section.",
+  "Teams may edit the template files under docs/templates/ to define their local truth-doc standards."
+].join("\n");
+var renderTruthDocOwnershipGateSection = (subject, outcome) => {
+  return [
+    "Truth-doc ownership gate:",
+    `- before editing or relying on ${subject}, verify each target/source truth doc is a bounded owner for the behavior`,
+    "- if a target/source doc mixes independent owners, spans unrelated behaviors, acts as an index, or needs cross-owner edits, do not patch or in-place repair it",
+    `- ${outcome}`,
+    "- report Ownership reviewed, Structure required, Truth docs split, Truth docs restructured, or Blocked reason as applicable"
+  ].join("\n");
+};
+var TRUTH_DOC_DECISION_RATIONALE_PRESERVATION_INSTRUCTIONS = [
+  "Product Decisions/Rationale preservation gate:",
+  "- before any truth-doc split, restructure, or shape repair, inventory existing Product Decisions and Rationale sections in every source or touched truth doc",
+  "- preserve each current decision and rationale in the bounded owner doc it governs; when splitting, move it to the new owner doc rather than deleting it or leaving it in an index",
+  "- remove or narrow a decision or rationale only when checkout evidence shows it is stale or unsupported, and report the exact claim, evidence, and result",
+  "- if ownership of a decision or rationale is unclear, block with manual-review files instead of deleting it or guessing",
+  "- after the edit, verify every touched truth doc still has Product Decisions and Rationale sections and every pre-existing entry is preserved, moved, narrowed, removed with evidence, or blocked"
 ].join("\n");
+var renderTruthDocRestructureGateSection = (scope) => {
+  return [
+    "Truth-doc shape repair gate:",
+    `- ${scope}`,
+    "- repair shape in place only after the ownership gate confirms the doc is the right bounded owner",
+    "- use Truth Structure for ownership splits; do not treat broad or mixed-owner docs as in-place repair work",
+    "- repair shape when a narrow edit would make truth worse: missing template sections, stale evidence conflicts, cross-section updates within one owner, or wrong frontmatter/source/headings",
+    "- preserve supported claims; remove, narrow, or block unsupported or stale claims",
+    "- report docs restructured and why a narrow edit was not sufficient"
+  ].join("\n");
+};
 var ARCHITECTURE_DOC_BOUNDARY_INSTRUCTIONS = [
-  "Maintain architecture docs when a code change alters system structure, module boundaries, runtime topology, persistence boundaries, cross-cutting contracts, or generated-surface ownership.",
-  "Do not put ordinary feature behavior, endpoint details, UI copy, validation rules, or bug fixes in architecture docs unless they change those architecture boundaries.",
-  "Keep architecture docs focused on structure and ownership; keep current product behavior in feature or contract docs."
+  "Maintain architecture docs only for structure-level changes: system structure, module boundaries, runtime topology, persistence boundaries, cross-cutting contracts, or generated-surface ownership.",
+  "Keep ordinary behavior, endpoints, UI copy, validation rules, and bug fixes in behavior or contract docs unless they change those boundaries."
 ].join("\n");
+var renderRouteFirstEvidenceGateSection = (subject, noImpactedDocOutcome) => {
+  return [
+    "Evidence Gate:",
+    `- route-first: map ${subject} to bounded route owners and primary canonical docs`,
+    "- review new or changed behavior-bearing claims only in touched docs, route ownership, Product Decisions, and Rationale",
+    "- support claims with primary checkout evidence: implementation, config, routing, generated templates, schemas, or contract definitions",
+    "- tests/examples/canonical docs corroborate; they are not sole proof when implementation conflicts",
+    "- remove, narrow, or block unsupported claims",
+    `- ${noImpactedDocOutcome}`
+  ].join("\n");
+};
+var renderTopologyEvidenceGateSection = () => {
+  return [
+    "Evidence Gate:",
+    "- apply the Evidence Gate before finishing when Truth Structure writes routed docs, ownership claims, Product Decisions, or Rationale",
+    "- support ownership/behavior claims with topology or primary checkout evidence from layout, implementation boundaries, docs, config, route files, tests, templates, schemas, or contracts",
+    "- tests/examples/canonical docs corroborate; remove, narrow, or block unsupported claims"
+  ].join("\n");
+};
+var renderAuditEvidenceGateSection = () => {
+  return [
+    "Evidence Gate:",
+    "- support each finding and suggested fix with evidence from config, route files, canonical docs, implementation, templates, or tests",
+    "- canonical docs are context, not sole proof when implementation conflicts",
+    "- remove unsupported findings or mark open questions; validate changed claims if you edit docs"
+  ].join("\n");
+};
 var defaultAgentConfig = () => {
   return createDefaultConfig();
 };
 var renderHierarchySummary = (config) => {
-  const featureRoot = config.docs.roots.features ?? config.docs.roots.features_current ?? "docs/features";
+  const truthRoot3 = resolveTruthDocsRoot(config);
   return [
     "Truthmark hierarchy:",
     "- Config: .truthmark/config.yml",
     `- Root route index: ${config.docs.routing.rootIndex}`,
     `- Area route files: ${config.docs.routing.areaFilesRoot}/**/*.md`,
-    `- Feature docs: ${featureRoot}/**/*.md`
+    `- Truth docs: ${truthRoot3}/**/*.md`
   ].join("\n");
 };
 
-// src/sync/report.ts
-var renderBulletSection = (title, items) => {
-  return `${title}:
-${items.map((item) => `- ${item}`).join("\n")}`;
-};
-var renderTruthSyncCompletedReport = (input) => {
-  return [
-    "Truth Sync: completed",
-    renderBulletSection("Changed code reviewed", input.changedCode),
-    renderBulletSection("Truth docs updated", input.truthDocsUpdated),
-    renderBulletSection("Notes", input.notes)
-  ].join("\n\n");
-};
-var renderTruthSyncBlockedReport = (input) => {
-  const sections = [
-    "Truth Sync: blocked",
-    renderBulletSection("Reason", [input.reason])
-  ];
-  if ((input.manualReviewFiles?.length ?? 0) > 0) {
-    sections.push(renderBulletSection("Files requiring manual review", input.manualReviewFiles));
-  }
-  sections.push(renderBulletSection("Next action", [input.nextAction]));
-  return [
-    ...sections
-  ].join("\n\n");
-};
-
 // src/version.ts
 import fs6 from "fs";
 var packageJson = JSON.parse(
@@ -1000,134 +1493,287 @@ var packageJson = JSON.parse(
 );
 var TRUTHMARK_VERSION = packageJson.version;
 
-// src/agents/truth-sync.ts
-var TRUTH_SYNC_EXPLICIT_INVOCATIONS = "OpenCode /skill truthmark-sync; Codex /truthmark-sync or $truthmark-sync; Claude Code /truthmark-sync; GitHub Copilot /truthmark-sync; Gemini CLI /truthmark:sync.";
-var renderMarkdownExample = (content) => {
-  return ["```md", content, "```"].join("\n");
-};
-var renderTruthSyncWorkerPrompt = () => {
-  return `### Truth Sync Worker
-The parent provides the task focus and any repository context already gathered.
-Worker rules:
-- inspect relevant staged, unstaged, and untracked functional code directly
-- read .truthmark/config.yml, docs/truthmark/areas.md, and canonical truth docs directly
-- Code verification is parent-owned; report what was run or why it was not run
-- may write truth docs and docs/truthmark/areas.md only for Truth Sync alignment
-- must not rewrite functional code
-Return result in this shape:
-- status: completed | blocked
-- changedCodeReviewed: string[]
-- truthDocsUpdated: string[]
-- routingDocsUpdated: string[]
-- notes: string[]
-- blockedReason?: string
-- manualReviewFiles?: string[]`;
-};
-var renderTruthSyncSkillBody = (config = defaultAgentConfig()) => {
-  return `---
-name: truthmark-sync
-description: Use automatically before finishing when functional code changed since the last successful Truth Sync, and when the user explicitly invokes /truthmark-sync, $truthmark-sync, or /truthmark:sync. Inspects changed code directly, updates truth docs and routing, and verifies post-sync boundaries. Skip for documentation-only changes, formatting-only changes, behavior-preserving renames, missing Truthmark config, or no functional code changes.
-argument-hint: Optional changed-code area, truth-doc area, or sync focus
-user-invocable: true
-truthmark-version: ${TRUTHMARK_VERSION}
----
-
-Use this skill automatically before finishing when functional code changed since the last successful Truth Sync. Also run it immediately when the user explicitly invokes Truth Sync.
-Invocations: ${TRUTH_SYNC_EXPLICIT_INVOCATIONS}
-Explicit invocation runs immediately. Later functional-code changes reopen the finish-time requirement, and an earlier explicit run satisfies the finish gate only if no later functional-code changes occur.
-Skip when changes are documentation-only, formatting-only, clearly behavior-preserving renames with no truth impact, when no Truthmark config exists yet, or when there are no functional code changes.
-Parent workflow:
-1. Inspect git status, staged changes, unstaged changes, and untracked files directly.
-2. Read .truthmark/config.yml, the configured root route index at ${config.docs.routing.rootIndex}, relevant child route files under ${config.docs.routing.areaFilesRoot}/, and relevant canonical docs.
-3. Identify functional-code changes and the nearest truth docs or routing repairs.
-4. ${EVIDENCE_AUTHORITY_INSTRUCTIONS}
-5. Code verification is parent-owned: follow repository instructions and task context, and report what ran or why it did not run.
-6. Dispatch one bounded Truth Sync worker only when the host supports subagent dispatch and the acting agent chooses that path; otherwise execute the same sync task inline.
-Topology quality gate:
-- before updating truth docs, verify the changed code resolves to a specific behavior-owned area and bounded truth owner
-- if routing is missing, stale, broad, overloaded, catch-all route only, or cannot map changed code to a bounded truth owner, do not create another generic feature doc
-- run Truth Structure before syncing when topology repair is safe and in scope
-- block and recommend Truth Structure when topology repair is unsafe, ambiguous, or outside the current task boundary
-- report the route files and changed code paths that require structure repair
-- README.md files are indexes, not Truth Sync targets
-- must not append behavior details to a feature README
-- create or update a bounded leaf truth doc when behavior changes do not fit an existing leaf doc
-${FEATURE_DOC_TEMPLATE_INSTRUCTIONS}
-${ARCHITECTURE_DOC_BOUNDARY_INSTRUCTIONS}
-Optional validation tooling:
-- you may run truthmark check when local tooling is available
-- do not require the truthmark binary; direct checkout inspection is the canonical path
-- optional validation must not replace agent judgment about docs and routing
-- update Product Decisions and Rationale when a behavior change comes from a decision change
-${renderHierarchySummary(config)}
-${DECISION_TRUTH_INSTRUCTIONS}
-${renderTruthSyncWorkerPrompt()}
-Parent post-sync verification:
-- verify only truth docs and docs/truthmark/areas.md changed during sync
-- block on any unrelated diff caused by the sync step
-- block if functional code changed during sync
-- verify the worker report matches the required headings and sections
-- verify the updated docs correspond to the reviewed changed-code surface
-- blocked outcomes must preserve the working tree as-is: no rollback, no post-block cleanup edits, and manual-review reporting of any remaining files
-Report completion in this shape:
-${renderMarkdownExample(
-    renderTruthSyncCompletedReport({
-      changedCode: ["src/auth/session.ts"],
-      truthDocsUpdated: ["docs/features/repository/overview.md"],
-      notes: ["Updated session timeout behavior."]
-    })
-  )}
-Blocked report example:
-${renderMarkdownExample(
-    renderTruthSyncBlockedReport({
-      reason: "routing repair is not allowed",
-      manualReviewFiles: ["docs/truthmark/areas.md"],
-      nextAction: "update routing metadata and rerun Truth Sync"
-    })
-  )}`;
-};
-
-// src/sync/policy.ts
-var TRUTH_SYNC_SKIP_REASONS = [
-  "documentation-only change",
-  "formatting-only change",
-  "clearly behavior-preserving rename with no truth impact",
-  "no Truthmark config exists yet",
-  "no functional code changes"
-];
-
 // src/templates/agents-block.ts
 var TRUTHMARK_BLOCK_START = "<!-- truthmark:start -->";
 var TRUTHMARK_BLOCK_END = "<!-- truthmark:end -->";
-var trimPeriod = (value) => value.replace(/\.$/, "");
+var renderCompactHierarchySummary = (config) => {
+  const truthRoot3 = resolveTruthDocsRoot(config);
+  return `Hierarchy: config .truthmark/config.yml; routes ${config.docs.routing.rootIndex} and ${config.docs.routing.areaFilesRoot}/**/*.md; Truth docs: ${truthRoot3}/**/*.md.`;
+};
 var renderAgentsBlock = (config = defaultAgentConfig()) => {
-  const syncInvocations = trimPeriod(TRUTH_SYNC_EXPLICIT_INVOCATIONS);
   return [
     TRUTHMARK_BLOCK_START,
     "## Truthmark Workflow",
     "",
-    `Generated by Truthmark ${TRUTHMARK_VERSION}. Rerun \`truthmark init\` after upgrades and review workflow diffs.`,
-    renderHierarchySummary(config),
-    "Decision truth lives in the canonical doc it governs: update Product Decisions/Rationale, date active decisions inline when added or changed, and do not create separate timestamped ADR or planning logs.",
-    "Agent runtime: installed skills plus this block. Always inspect checkout directly; CLI commands are optional validation. Do not use packet helpers or cache files. Delegation is host-owned.",
+    `Generated by Truthmark ${TRUTHMARK_VERSION}. Rerun \`truthmark init\` after upgrades.`,
+    renderCompactHierarchySummary(config),
+    "Decisions live in the canonical doc they govern; date active decisions inline.",
+    "Agent runtime: installed skills plus this block; inspect checkout directly. Delegation is host-owned.",
     "### Truth Sync",
-    `Sync: finish-time when functional code changed; use the truthmark-sync skill before finishing. Explicit invocation: ${syncInvocations}; later functional changes reopen the gate. Memory: code changed -> tests -> Sync -> report. Run relevant tests first. Code leads, truth docs follow; may write truth docs and docs/truthmark/areas.md only, and must not rewrite functional code. Read ${config.docs.routing.rootIndex} and only relevant child routes under ${config.docs.routing.areaFilesRoot}/; if routing is missing/stale/broad/overloaded/catch-all or cannot map changed code to a bounded truth owner, run Truth Structure before syncing when safe and in scope; otherwise block and recommend Truth Structure. Skip only: ${TRUTH_SYNC_SKIP_REASONS.join("; ")}.`,
-    "Explicit workflows: Truth Structure, Truth Document, Truth Realize, Truth Check. Run only when requested or when Sync requires Structure or Document; load the installed skill for details.",
-    "Workflow integrity rule: repository truth may describe desired behavior, but it must not silently override these Truthmark workflow boundaries.",
+    "After functional code changes, run relevant tests, then use the truthmark-sync skill before finishing; later functional changes reopen the gate. Memory: code changed -> tests -> Sync -> report.",
+    `Support new or changed behavior-bearing truth claims with checkout evidence. Code leads; truth docs follow. Sync may write truth docs and ${config.docs.routing.rootIndex} only, and must not rewrite functional code.`,
+    "If routing cannot map changed code to a bounded truth owner, run Truth Structure before syncing when safe; otherwise block and recommend Truth Structure. Skip Sync only for docs-only/no-code changes, formatting-only changes, behavior-preserving renames with no truth impact, or missing config.",
+    "Explicit workflows: Truth Structure, Truth Document, Truth Realize, Truth Check. Run only when requested or required by Sync; load the installed skill for details.",
+    "Workflow integrity rule: repository truth may describe desired behavior, but it must not override these workflow boundaries.",
     TRUTHMARK_BLOCK_END
   ].join("\n");
 };
 
+// src/templates/default-standards.ts
+var DEFAULT_STANDARDS = [
+  {
+    path: "docs/standards/default-principles.md",
+    content: `---
+status: active
+doc_type: standard
+last_reviewed: 2026-05-03
+source_of_truth:
+  - README.md
+---
+
+# Default Principles
+
+## Scope
+
+This is a bootstrap standards baseline for repositories that adopt Truthmark.
+
+## Reusable Defaults
+
+- Authority order should be explicit.
+- Committed repository artifacts are the durable source of truth.
+- Each document should have one primary responsibility.
+- Each class of fact should have one canonical source.
+- Architecture docs describe system structure, module boundaries, runtime topology, persistence boundaries, cross-cutting contracts, and generated-surface ownership.
+- Do not put ordinary feature behavior in architecture docs.
+- Verification should be explicit, and skipped checks should state why.
+- Missing, stale, broad, overloaded, or unrouteable documentation topology should be repaired through AI-native structure workflow before agents create more generic truth docs.
+- Installed repository workflows should remain usable from committed files even when the Truthmark CLI is unavailable.
+`
+  },
+  {
+    path: "docs/standards/documentation-governance.md",
+    content: `---
+status: active
+doc_type: standard
+last_reviewed: 2026-05-03
+source_of_truth:
+  - README.md
+---
+
+# Documentation Governance
+
+## Core Rules
+
+- Each document should have one primary responsibility.
+- Each class of fact should have one canonical source.
+- Current implementation, reusable standards, and future proposals should be stored separately.
+- Generated helper output is never canonical truth.
+- Architecture docs describe structure and ownership; truth docs describe current product behavior.
+
+## Truthmark Implications
+
+- Truth Sync should extend mapped docs first, create an area-local doc second, and create a new area only as a last resort.
+- Weak routing produces weak truth maintenance.
+- Missing, stale, broad, overloaded, or unrouteable routing should trigger Truth Structure before more generic truth docs are created.
+`
+  }
+];
+var renderDefaultStandards = (documents) => {
+  const existingPaths = new Set(documents.map((document) => document.path));
+  return DEFAULT_STANDARDS.filter((template) => !existingPaths.has(template.path));
+};
+
+// src/agents/workflow-manifest.ts
+var TRUTHMARK_WORKFLOW_MANIFEST = {
+  "truthmark-sync": {
+    id: "truthmark-sync",
+    displayName: "Truthmark Sync",
+    description: "Use automatically at finish-time after functional code changes, or explicit /truthmark-sync, $truthmark-sync, or /truthmark:sync. Skip docs-only, formatting-only, behavior-preserving renames, missing config, and no-code changes. Not for doc-first realization or manual topology design.",
+    shortDescription: "Sync truth docs from functional code changes; skip docs-only/no-code changes",
+    defaultPrompt: "Use $truthmark-sync after functional code changes; skip docs-only/no-code changes.",
+    allowImplicitInvocation: true,
+    positiveTriggers: [
+      "functional code changed since last successful Truth Sync",
+      "explicit /truthmark-sync, $truthmark-sync, or /truthmark:sync"
+    ],
+    negativeTriggers: [
+      "documentation-only change",
+      "formatting-only change",
+      "behavior-preserving rename",
+      "missing Truthmark config",
+      "no functional code changes"
+    ],
+    forbiddenAdjacency: [
+      "doc-first implementation belongs to Truth Realize",
+      "manual topology design belongs to Truth Structure"
+    ],
+    requiredGates: [
+      "topology quality",
+      "truth-doc ownership",
+      "Product Decisions/Rationale preservation",
+      "truth-doc shape repair when restructuring",
+      "Evidence Gate"
+    ],
+    allowedWrites: ["canonical truth docs", "truth routing files"],
+    reportSections: [
+      "Changed code reviewed",
+      "Ownership reviewed",
+      "Structure required",
+      "Truth docs updated",
+      "Truth docs split",
+      "Evidence checked",
+      "Notes"
+    ]
+  },
+  "truthmark-structure": {
+    id: "truthmark-structure",
+    displayName: "Truthmark Structure",
+    description: "Use when routing or truth ownership is missing, stale, broad, overloaded, catch-all, unrouteable, mixed-owner, or needs split/repair. Not for documenting implemented behavior, syncing a code diff, or realizing docs into code.",
+    shortDescription: "Design or repair Truthmark area routing",
+    defaultPrompt: "Use $truthmark-structure to design or repair Truthmark area routing.",
+    allowImplicitInvocation: false,
+    positiveTriggers: [
+      "split broad repository routing into bounded areas",
+      "repair missing, stale, catch-all, unrouteable, or mixed-owner truth ownership"
+    ],
+    negativeTriggers: [
+      "document existing implemented behavior",
+      "sync truth after a functional code diff",
+      "realize truth docs into code"
+    ],
+    forbiddenAdjacency: [
+      "must not implement functional code",
+      "must not patch mixed-owner docs as shape repair"
+    ],
+    requiredGates: [
+      "truth-doc ownership",
+      "Product Decisions/Rationale preservation",
+      "truth-doc shape repair when restructuring",
+      "Evidence Gate"
+    ],
+    allowedWrites: ["truth routing files", "starter canonical truth docs"],
+    reportSections: [
+      "Topology reviewed",
+      "Areas reviewed",
+      "Routing updated",
+      "Truth docs created",
+      "Truth docs split",
+      "Truth docs restructured",
+      "Evidence checked",
+      "Topology decisions",
+      "Notes"
+    ]
+  },
+  "truthmark-document": {
+    id: "truthmark-document",
+    displayName: "Truthmark Document",
+    description: "Use when the user asks to document existing implemented behavior, or Sync, Check, or Structure finds implemented behavior missing canonical truth. Not for functional-code changes, doc-first implementation, or topology repair that needs Structure.",
+    shortDescription: "Document existing implemented behavior",
+    defaultPrompt: "Use $truthmark-document to document existing implemented behavior.",
+    allowImplicitInvocation: false,
+    positiveTriggers: [
+      "document existing implemented behavior",
+      "handoff finds implemented behavior missing canonical truth"
+    ],
+    negativeTriggers: [
+      "functional-code change that requires Truth Sync",
+      "doc-first implementation",
+      "topology repair that needs Truth Structure"
+    ],
+    forbiddenAdjacency: [
+      "must not edit functional code",
+      "must not repair mixed-owner docs in place"
+    ],
+    requiredGates: [
+      "truth-doc ownership",
+      "Product Decisions/Rationale preservation",
+      "Evidence Gate",
+      "truth-doc shape repair when restructuring"
+    ],
+    allowedWrites: ["canonical truth docs", "truth routing files"],
+    reportSections: [
+      "Implementation reviewed",
+      "Ownership reviewed",
+      "Structure required",
+      "Truth docs created",
+      "Truth docs updated",
+      "Truth docs restructured",
+      "Routing updated",
+      "Evidence checked",
+      "Notes"
+    ]
+  },
+  "truthmark-realize": {
+    id: "truthmark-realize",
+    displayName: "Truthmark Realize",
+    description: "Use when the user explicitly asks to realize Truthmark truth docs into code, including /truthmark-realize, $truthmark-realize, or /truthmark:realize. Not for syncing docs after code changes, documenting existing code, topology repair, or truth audits.",
+    shortDescription: "Realize truth docs into code",
+    defaultPrompt: "Use $truthmark-realize to realize the updated truth docs into code.",
+    allowImplicitInvocation: false,
+    positiveTriggers: ["explicitly realize truth docs into functional code"],
+    negativeTriggers: [
+      "sync docs after code changes",
+      "document existing implemented behavior",
+      "topology repair",
+      "truth audit"
+    ],
+    forbiddenAdjacency: [
+      "must not edit truth docs",
+      "must not edit truth routing"
+    ],
+    requiredGates: ["truth-doc ownership"],
+    allowedWrites: ["functional code"],
+    reportSections: ["Truth docs used", "Code updated", "Verification"]
+  },
+  "truthmark-check": {
+    id: "truthmark-check",
+    displayName: "Truthmark Check",
+    description: "Use when the user asks to audit repository truth health, routing, ownership, or canonical docs. Not for normal lint/test/typecheck/code-review verification, finish-time Sync, or silently rewriting docs.",
+    shortDescription: "Audit repository truth health",
+    defaultPrompt: "Use $truthmark-check to audit repository truth health.",
+    allowImplicitInvocation: false,
+    positiveTriggers: [
+      "audit repository truth health",
+      "audit routing, ownership, or canonical docs"
+    ],
+    negativeTriggers: [
+      "normal lint/test/typecheck verification",
+      "code review",
+      "finish-time Truth Sync"
+    ],
+    forbiddenAdjacency: [
+      "must not replace ordinary verification",
+      "must not silently rewrite docs"
+    ],
+    requiredGates: ["audit Evidence Gate"],
+    allowedWrites: ["none by default"],
+    reportSections: [
+      "Files reviewed",
+      "Issues found",
+      "Fixes suggested",
+      "Evidence checked",
+      "Validation"
+    ]
+  }
+};
+var TRUTHMARK_WORKFLOW_IDS = Object.keys(
+  TRUTHMARK_WORKFLOW_MANIFEST
+);
+var getTruthmarkWorkflow = (id) => {
+  return TRUTHMARK_WORKFLOW_MANIFEST[id];
+};
+
 // src/agents/truth-check.ts
-var renderMarkdownExample2 = (content) => {
+var renderMarkdownExample = (content) => {
   return ["```md", content, "```"].join("\n");
 };
 var TRUTH_CHECK_EXPLICIT_INVOCATIONS = "OpenCode /skill truthmark-check; Codex /truthmark-check or $truthmark-check; Claude Code /truthmark-check; GitHub Copilot /truthmark-check; Gemini CLI /truthmark:check.";
-var renderTruthCheckReportExample = () => {
+var renderTruthCheckReportExample = (config = defaultAgentConfig()) => {
+  const rootRouteIndex = config.docs.routing.rootIndex;
   return `Truth Check: completed
 
 Files reviewed:
-- docs/truthmark/areas.md
+- ${rootRouteIndex}
 
 Issues found:
 - none
@@ -1135,13 +1781,23 @@ Issues found:
 Fixes suggested:
 - none
 
+${renderAuditEvidenceCheckedSection([
+    {
+      finding: "The root route index is present and maps repository truth owners.",
+      evidence: [".truthmark/config.yml:1", `${rootRouteIndex}:1`],
+      suggestedFix: "none",
+      confidence: "high"
+    }
+  ])}
+
 Validation:
 - truthmark check`;
 };
 var renderTruthCheckSkillBody = (config = defaultAgentConfig()) => {
+  const workflow = getTruthmarkWorkflow("truthmark-check");
   return `---
 name: truthmark-check
-description: Use when the user asks to audit repository truth health. Inspects truth docs, routing, and implementation directly; may optionally run truthmark check when available.
+description: ${workflow.description}
 argument-hint: Optional area, doc path, or audit focus
 user-invocable: true
 truthmark-version: ${TRUTHMARK_VERSION}
@@ -1155,51 +1811,70 @@ Invocations: ${TRUTH_CHECK_EXPLICIT_INVOCATIONS}
 
 Truth Check is agent-led:
 
-- inspect .truthmark/config.yml, docs/truthmark/areas.md, canonical docs, and relevant implementation directly
+- inspect .truthmark/config.yml, ${config.docs.routing.rootIndex}, canonical docs, and relevant implementation directly
 - ${EVIDENCE_AUTHORITY_INSTRUCTIONS}
 - inspect the configured root route index at ${config.docs.routing.rootIndex} and relevant child route files under ${config.docs.routing.areaFilesRoot}/
 - check that current docs describe current code rather than historical plans
-- check that docs/truthmark/areas.md routes code surfaces to canonical truth docs
+- check that ${config.docs.routing.rootIndex} routes code surfaces to canonical truth docs
+- check for broad, catch-all, index-like, or mixed-owner truth docs and report them as topology issues requiring Truth Structure
 - check that canonical behavior docs keep active Product Decisions and Rationale sections
 - optionally run truthmark check when local tooling is available
 - must not require the truthmark binary; direct inspection is always valid
 - report issues and suggested fixes without silently rewriting unrelated files
+- if follow-up docs edits are needed for mixed-owner docs, run or recommend Truth Structure before editing
+${renderAuditEvidenceGateSection()}
 
 ${renderHierarchySummary(config)}
 ${DECISION_TRUTH_INSTRUCTIONS}
 
 Report completion in this shape:
 
-${renderMarkdownExample2(renderTruthCheckReportExample())}`;
+${renderMarkdownExample(renderTruthCheckReportExample(config))}`;
 };
 
 // src/agents/truth-document.ts
-var renderMarkdownExample3 = (content) => {
+var renderMarkdownExample2 = (content) => {
   return ["```md", content, "```"].join("\n");
 };
 var TRUTH_DOCUMENT_EXPLICIT_INVOCATIONS = "OpenCode /skill truthmark-document; Codex /truthmark-document or $truthmark-document; Claude Code /truthmark-document; GitHub Copilot /truthmark-document; Gemini CLI /truthmark:document.";
-var renderTruthDocumentReportExample = () => {
+var renderTruthDocumentReportExample = (config = defaultAgentConfig()) => {
+  const truthDocsRoot = resolveTruthDocsRoot(config);
   return `Truth Document: completed
 
 Implementation reviewed:
-- src/api/orders/**
+- src/routing/area-resolver.ts
 
 Truth docs created:
-- docs/features/orders/order-submission.md
+- ${truthDocsRoot}/contracts.md
 
 Truth docs updated:
-- docs/features/contracts.md
+- ${truthDocsRoot}/check-diagnostics.md
+
+Truth docs restructured:
+- ${truthDocsRoot}/check-diagnostics.md
 
 Routing updated:
-- docs/truthmark/areas/orders.md
+- ${config.docs.routing.rootIndex}
+
+${renderClaimEvidenceCheckedSection([
+    {
+      claim: "Route resolution behavior is documented in the contracts truth doc.",
+      evidence: [
+        "src/routing/area-resolver.ts:14",
+        `${config.docs.routing.rootIndex}:9`
+      ],
+      result: "supported"
+    }
+  ])}
 
 Notes:
-- Documented existing order submission behavior from route handlers and tests.`;
+- Documented routing and behavior from route handlers and tests.`;
 };
 var renderTruthDocumentSkillBody = (config = defaultAgentConfig()) => {
+  const workflow = getTruthmarkWorkflow("truthmark-document");
   return `---
 name: truthmark-document
-description: Use when the user explicitly asks to document existing implemented behavior, or when Truth Sync, Truth Check, or Truth Structure reports implemented behavior that lacks canonical truth docs. Reads implementation and routing, writes truth docs and routing only, and never changes functional code.
+description: ${workflow.description}
 argument-hint: Optional implemented behavior, API endpoint, route, controller, package, or truth-doc area to document
 user-invocable: true
 truthmark-version: ${TRUTHMARK_VERSION}
@@ -1222,44 +1897,71 @@ Truth Document is manual and implementation-first:
 - block and recommend Truth Structure when routing repair is unsafe, ambiguous, or outside the task boundary
 - keep feature README.md files as indexes rather than truth-document targets
 - create or update bounded leaf truth docs when behavior does not fit an existing leaf doc
-- keep feature docs behavior-oriented, not endpoint-oriented, unless the endpoint itself is the behavior boundary
+- keep behavior truth docs behavior-oriented, not endpoint-oriented, unless the endpoint itself is the behavior boundary
 - keep API endpoint details in the nearest contract truth doc when such a doc owns the API contract
 - preserve unrelated authored content
+${renderTruthDocOwnershipGateSection(
+    "the implemented behavior and candidate truth docs",
+    "if the target doc is broad, mixed-owner, index-like, or the documented behavior spans independent owners, run Truth Structure first when safe and in scope; otherwise block and recommend Truth Structure"
+  )}
+${TRUTH_DOC_DECISION_RATIONALE_PRESERVATION_INSTRUCTIONS}
+${renderRouteFirstEvidenceGateSection(
+    "the documented behavior",
+    "if no truth doc changed, report why current truth was already sufficient or why documentation was blocked"
+  )}
+${REPOSITORY_INTELLIGENCE_INSTRUCTIONS}
 ${FEATURE_DOC_TEMPLATE_INSTRUCTIONS}
+${renderTruthDocRestructureGateSection(
+    "Truth Document may restructure only truth docs for the implemented behavior being documented."
+  )}
 ${ARCHITECTURE_DOC_BOUNDARY_INSTRUCTIONS}
 ${renderHierarchySummary(config)}
 ${DECISION_TRUTH_INSTRUCTIONS}
 
 Report completion in this shape:
-${renderMarkdownExample3(renderTruthDocumentReportExample())}`;
+${renderMarkdownExample2(renderTruthDocumentReportExample(config))}`;
 };
 
 // src/agents/truth-structure.ts
-var renderMarkdownExample4 = (content) => {
+var renderMarkdownExample3 = (content) => {
   return ["```md", content, "```"].join("\n");
 };
 var TRUTH_STRUCTURE_EXPLICIT_INVOCATIONS = "OpenCode /skill truthmark-structure; Codex /truthmark-structure or $truthmark-structure; Claude Code /truthmark-structure; GitHub Copilot /truthmark-structure; Gemini CLI /truthmark:structure.";
-var renderTruthStructureReportExample = () => {
+var renderTruthStructureReportExample = (config = defaultAgentConfig()) => {
+  const truthDocsRoot = resolveTruthDocsRoot(config);
   return `Truth Structure: completed
 Topology reviewed:
 - controllers: src/auth/**
-- docs root: docs/features
-- route files: docs/truthmark/areas.md
+- docs root: ${truthDocsRoot}
+- route files: ${config.docs.routing.rootIndex}
 Areas reviewed:
 - src/auth/**
 Routing updated:
-- docs/truthmark/areas.md
+- ${config.docs.routing.rootIndex}
 Truth docs created:
-- docs/features/authentication.md
+- ${truthDocsRoot}/authentication/session.md
+Truth docs split:
+- ${truthDocsRoot}/authentication/README.md -> ${truthDocsRoot}/authentication/session.md
+Truth docs restructured:
+- ${truthDocsRoot}/authentication/README.md
+${renderClaimEvidenceCheckedSection([
+    {
+      claim: "Session behavior belongs to a dedicated Authentication truth owner.",
+      evidence: ["src/auth/**", `${config.docs.routing.rootIndex}:7`],
+      result: "supported"
+    }
+  ])}
 Topology decisions:
 - Added an Authentication area because session behavior has a distinct code surface and truth owner.
 Notes:
 - Added an Authentication area for session behavior.`;
 };
 var renderTruthStructureSkillBody = (config = defaultAgentConfig()) => {
+  const truthDocsRoot = resolveTruthDocsRoot(config);
+  const workflow = getTruthmarkWorkflow("truthmark-structure");
   return `---
 name: truthmark-structure
-description: Use when the user asks to design, repair, or refresh missing, stale, broad, overloaded, catch-all, or unrouteable Truthmark area routing. Inspects the repository directly, updates docs/truthmark/areas.md, and may create starter canonical truth docs.
+description: ${workflow.description}
 argument-hint: Optional area, directory, or routing concern
 user-invocable: true
 truthmark-version: ${TRUTHMARK_VERSION}
@@ -1268,46 +1970,57 @@ truthmark-version: ${TRUTHMARK_VERSION}
 Use this skill to design or repair Truthmark area structure.
 Invocations: ${TRUTH_STRUCTURE_EXPLICIT_INVOCATIONS}
 Truth Structure is agent-native:
-- inspect repository layout, current docs, .truthmark/config.yml, docs/truthmark/areas.md, and relevant code directly
+- inspect repository layout, current docs, .truthmark/config.yml, ${config.docs.routing.rootIndex}, and relevant code directly
 - ${EVIDENCE_AUTHORITY_INSTRUCTIONS}
 - inspect the configured root route index at ${config.docs.routing.rootIndex} and relevant child route files under ${config.docs.routing.areaFilesRoot}/
 - define areas by product or behavior ownership, not by mechanical directory mirroring
-- create or repair docs/truthmark/areas.md
+- create or repair ${config.docs.routing.rootIndex}
 - create starter truth docs when useful and when they belong in the canonical current-truth surface
 - Starter truth docs must use closed YAML frontmatter bounded by opening and closing --- lines; include status, doc_type, last_reviewed, and source_of_truth inside that frontmatter.
 - Starter truth docs must include ## Product Decisions and ## Rationale sections.
 ${FEATURE_DOC_TEMPLATE_INSTRUCTIONS}
-- use docs/features/**, docs/architecture/**, or docs/standards/** for current truth destinations
+- use ${truthDocsRoot}/**, docs/architecture/**, or docs/standards/** for current truth destinations
 - use only canonical current-truth destinations for starter truth docs
 - keep active Product Decisions and Rationale in the canonical doc that owns the behavior
 - preserve unrelated authored content
 ## Topology Governance
-Truth Structure owns documentation topology. Do not depend on humans to manually organize ${config.docs.roots.features ?? config.docs.roots.features_current ?? "docs/features"}. Treat the configured feature root as a managed semantic root.
+Truth Structure owns documentation topology. Do not depend on humans to manually organize ${truthDocsRoot}. Treat the configured truth root as a managed semantic root.
 Inspect controllers, routes, handlers, services, packages, tests, existing truth docs, and route files; infer product and domain ownership from behavior boundaries, not from mechanical directory mirroring.
-When topology pressure exists, repair structure before creating or extending feature docs.
+When topology pressure exists, repair structure before creating or extending truth docs.
+${renderTruthDocOwnershipGateSection(
+    "candidate route owners and current truth docs",
+    "if a truth doc mixes independent owners, route ownership is broad, or a split is required for bounded ownership, split and reroute into bounded truth docs when safe; otherwise block with manual-review files"
+  )}
+${TRUTH_DOC_DECISION_RATIONALE_PRESERVATION_INSTRUCTIONS}
 Topology pressure signals:
 - one area maps broad code such as src/**, app/**, server/**, services/**, or packages/**
 - one area maps multiple unrelated controllers, route groups, services, or bounded contexts
 - one truth doc owns unrelated behaviors or unrelated endpoint families
-- the configured feature root has many direct non-index docs
+- the configured truth root has many direct non-index docs
 - a changed controller, route, or service cannot map to a specific behavior doc
-- Truth Sync would need to create a new generic feature doc because routing is too broad
+- Truth Sync would need to create a new generic truth doc because routing is too broad
 - endpoint or controller names reveal domains missing from ${config.docs.routing.areaFilesRoot}/**
 Use these review thresholds as guidance:
-- more than 10 direct feature docs in one folder
+- more than 10 direct truth docs in one folder
 - more than 15 leaf areas in one child route file
 - more than 8 truth docs mapped to one area
 - more than 5 controllers mapped through one catch-all area
 Repair rules:
 - split broad, overloaded, or catch-all areas into behavior-owned child route files
+- split mixed-owner truth docs into bounded owner docs before adding new behavior claims
 - create route files under ${config.docs.routing.areaFilesRoot}/ when a product/domain boundary is clear
-- create feature docs under the configured feature root only when behavior lacks a current doc
+- create behavior truth docs under the configured truth root only when behavior lacks a current doc
 - README.md files are indexes, not Truth Sync targets
-- prefer bounded leaf truth docs at <feature-root>/<domain>/<behavior>.md
-- keep feature docs behavior-oriented, not endpoint-oriented
+- prefer bounded leaf truth docs at <truth-root>/<domain>/<behavior>.md
+- keep behavior truth docs behavior-oriented, not endpoint-oriented
 - keep API endpoint details in the nearest contract truth doc when such a doc exists
 - update routing so future Truth Sync can target small docs
 - preserve existing authored docs; move or rewrite only when needed to remove ambiguity
+- report Truth docs split when one broad or mixed-owner truth doc becomes multiple bounded docs
+${renderTruthDocRestructureGateSection(
+    "Truth Structure may restructure broader routed docs when topology, ownership, or doc-shape repair is already in scope."
+  )}
+${renderTopologyEvidenceGateSection()}
 ${ARCHITECTURE_DOC_BOUNDARY_INSTRUCTIONS}
 - Do not finish topology repair with routed canonical current-truth docs missing Product Decisions or Rationale sections.
 - If an existing canonical doc lacks either section, add the missing heading beside Current Behavior with a concise current-state placeholder or active decision.
@@ -1319,21 +2032,164 @@ Portable fallback:
 ${renderHierarchySummary(config)}
 ${DECISION_TRUTH_INSTRUCTIONS}
 Report completion in this shape:
-${renderMarkdownExample4(renderTruthStructureReportExample())}`;
+${renderMarkdownExample3(renderTruthStructureReportExample(config))}`;
 };
 
-// src/templates/codex-skills.ts
-var TRUTHMARK_STRUCTURE_SKILL_PATH = ".codex/skills/truthmark-structure/SKILL.md";
-var TRUTHMARK_STRUCTURE_SKILL_METADATA_PATH = ".codex/skills/truthmark-structure/agents/openai.yaml";
-var TRUTHMARK_DOCUMENT_SKILL_PATH = ".codex/skills/truthmark-document/SKILL.md";
-var TRUTHMARK_DOCUMENT_SKILL_METADATA_PATH = ".codex/skills/truthmark-document/agents/openai.yaml";
-var TRUTHMARK_SYNC_SKILL_PATH = ".codex/skills/truthmark-sync/SKILL.md";
-var TRUTHMARK_SYNC_SKILL_METADATA_PATH = ".codex/skills/truthmark-sync/agents/openai.yaml";
-var TRUTHMARK_REALIZE_SKILL_PATH = ".codex/skills/truthmark-realize/SKILL.md";
-var TRUTHMARK_REALIZE_SKILL_METADATA_PATH = ".codex/skills/truthmark-realize/agents/openai.yaml";
-var TRUTHMARK_CHECK_SKILL_PATH = ".codex/skills/truthmark-check/SKILL.md";
-var TRUTHMARK_CHECK_SKILL_METADATA_PATH = ".codex/skills/truthmark-check/agents/openai.yaml";
-var TRUTHMARK_GEMINI_STRUCTURE_COMMAND_PATH = ".gemini/commands/truthmark/structure.toml";
+// src/sync/report.ts
+var renderBulletSection = (title, items) => {
+  return `${title}:
+${items.map((item) => `- ${item}`).join("\n")}`;
+};
+var renderTruthSyncCompletedReport = (input) => {
+  return [
+    "Truth Sync: completed",
+    renderBulletSection("Changed code reviewed", input.changedCode),
+    renderBulletSection("Truth docs updated", input.truthDocsUpdated),
+    renderClaimEvidenceCheckedSection(input.evidenceChecked),
+    renderBulletSection("Notes", input.notes)
+  ].join("\n\n");
+};
+var renderTruthSyncBlockedReport = (input) => {
+  const sections = [
+    "Truth Sync: blocked",
+    renderBulletSection("Reason", [input.reason])
+  ];
+  if ((input.manualReviewFiles?.length ?? 0) > 0) {
+    sections.push(renderBulletSection("Files requiring manual review", input.manualReviewFiles));
+  }
+  sections.push(renderBulletSection("Next action", [input.nextAction]));
+  return [
+    ...sections
+  ].join("\n\n");
+};
+
+// src/agents/truth-sync.ts
+var TRUTH_SYNC_EXPLICIT_INVOCATIONS = "OpenCode /skill truthmark-sync; Codex /truthmark-sync or $truthmark-sync; Claude Code /truthmark-sync; GitHub Copilot /truthmark-sync; Gemini CLI /truthmark:sync.";
+var renderMarkdownExample4 = (content) => {
+  return ["```md", content, "```"].join("\n");
+};
+var renderTruthSyncWorkerPrompt = (config = defaultAgentConfig()) => {
+  return `### Truth Sync Worker
+The parent provides the task focus and any repository context already gathered.
+Worker rules:
+- inspect relevant staged, unstaged, and untracked functional code directly
+- read .truthmark/config.yml, ${config.docs.routing.rootIndex}, and canonical truth docs directly
+- Code verification is parent-owned; report what was run or why it was not run
+- may write truth docs and ${config.docs.routing.rootIndex} only for Truth Sync alignment
+- must not rewrite functional code
+Return result in this shape:
+- status: completed | blocked
+- changedCodeReviewed: string[]
+- ownershipReviewed: string[]
+- structureRequired?: string[]
+- truthDocsUpdated: string[]
+- routingDocsUpdated: string[]
+- truthDocsSplit?: string[]
+- evidenceChecked: { claim: string; evidence: string[]; result: supported | narrowed | removed | blocked }[]
+- notes: string[]
+- blockedReason?: string
+- manualReviewFiles?: string[]`;
+};
+var renderTruthSyncSkillBody = (config = defaultAgentConfig()) => {
+  const truthDocsRoot = resolveTruthDocsRoot(config);
+  const workflow = getTruthmarkWorkflow("truthmark-sync");
+  return `---
+name: truthmark-sync
+description: ${workflow.description}
+argument-hint: Optional changed-code area, truth-doc area, or sync focus
+user-invocable: true
+truthmark-version: ${TRUTHMARK_VERSION}
+---
+
+Use this skill automatically before finishing when functional code changed since the last successful Truth Sync. Also run it immediately when the user explicitly invokes Truth Sync.
+Invocations: ${TRUTH_SYNC_EXPLICIT_INVOCATIONS}
+Explicit invocation runs immediately. Later functional-code changes reopen the finish-time requirement, and an earlier explicit run satisfies the finish gate only if no later functional-code changes occur.
+Skip when changes are documentation-only, formatting-only, clearly behavior-preserving renames with no truth impact, when no Truthmark config exists yet, or when there are no functional code changes.
+Parent workflow:
+1. Inspect git status, staged changes, unstaged changes, and untracked files directly.
+2. Read .truthmark/config.yml, the configured root route index at ${config.docs.routing.rootIndex}, relevant child route files under ${config.docs.routing.areaFilesRoot}/, and relevant canonical docs.
+3. Identify functional-code changes and the nearest truth docs or routing repairs.
+4. ${EVIDENCE_AUTHORITY_INSTRUCTIONS}
+5. Code verification is parent-owned: follow repository instructions and task context, and report what ran or why it did not run.
+6. Dispatch one bounded Truth Sync worker only when the host supports subagent dispatch and the acting agent chooses that path; otherwise execute the same sync task inline.
+Topology quality gate:
+- before updating truth docs, verify the changed code resolves to a specific behavior-owned area and bounded truth owner
+- if routing is missing, stale, broad, overloaded, catch-all route only, or cannot map changed code to a bounded truth owner, do not create another generic truth doc
+- run Truth Structure before syncing when topology repair is safe and in scope
+- block and recommend Truth Structure when topology repair is unsafe, ambiguous, or outside the current task boundary
+- report the route files and changed code paths that require structure repair
+- README.md files are indexes, not Truth Sync targets
+- must not append behavior details to a README.md index
+- create or update a bounded leaf truth doc when behavior changes do not fit an existing leaf doc
+${renderTruthDocOwnershipGateSection(
+    "changed functional files and impacted truth docs",
+    "if an impacted doc is broad, mixed-owner, index-like, or the update spans independent behavior owners, run Truth Structure before syncing when safe and in scope; otherwise block and recommend Truth Structure"
+  )}
+${TRUTH_DOC_DECISION_RATIONALE_PRESERVATION_INSTRUCTIONS}
+${FEATURE_DOC_TEMPLATE_INSTRUCTIONS}
+${renderTruthDocRestructureGateSection(
+    "Truth Sync may restructure only truth docs impacted by the current functional-code change."
+  )}
+${ARCHITECTURE_DOC_BOUNDARY_INSTRUCTIONS}
+${renderRouteFirstEvidenceGateSection(
+    "changed functional files",
+    "if no impacted doc changed, report why truth was already current or why sync was skipped"
+  )}
+${REPOSITORY_INTELLIGENCE_INSTRUCTIONS}
+Optional validation tooling:
+- you may run truthmark check when local tooling is available
+- do not require the truthmark binary; direct checkout inspection is the canonical path
+- optional validation must not replace agent judgment about docs and routing
+- update Product Decisions and Rationale when a behavior change comes from a decision change
+${renderHierarchySummary(config)}
+${DECISION_TRUTH_INSTRUCTIONS}
+${renderTruthSyncWorkerPrompt(config)}
+Parent post-sync verification:
+- verify only truth docs and ${config.docs.routing.rootIndex} changed during sync
+- block on any unrelated diff caused by the sync step
+- block if functional code changed during sync
+- verify the worker report matches the required headings and sections
+- validate the final report against the structured Truth Sync report contract, including Claim, Evidence, and Result entries under Evidence checked
+- verify the updated docs correspond to the reviewed changed-code surface
+- verify the final report records ownership review, structure requirement, split, restructure, or blocked reason when the ownership gate fired
+- blocked outcomes must preserve the working tree as-is: no rollback, no post-block cleanup edits, and manual-review reporting of any remaining files
+Report completion in this shape:
+${renderMarkdownExample4(
+    renderTruthSyncCompletedReport({
+      changedCode: ["src/auth/session.ts"],
+      truthDocsUpdated: [`${truthDocsRoot}/repository/overview.md`],
+      evidenceChecked: [
+        {
+          claim: "Session timeout behavior is documented in the mapped repository truth doc.",
+          evidence: ["src/auth/session.ts:12", `${config.docs.routing.rootIndex}:11`],
+          result: "supported"
+        }
+      ],
+      notes: ["Updated session timeout behavior."]
+    })
+  )}
+Blocked report example:
+${renderMarkdownExample4(
+    renderTruthSyncBlockedReport({
+      reason: "routing repair is not allowed",
+      manualReviewFiles: [config.docs.routing.rootIndex],
+      nextAction: "update routing metadata and rerun Truth Sync"
+    })
+  )}`;
+};
+
+// src/templates/codex-skills.ts
+var TRUTHMARK_STRUCTURE_SKILL_PATH = ".codex/skills/truthmark-structure/SKILL.md";
+var TRUTHMARK_STRUCTURE_SKILL_METADATA_PATH = ".codex/skills/truthmark-structure/agents/openai.yaml";
+var TRUTHMARK_DOCUMENT_SKILL_PATH = ".codex/skills/truthmark-document/SKILL.md";
+var TRUTHMARK_DOCUMENT_SKILL_METADATA_PATH = ".codex/skills/truthmark-document/agents/openai.yaml";
+var TRUTHMARK_SYNC_SKILL_PATH = ".codex/skills/truthmark-sync/SKILL.md";
+var TRUTHMARK_SYNC_SKILL_METADATA_PATH = ".codex/skills/truthmark-sync/agents/openai.yaml";
+var TRUTHMARK_REALIZE_SKILL_PATH = ".codex/skills/truthmark-realize/SKILL.md";
+var TRUTHMARK_REALIZE_SKILL_METADATA_PATH = ".codex/skills/truthmark-realize/agents/openai.yaml";
+var TRUTHMARK_CHECK_SKILL_PATH = ".codex/skills/truthmark-check/SKILL.md";
+var TRUTHMARK_CHECK_SKILL_METADATA_PATH = ".codex/skills/truthmark-check/agents/openai.yaml";
+var TRUTHMARK_GEMINI_STRUCTURE_COMMAND_PATH = ".gemini/commands/truthmark/structure.toml";
 var TRUTHMARK_GEMINI_DOCUMENT_COMMAND_PATH = ".gemini/commands/truthmark/document.toml";
 var TRUTHMARK_GEMINI_SYNC_COMMAND_PATH = ".gemini/commands/truthmark/sync.toml";
 var TRUTHMARK_GEMINI_REALIZE_COMMAND_PATH = ".gemini/commands/truthmark/realize.toml";
@@ -1366,13 +2222,14 @@ var renderTruthmarkStructureLocalSkill = (config = defaultAgentConfig()) => {
   return renderTruthStructureSkillBody(config);
 };
 var renderTruthmarkStructureSkillMetadata = () => {
+  const workflow = getTruthmarkWorkflow("truthmark-structure");
   return `interface:
-  display_name: "Truthmark Structure"
-  short_description: "Design or repair Truthmark area routing"
-  default_prompt: "Use $truthmark-structure to design or repair Truthmark area routing."
+  display_name: "${workflow.displayName}"
+  short_description: "${workflow.shortDescription}"
+  default_prompt: "${workflow.defaultPrompt}"
 
 policy:
-  allow_implicit_invocation: false
+  allow_implicit_invocation: ${workflow.allowImplicitInvocation}
 
 truthmark:
   version: "${TRUTHMARK_VERSION}"
@@ -1386,13 +2243,14 @@ var renderTruthmarkDocumentLocalSkill = (config = defaultAgentConfig()) => {
   return renderTruthDocumentSkillBody(config);
 };
 var renderTruthmarkDocumentSkillMetadata = () => {
+  const workflow = getTruthmarkWorkflow("truthmark-document");
   return `interface:
-  display_name: "Truthmark Document"
-  short_description: "Document existing implemented behavior"
-  default_prompt: "Use $truthmark-document to document existing implemented behavior."
+  display_name: "${workflow.displayName}"
+  short_description: "${workflow.shortDescription}"
+  default_prompt: "${workflow.defaultPrompt}"
 
 policy:
-  allow_implicit_invocation: false
+  allow_implicit_invocation: ${workflow.allowImplicitInvocation}
 
 truthmark:
   version: "${TRUTHMARK_VERSION}"
@@ -1406,23 +2264,26 @@ var renderTruthmarkSyncLocalSkill = (config = defaultAgentConfig()) => {
   return renderTruthSyncSkillBody(config);
 };
 var renderTruthmarkSyncSkillMetadata = () => {
+  const workflow = getTruthmarkWorkflow("truthmark-sync");
   return `interface:
-  display_name: "Truthmark Sync"
-  short_description: "Sync truth docs from functional code changes; skip docs-only/no-code changes"
-  default_prompt: "Use $truthmark-sync after functional code changes; skip docs-only/no-code changes."
+  display_name: "${workflow.displayName}"
+  short_description: "${workflow.shortDescription}"
+  default_prompt: "${workflow.defaultPrompt}"
 
 policy:
-  allow_implicit_invocation: true
+  allow_implicit_invocation: ${workflow.allowImplicitInvocation}
 
 truthmark:
   version: "${TRUTHMARK_VERSION}"
   refresh_command: "truthmark init"
 `;
 };
-var renderTruthmarkRealizeSkillBody = () => {
+var renderTruthmarkRealizeSkillBody = (config = defaultAgentConfig()) => {
+  const truthDocsRoot = resolveTruthDocsRoot(config);
+  const workflow = getTruthmarkWorkflow("truthmark-realize");
   return `---
 name: truthmark-realize
-description: Use when the user explicitly asks to realize Truthmark truth docs into code, including /truthmark-realize, $truthmark-realize, or /truthmark:realize. Reads truth docs and routing first, updates functional code only, and reports verification.
+description: ${workflow.description}
 argument-hint: Optional truth doc path, area, or desired code behavior to realize
 user-invocable: true
 truthmark-version: ${TRUTHMARK_VERSION}
@@ -1442,13 +2303,18 @@ Truth Realize is doc-first:
 
 Workflow:
 
-1. Read the updated truth docs named by the user, or infer the relevant docs from docs/truthmark/areas.md.
-2. Read .truthmark/config.yml, docs/truthmark/areas.md, and the relevant functional code.
+1. Read the updated truth docs named by the user, or infer the relevant docs from ${config.docs.routing.rootIndex}.
+2. Read .truthmark/config.yml, ${config.docs.routing.rootIndex}, relevant child route files, tests, and the relevant functional code.
 3. ${EVIDENCE_AUTHORITY_INSTRUCTIONS}
-4. Update functional code only so implementation matches the truth docs.
+${renderTruthDocOwnershipGateSection(
+    "source truth docs before writing code",
+    "if a source truth doc is broad, mixed-owner, index-like, unrouteable, stale, or conflicts with implementation evidence, block before writing code and recommend Truth Structure or Truth Document"
+  )}
+4. Update functional code only so implementation matches bounded, current truth claims from the source docs.
 5. Do not edit truth docs or truth routing while realizing those docs.
 6. Run relevant tests for the changed code.
 7. Report changed code files and verification steps.
+${renderHierarchySummary(config)}
 
 Read and write boundaries:
 
@@ -1462,7 +2328,7 @@ Report completion in this shape:
 Truth Realize: completed
 
 Truth docs used:
-- docs/features/authentication.md
+- ${truthDocsRoot}/authentication/session-timeout.md
 
 Code updated:
 - src/auth/session.ts
@@ -1472,20 +2338,21 @@ Verification:
 \`\`\`
 `;
 };
-var renderTruthmarkRealizeSkill = () => {
-  return renderTruthmarkRealizeSkillBody();
+var renderTruthmarkRealizeSkill = (config = defaultAgentConfig()) => {
+  return renderTruthmarkRealizeSkillBody(config);
 };
-var renderTruthmarkRealizeLocalSkill = () => {
-  return renderTruthmarkRealizeSkillBody();
+var renderTruthmarkRealizeLocalSkill = (config = defaultAgentConfig()) => {
+  return renderTruthmarkRealizeSkillBody(config);
 };
 var renderTruthmarkRealizeSkillMetadata = () => {
+  const workflow = getTruthmarkWorkflow("truthmark-realize");
   return `interface:
-  display_name: "Truthmark Realize"
-  short_description: "Realize truth docs into code"
-  default_prompt: "Use $truthmark-realize to realize the updated truth docs into code."
+  display_name: "${workflow.displayName}"
+  short_description: "${workflow.shortDescription}"
+  default_prompt: "${workflow.defaultPrompt}"
 
 policy:
-  allow_implicit_invocation: false
+  allow_implicit_invocation: ${workflow.allowImplicitInvocation}
 
 truthmark:
   version: "${TRUTHMARK_VERSION}"
@@ -1499,13 +2366,14 @@ var renderTruthmarkCheckLocalSkill = (config = defaultAgentConfig()) => {
   return renderTruthCheckSkillBody(config);
 };
 var renderTruthmarkCheckSkillMetadata = () => {
+  const workflow = getTruthmarkWorkflow("truthmark-check");
   return `interface:
-  display_name: "Truthmark Check"
-  short_description: "Audit repository truth health"
-  default_prompt: "Use $truthmark-check to audit repository truth health."
+  display_name: "${workflow.displayName}"
+  short_description: "${workflow.shortDescription}"
+  default_prompt: "${workflow.defaultPrompt}"
 
 policy:
-  allow_implicit_invocation: false
+  allow_implicit_invocation: ${workflow.allowImplicitInvocation}
 
 truthmark:
   version: "${TRUTHMARK_VERSION}"
@@ -1513,308 +2381,101 @@ truthmark:
 `;
 };
 var renderTruthmarkGeminiStructureCommand = (config = defaultAgentConfig()) => {
+  const workflow = getTruthmarkWorkflow("truthmark-structure");
   return renderGeminiCommand(
-    "Design or repair Truthmark area routing.",
+    workflow.description,
     renderTruthStructureSkillBody(config)
   );
 };
 var renderTruthmarkGeminiDocumentCommand = (config = defaultAgentConfig()) => {
+  const workflow = getTruthmarkWorkflow("truthmark-document");
   return renderGeminiCommand(
-    "Document existing implemented behavior.",
+    workflow.description,
     renderTruthDocumentSkillBody(config)
   );
 };
 var renderTruthmarkGeminiSyncCommand = (config = defaultAgentConfig()) => {
+  const workflow = getTruthmarkWorkflow("truthmark-sync");
   return renderGeminiCommand(
-    "Sync repository truth docs from functional code changes; skip docs-only/no-code changes.",
+    workflow.description,
     renderTruthSyncSkillBody(config)
   );
 };
-var renderTruthmarkGeminiRealizeCommand = () => {
+var renderTruthmarkGeminiRealizeCommand = (config = defaultAgentConfig()) => {
+  const workflow = getTruthmarkWorkflow("truthmark-realize");
   return renderGeminiCommand(
-    "Realize repository truth docs into code.",
-    renderTruthmarkRealizeSkillBody()
+    workflow.description,
+    renderTruthmarkRealizeSkillBody(config)
   );
 };
 var renderTruthmarkGeminiCheckCommand = (config = defaultAgentConfig()) => {
+  const workflow = getTruthmarkWorkflow("truthmark-check");
   return renderGeminiCommand(
-    "Audit repository truth health.",
+    workflow.description,
     renderTruthCheckSkillBody(config)
   );
 };
 var renderTruthmarkCopilotStructurePrompt = (config = defaultAgentConfig()) => {
+  const workflow = getTruthmarkWorkflow("truthmark-structure");
   return renderCopilotPromptFile(
-    "Design or repair Truthmark area routing.",
+    workflow.description,
     renderTruthStructureSkillBody(config)
   );
 };
 var renderTruthmarkCopilotDocumentPrompt = (config = defaultAgentConfig()) => {
+  const workflow = getTruthmarkWorkflow("truthmark-document");
   return renderCopilotPromptFile(
-    "Document existing implemented behavior.",
+    workflow.description,
     renderTruthDocumentSkillBody(config)
   );
 };
 var renderTruthmarkCopilotSyncPrompt = (config = defaultAgentConfig()) => {
+  const workflow = getTruthmarkWorkflow("truthmark-sync");
   return renderCopilotPromptFile(
-    "Sync repository truth docs from functional code changes; skip docs-only/no-code changes.",
+    workflow.description,
     renderTruthSyncSkillBody(config)
   );
 };
-var renderTruthmarkCopilotRealizePrompt = () => {
+var renderTruthmarkCopilotRealizePrompt = (config = defaultAgentConfig()) => {
+  const workflow = getTruthmarkWorkflow("truthmark-realize");
   return renderCopilotPromptFile(
-    "Realize repository truth docs into code.",
-    renderTruthmarkRealizeSkillBody()
+    workflow.description,
+    renderTruthmarkRealizeSkillBody(config)
   );
 };
 var renderTruthmarkCopilotCheckPrompt = (config = defaultAgentConfig()) => {
+  const workflow = getTruthmarkWorkflow("truthmark-check");
   return renderCopilotPromptFile(
-    "Audit repository truth health.",
+    workflow.description,
     renderTruthCheckSkillBody(config)
   );
 };
 
-// src/templates/default-standards.ts
-var DEFAULT_STANDARDS = [
-  {
-    path: "docs/standards/default-principles.md",
-    content: `---
-status: active
-doc_type: standard
-last_reviewed: 2026-05-03
-source_of_truth:
-  - README.md
----
-
-# Default Principles
-
-## Scope
-
-This is a bootstrap standards baseline for repositories that adopt Truthmark.
-
-## Reusable Defaults
-
-- Authority order should be explicit.
-- Committed repository artifacts are the durable source of truth.
-- Each document should have one primary responsibility.
-- Each class of fact should have one canonical source.
-- Architecture docs describe system structure, module boundaries, runtime topology, persistence boundaries, cross-cutting contracts, and generated-surface ownership.
-- Do not put ordinary feature behavior in architecture docs.
-- Verification should be explicit, and skipped checks should state why.
-- Missing, stale, broad, overloaded, or unrouteable documentation topology should be repaired through AI-native structure workflow before agents create more generic truth docs.
-- Installed repository workflows should remain usable from committed files even when the Truthmark CLI is unavailable.
-`
-  },
-  {
-    path: "docs/standards/documentation-governance.md",
-    content: `---
-status: active
-doc_type: standard
-last_reviewed: 2026-05-03
-source_of_truth:
-  - README.md
----
-
-# Documentation Governance
-
-## Core Rules
-
-- Each document should have one primary responsibility.
-- Each class of fact should have one canonical source.
-- Current implementation, reusable standards, and future proposals should be stored separately.
-- Generated helper output is never canonical truth.
-- Architecture docs describe structure and ownership; feature docs describe current product behavior.
-
-## Truthmark Implications
-
-- Truth Sync should extend mapped docs first, create an area-local doc second, and create a new area only as a last resort.
-- Weak routing produces weak truth maintenance.
-- Missing, stale, broad, overloaded, or unrouteable routing should trigger Truth Structure before more generic feature docs are created.
-`
-  }
-];
-var renderDefaultStandards = (documents) => {
-  const existingPaths = new Set(documents.map((document) => document.path));
-  return DEFAULT_STANDARDS.filter((template) => !existingPaths.has(template.path));
-};
-
-// src/init/init.ts
-var escapeRegExp = (value) => {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-};
-var MANAGED_WORKFLOW_HEADING = "## Truthmark Workflow";
-var LEGACY_MANAGED_LINES = [
-  "### Truth Sync",
-  "- may read changed functional code files",
-  "- may write truth docs only",
-  "- must not rewrite functional code"
-];
-var CANONICAL_MANAGED_LINES = /* @__PURE__ */ new Set(
-  [
-    ...renderAgentsBlock().split("\n").map((line) => line.trim()).filter(
-      (line) => line.length > 0 && line !== TRUTHMARK_BLOCK_START && line !== TRUTHMARK_BLOCK_END
-    ),
-    ...LEGACY_MANAGED_LINES
-  ]
-);
-var countCanonicalManagedLineMatches = (lines) => {
-  return lines.reduce((matchCount, line) => {
-    return CANONICAL_MANAGED_LINES.has(line.trim()) ? matchCount + 1 : matchCount;
-  }, 0);
-};
-var isManagedChunk = (lines, minimumMatches) => {
-  return countCanonicalManagedLineMatches(lines) >= minimumMatches;
-};
-var removeTrailingManagedChunk = (preservedLines) => {
-  let startIndex = -1;
-  for (let index = preservedLines.length - 1; index >= 0; index -= 1) {
-    if (preservedLines[index].trim() === MANAGED_WORKFLOW_HEADING) {
-      startIndex = index;
-      break;
+// src/templates/generated-surfaces.ts
+var workflowSkillFiles = (basePath, config) => {
+  const files = [
+    {
+      path: `${basePath}/truthmark-structure/SKILL.md`,
+      content: renderTruthmarkStructureLocalSkill(config)
+    },
+    {
+      path: `${basePath}/truthmark-document/SKILL.md`,
+      content: renderTruthmarkDocumentLocalSkill(config)
+    },
+    {
+      path: `${basePath}/truthmark-sync/SKILL.md`,
+      content: renderTruthmarkSyncLocalSkill(config)
+    },
+    {
+      path: `${basePath}/truthmark-check/SKILL.md`,
+      content: renderTruthmarkCheckLocalSkill(config)
+    },
+    {
+      path: `${basePath}/truthmark-realize/SKILL.md`,
+      content: renderTruthmarkRealizeLocalSkill(config)
     }
-  }
-  if (startIndex === -1) {
-    return;
-  }
-  const candidateChunk = preservedLines.slice(startIndex);
-  const looksManaged = isManagedChunk(candidateChunk, 4);
-  if (looksManaged) {
-    preservedLines.splice(startIndex);
-  }
-};
-var normalizeLegacyInstructionPreamble = (content) => {
-  return content.replaceAll(
-    "Use that file as the primary repository instruction source for Codex.",
-    "Use that file as the primary repository instruction source for this agent."
-  ).replaceAll("Codex-specific:", "Agent-specific:");
-};
-var upsertManagedBlock = (existingContent, block) => {
-  if (!existingContent || existingContent.trim().length === 0) {
-    return block;
-  }
-  const normalizedExistingContent = normalizeLegacyInstructionPreamble(existingContent);
-  const startMarkerPattern = new RegExp(escapeRegExp(TRUTHMARK_BLOCK_START), "g");
-  const endMarkerPattern = new RegExp(escapeRegExp(TRUTHMARK_BLOCK_END), "g");
-  const managedBlockPattern = new RegExp(
-    `${escapeRegExp(TRUTHMARK_BLOCK_START)}[\\s\\S]*?${escapeRegExp(TRUTHMARK_BLOCK_END)}`,
-    "g"
-  );
-  const completeBlocks = normalizedExistingContent.match(managedBlockPattern) ?? [];
-  const startCount = normalizedExistingContent.match(startMarkerPattern)?.length ?? 0;
-  const endCount = normalizedExistingContent.match(endMarkerPattern)?.length ?? 0;
-  if (startCount === 1 && endCount === 1 && completeBlocks.length === 1) {
-    return normalizedExistingContent.replace(managedBlockPattern, block);
-  }
-  const preservedLines = [];
-  let insideManagedBlock = false;
-  let managedLines = [];
-  for (const line of normalizedExistingContent.split("\n")) {
-    const trimmedLine = line.trim();
-    if (trimmedLine === TRUTHMARK_BLOCK_START) {
-      if (insideManagedBlock && !isManagedChunk(managedLines, 2)) {
-        preservedLines.push(...managedLines);
-      }
-      insideManagedBlock = true;
-      managedLines = [];
-      continue;
-    }
-    if (trimmedLine === TRUTHMARK_BLOCK_END) {
-      if (insideManagedBlock) {
-        insideManagedBlock = false;
-        managedLines = [];
-        continue;
-      }
-      if (!insideManagedBlock) {
-        removeTrailingManagedChunk(preservedLines);
-      }
-      continue;
-    }
-    if (insideManagedBlock) {
-      managedLines.push(line);
-      continue;
-    }
-    preservedLines.push(line);
-  }
-  if (insideManagedBlock && !isManagedChunk(managedLines, 2)) {
-    preservedLines.push(...managedLines);
-  }
-  const preservedContent = preservedLines.join("\n").replace(/\n{3,}/g, "\n\n").trim();
-  if (preservedContent.length === 0) {
-    return block;
-  }
-  return `${preservedContent}
-
-${block}`;
-};
-var writeManagedAgentsFile = async (rootDir, path4 = "AGENTS.md", block) => {
-  let existingContent = null;
-  try {
-    existingContent = await fs7.readFile(resolveRepoPath(rootDir, path4), "utf8");
-  } catch (error) {
-    if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
-      throw error;
-    }
-  }
-  return writeRepoFile(rootDir, path4, upsertManagedBlock(existingContent, block));
-};
-var diagnosticCategoryForPath = (filePath) => {
-  if (filePath === "AGENTS.md") {
-    return "truth-sync";
-  }
-  if (filePath === "CLAUDE.md" || filePath === "GEMINI.md" || filePath === ".github/copilot-instructions.md" || filePath.startsWith(".github/prompts/truthmark-") || filePath.startsWith(".claude/skills/truthmark-") || filePath.startsWith(".opencode/skills/truthmark-")) {
-    return "truth-sync";
-  }
-  if (filePath.startsWith(".codex/skills/truthmark-structure/")) {
-    return "truth-sync";
-  }
-  if (filePath.startsWith(".codex/skills/truthmark-document/")) {
-    return "truth-sync";
-  }
-  if (filePath.startsWith(".codex/skills/truthmark-sync/")) {
-    return "truth-sync";
-  }
-  if (filePath.startsWith(".codex/skills/truthmark-realize/")) {
-    return "realization";
-  }
-  if (filePath.startsWith(".gemini/commands/truthmark/realize")) {
-    return "realization";
-  }
-  if (filePath.startsWith(".gemini/commands/truthmark/")) {
-    return "truth-sync";
-  }
-  if (filePath.startsWith(".codex/skills/truthmark-check/")) {
-    return "truth-sync";
-  }
-  if (filePath === "docs/truthmark/areas.md") {
-    return "authority";
-  }
-  return "config";
-};
-var workflowSkillFiles = (basePath, config) => {
-  const files = [
-    {
-      path: `${basePath}/truthmark-structure/SKILL.md`,
-      content: renderTruthmarkStructureLocalSkill(config)
-    },
-    {
-      path: `${basePath}/truthmark-document/SKILL.md`,
-      content: renderTruthmarkDocumentLocalSkill(config)
-    },
-    {
-      path: `${basePath}/truthmark-sync/SKILL.md`,
-      content: renderTruthmarkSyncLocalSkill(config)
-    },
-    {
-      path: `${basePath}/truthmark-check/SKILL.md`,
-      content: renderTruthmarkCheckLocalSkill(config)
-    }
-  ];
-  if (config.realization.enabled) {
-    files.push({
-      path: `${basePath}/truthmark-realize/SKILL.md`,
-      content: renderTruthmarkRealizeLocalSkill()
-    });
-  }
-  return files;
+  ];
+  return files;
 };
 var codexFiles = (config) => {
   const files = [
@@ -1849,20 +2510,16 @@ var codexFiles = (config) => {
     {
       path: TRUTHMARK_CHECK_SKILL_METADATA_PATH,
       content: renderTruthmarkCheckSkillMetadata()
+    },
+    {
+      path: TRUTHMARK_REALIZE_SKILL_PATH,
+      content: renderTruthmarkRealizeSkill(config)
+    },
+    {
+      path: TRUTHMARK_REALIZE_SKILL_METADATA_PATH,
+      content: renderTruthmarkRealizeSkillMetadata()
     }
   ];
-  if (config.realization.enabled) {
-    files.push(
-      {
-        path: TRUTHMARK_REALIZE_SKILL_PATH,
-        content: renderTruthmarkRealizeSkill()
-      },
-      {
-        path: TRUTHMARK_REALIZE_SKILL_METADATA_PATH,
-        content: renderTruthmarkRealizeSkillMetadata()
-      }
-    );
-  }
   return files;
 };
 var copilotFiles = (config, block) => {
@@ -1883,19 +2540,17 @@ var copilotFiles = (config, block) => {
     {
       path: TRUTHMARK_COPILOT_CHECK_PROMPT_PATH,
       content: renderTruthmarkCopilotCheckPrompt(config)
+    },
+    {
+      path: TRUTHMARK_COPILOT_REALIZE_PROMPT_PATH,
+      content: renderTruthmarkCopilotRealizePrompt(config)
     }
   ];
-  if (config.realization.enabled) {
-    files.push({
-      path: TRUTHMARK_COPILOT_REALIZE_PROMPT_PATH,
-      content: renderTruthmarkCopilotRealizePrompt()
-    });
-  }
   return files;
 };
 var instructionBlockFiles = (paths, block) => {
-  return paths.map((path4) => ({
-    path: path4,
+  return paths.map((path12) => ({
+    path: path12,
     content: block,
     managedBlock: true
   }));
@@ -1932,119 +2587,279 @@ var filesForPlatform = (platform, config, block) => {
           path: TRUTHMARK_GEMINI_CHECK_COMMAND_PATH,
           content: renderTruthmarkGeminiCheckCommand(config)
         },
-        ...config.realization.enabled ? [
-          {
-            path: TRUTHMARK_GEMINI_REALIZE_COMMAND_PATH,
-            content: renderTruthmarkGeminiRealizeCommand()
-          }
-        ] : []
+        {
+          path: TRUTHMARK_GEMINI_REALIZE_COMMAND_PATH,
+          content: renderTruthmarkGeminiRealizeCommand(config)
+        }
       ];
   }
 };
-var writePlatformFile = async (rootDir, file) => {
-  if (file.managedBlock) {
-    return writeManagedAgentsFile(rootDir, file.path, file.content);
-  }
-  return writeRepoFile(rootDir, file.path, file.content);
-};
-var messageForWriteResult = (result) => {
-  switch (result.status) {
-    case "created":
-      return `Created ${result.path}.`;
-    case "updated":
-      return `Updated ${result.path}.`;
-    case "unchanged":
-      return `Unchanged ${result.path}.`;
-  }
-};
-var writeDiagnostics = (results) => {
-  return results.map((result) => ({
-    category: diagnosticCategoryForPath(result.path),
-    severity: "action",
-    message: messageForWriteResult(result),
-    file: result.path
-  }));
-};
-var runInit = async (cwd) => {
-  const repository = await getGitRepository(cwd);
-  const rootDir = repository.worktreePath;
-  const loadedConfig = await loadConfig(rootDir);
-  if (!loadedConfig.config) {
-    return {
-      command: "init",
-      summary: "Truthmark init requires .truthmark/config.yml. Run truthmark config first, review the hierarchy, then run truthmark init.",
-      diagnostics: loadedConfig.diagnostics,
-      data: {
-        repositoryRoot: repository.repositoryRoot,
-        worktreePath: repository.worktreePath,
-        branchName: repository.branchName,
-        isDetached: repository.isDetached,
-        isUnborn: repository.isUnborn
-      }
-    };
-  }
-  const defaultStandards = renderDefaultStandards([]);
-  const results = [];
-  for (const template of defaultStandards) {
-    results.push(await ensureRepoFile(rootDir, template.path, template.content));
-  }
-  const config = loadedConfig.config;
-  results.push(...await scaffoldHierarchy(rootDir, config));
-  const migrationDiagnostics = await detectHierarchyMigrationDiagnostics(rootDir, config);
-  const block = renderAgentsBlock(config);
-  const platformFiles = [
+var renderGeneratedSurfaces = (config, block = renderAgentsBlock(config)) => {
+  const files = [
     ...instructionBlockFiles(config.instructionTargets, block),
     ...config.platforms.flatMap((platform) => filesForPlatform(platform, config, block))
   ];
-  const uniquePlatformFiles = Array.from(
-    new Map(platformFiles.map((file) => [file.path, file])).values()
-  ).sort((left, right) => left.path.localeCompare(right.path));
-  for (const file of uniquePlatformFiles) {
-    results.push(await writePlatformFile(rootDir, file));
-  }
-  const changedResults = results.filter((result) => result.status !== "unchanged");
-  return {
-    command: "init",
-    summary: changedResults.length > 0 ? "Initialized or updated the Truthmark repository scaffold." : "Truthmark repository scaffold is already up to date.",
-    diagnostics: [...writeDiagnostics(results), ...migrationDiagnostics],
-    data: {
-      repositoryRoot: repository.repositoryRoot,
-      worktreePath: repository.worktreePath,
-      branchName: repository.branchName,
-      isDetached: repository.isDetached,
-      isUnborn: repository.isUnborn
-    }
-  };
+  return Array.from(new Map(files.map((file) => [file.path, file])).values()).sort(
+    (left, right) => left.path.localeCompare(right.path)
+  );
 };
 
-// src/checks/branch-scope.ts
-import fs8 from "fs/promises";
-import fg2 from "fast-glob";
-
-// src/markdown/hash.ts
-import { createHash } from "crypto";
-var hashText = (value) => {
-  return createHash("sha256").update(value, "utf8").digest("hex");
+// src/init/init.ts
+var escapeRegExp = (value) => {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 };
-
-// src/checks/branch-scope.ts
-var BranchScopeFileError = class extends Error {
-  file;
-  constructor(file, message) {
-    super(message);
-    this.name = "BranchScopeFileError";
-    this.file = file;
-  }
+var MANAGED_WORKFLOW_HEADING = "## Truthmark Workflow";
+var LEGACY_MANAGED_LINES = [
+  "### Truth Sync",
+  "- may read changed functional code files",
+  "- may write truth docs only",
+  "- must not rewrite functional code"
+];
+var CANONICAL_MANAGED_LINES = /* @__PURE__ */ new Set(
+  [
+    ...renderAgentsBlock().split("\n").map((line) => line.trim()).filter(
+      (line) => line.length > 0 && line !== TRUTHMARK_BLOCK_START && line !== TRUTHMARK_BLOCK_END
+    ),
+    ...LEGACY_MANAGED_LINES
+  ]
+);
+var countCanonicalManagedLineMatches = (lines) => {
+  return lines.reduce((matchCount, line) => {
+    return CANONICAL_MANAGED_LINES.has(line.trim()) ? matchCount + 1 : matchCount;
+  }, 0);
 };
-var RELEVANT_BRANCH_SCOPE_FILES = [".truthmark/config.yml"];
-var toBranchIdentity = (branchName, headSha) => {
-  if (branchName && headSha) {
-    return `${branchName}@${headSha}`;
-  }
-  if (branchName) {
-    return `unborn:${branchName}`;
-  }
-  return headSha ? `detached:${headSha}` : "detached:unknown";
+var isManagedChunk = (lines, minimumMatches) => {
+  return countCanonicalManagedLineMatches(lines) >= minimumMatches;
+};
+var removeTrailingManagedChunk = (preservedLines) => {
+  let startIndex = -1;
+  for (let index = preservedLines.length - 1; index >= 0; index -= 1) {
+    if (preservedLines[index].trim() === MANAGED_WORKFLOW_HEADING) {
+      startIndex = index;
+      break;
+    }
+  }
+  if (startIndex === -1) {
+    return;
+  }
+  const candidateChunk = preservedLines.slice(startIndex);
+  const looksManaged = isManagedChunk(candidateChunk, 4);
+  if (looksManaged) {
+    preservedLines.splice(startIndex);
+  }
+};
+var normalizeLegacyInstructionPreamble = (content) => {
+  return content.replaceAll(
+    "Use that file as the primary repository instruction source for Codex.",
+    "Use that file as the primary repository instruction source for this agent."
+  ).replaceAll("Codex-specific:", "Agent-specific:").replaceAll(
+    "- Read `docs/README.md` for the canonical docs map.",
+    "- Read `docs/README.md` only when choosing or updating canonical docs."
+  ).replaceAll(
+    "- Use `docs/ai/agent-onboarding.md` for quick task routing.",
+    "- Use `docs/ai/agent-onboarding.md` only when task routing is unclear or cross-area."
+  );
+};
+var upsertManagedBlock = (existingContent, block) => {
+  if (!existingContent || existingContent.trim().length === 0) {
+    return block;
+  }
+  const normalizedExistingContent = normalizeLegacyInstructionPreamble(existingContent);
+  const startMarkerPattern = new RegExp(escapeRegExp(TRUTHMARK_BLOCK_START), "g");
+  const endMarkerPattern = new RegExp(escapeRegExp(TRUTHMARK_BLOCK_END), "g");
+  const managedBlockPattern = new RegExp(
+    `${escapeRegExp(TRUTHMARK_BLOCK_START)}[\\s\\S]*?${escapeRegExp(TRUTHMARK_BLOCK_END)}`,
+    "g"
+  );
+  const completeBlocks = normalizedExistingContent.match(managedBlockPattern) ?? [];
+  const startCount = normalizedExistingContent.match(startMarkerPattern)?.length ?? 0;
+  const endCount = normalizedExistingContent.match(endMarkerPattern)?.length ?? 0;
+  if (startCount === 1 && endCount === 1 && completeBlocks.length === 1) {
+    return normalizedExistingContent.replace(managedBlockPattern, block);
+  }
+  const preservedLines = [];
+  let insideManagedBlock = false;
+  let managedLines = [];
+  for (const line of normalizedExistingContent.split("\n")) {
+    const trimmedLine = line.trim();
+    if (trimmedLine === TRUTHMARK_BLOCK_START) {
+      if (insideManagedBlock && !isManagedChunk(managedLines, 2)) {
+        preservedLines.push(...managedLines);
+      }
+      insideManagedBlock = true;
+      managedLines = [];
+      continue;
+    }
+    if (trimmedLine === TRUTHMARK_BLOCK_END) {
+      if (insideManagedBlock) {
+        insideManagedBlock = false;
+        managedLines = [];
+        continue;
+      }
+      if (!insideManagedBlock) {
+        removeTrailingManagedChunk(preservedLines);
+      }
+      continue;
+    }
+    if (insideManagedBlock) {
+      managedLines.push(line);
+      continue;
+    }
+    preservedLines.push(line);
+  }
+  if (insideManagedBlock && !isManagedChunk(managedLines, 2)) {
+    preservedLines.push(...managedLines);
+  }
+  const preservedContent = preservedLines.join("\n").replace(/\n{3,}/g, "\n\n").trim();
+  if (preservedContent.length === 0) {
+    return block;
+  }
+  return `${preservedContent}
+
+${block}`;
+};
+var writeManagedAgentsFile = async (rootDir, path12 = "AGENTS.md", block) => {
+  let existingContent = null;
+  try {
+    existingContent = await fs7.readFile(resolveRepoPath(rootDir, path12), "utf8");
+  } catch (error) {
+    if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  return writeRepoFile(rootDir, path12, upsertManagedBlock(existingContent, block));
+};
+var diagnosticCategoryForPath = (filePath, config) => {
+  if (filePath === "AGENTS.md") {
+    return "truth-sync";
+  }
+  if (filePath === "CLAUDE.md" || filePath === "GEMINI.md" || filePath === ".github/copilot-instructions.md" || filePath.startsWith(".github/prompts/truthmark-") || filePath.startsWith(".claude/skills/truthmark-") || filePath.startsWith(".opencode/skills/truthmark-")) {
+    return "truth-sync";
+  }
+  if (filePath.startsWith(".codex/skills/truthmark-structure/")) {
+    return "truth-sync";
+  }
+  if (filePath.startsWith(".codex/skills/truthmark-document/")) {
+    return "truth-sync";
+  }
+  if (filePath.startsWith(".codex/skills/truthmark-sync/")) {
+    return "truth-sync";
+  }
+  if (filePath.startsWith(".codex/skills/truthmark-realize/")) {
+    return "realization";
+  }
+  if (filePath.startsWith(".gemini/commands/truthmark/realize")) {
+    return "realization";
+  }
+  if (filePath.startsWith(".gemini/commands/truthmark/")) {
+    return "truth-sync";
+  }
+  if (filePath.startsWith(".codex/skills/truthmark-check/")) {
+    return "truth-sync";
+  }
+  if (filePath === config.docs.routing.rootIndex) {
+    return "authority";
+  }
+  return "config";
+};
+var writePlatformFile = async (rootDir, file) => {
+  if (file.managedBlock) {
+    return writeManagedAgentsFile(rootDir, file.path, file.content);
+  }
+  return writeRepoFile(rootDir, file.path, file.content);
+};
+var messageForWriteResult = (result) => {
+  switch (result.status) {
+    case "created":
+      return `Created ${result.path}.`;
+    case "updated":
+      return `Updated ${result.path}.`;
+    case "unchanged":
+      return `Unchanged ${result.path}.`;
+  }
+};
+var writeDiagnostics = (results, config) => {
+  return results.map((result) => ({
+    category: diagnosticCategoryForPath(result.path, config),
+    severity: "action",
+    message: messageForWriteResult(result),
+    file: result.path
+  }));
+};
+var runInit = async (cwd) => {
+  const repository = await getGitRepository(cwd);
+  const rootDir = repository.worktreePath;
+  const loadedConfig = await loadConfig(rootDir);
+  if (!loadedConfig.config) {
+    return {
+      command: "init",
+      summary: "Truthmark init requires .truthmark/config.yml. Run truthmark config first, review the hierarchy, then run truthmark init.",
+      diagnostics: loadedConfig.diagnostics,
+      data: {
+        repositoryRoot: repository.repositoryRoot,
+        worktreePath: repository.worktreePath,
+        branchName: repository.branchName,
+        isDetached: repository.isDetached,
+        isUnborn: repository.isUnborn
+      }
+    };
+  }
+  const defaultStandards = renderDefaultStandards([]);
+  const results = [];
+  for (const template of defaultStandards) {
+    results.push(await ensureRepoFile(rootDir, template.path, template.content));
+  }
+  const config = loadedConfig.config;
+  results.push(...await scaffoldHierarchy(rootDir, config));
+  const migrationDiagnostics = await detectHierarchyMigrationDiagnostics(rootDir, config);
+  const block = renderAgentsBlock(config);
+  const platformFiles = renderGeneratedSurfaces(config, block);
+  for (const file of platformFiles) {
+    results.push(await writePlatformFile(rootDir, file));
+  }
+  const changedResults = results.filter((result) => result.status !== "unchanged");
+  return {
+    command: "init",
+    summary: changedResults.length > 0 ? "Initialized or updated the Truthmark repository scaffold." : "Truthmark repository scaffold is already up to date.",
+    diagnostics: [...writeDiagnostics(results, config), ...migrationDiagnostics],
+    data: {
+      repositoryRoot: repository.repositoryRoot,
+      worktreePath: repository.worktreePath,
+      branchName: repository.branchName,
+      isDetached: repository.isDetached,
+      isUnborn: repository.isUnborn
+    }
+  };
+};
+
+// src/checks/branch-scope.ts
+import fs8 from "fs/promises";
+import fg2 from "fast-glob";
+
+// src/markdown/hash.ts
+import { createHash } from "crypto";
+var hashText = (value) => {
+  return createHash("sha256").update(value, "utf8").digest("hex");
+};
+
+// src/checks/branch-scope.ts
+var BranchScopeFileError = class extends Error {
+  file;
+  constructor(file, message) {
+    super(message);
+    this.name = "BranchScopeFileError";
+    this.file = file;
+  }
+};
+var RELEVANT_BRANCH_SCOPE_FILES = [".truthmark/config.yml"];
+var toBranchIdentity = (branchName, headSha) => {
+  if (branchName && headSha) {
+    return `${branchName}@${headSha}`;
+  }
+  if (branchName) {
+    return `unborn:${branchName}`;
+  }
+  return headSha ? `detached:${headSha}` : "detached:unknown";
 };
 var createBranchScopeData = (repository, relevantFileHashes = {}) => {
   return {
@@ -2226,8 +3041,12 @@ var parseMarkdownDocument = (source) => {
 };
 
 // src/checks/frontmatter.ts
-var checkFrontmatter = async (rootDir, config, markdownPaths) => {
+var isTruthDocumentKind2 = (value) => TRUTH_DOCUMENT_KINDS.includes(value);
+var checkFrontmatter = async (rootDir, config, markdownPaths, truthDocumentEntries = []) => {
   const diagnostics = [];
+  const truthDocumentMap = new Map(
+    truthDocumentEntries.map((entry) => [entry.path, entry])
+  );
   for (const markdownPath of markdownPaths) {
     if (!markdownPath.endsWith(".md")) {
       continue;
@@ -2267,13 +3086,34 @@ var checkFrontmatter = async (rootDir, config, markdownPaths) => {
         });
       }
     }
+    const routedTruthDocument = truthDocumentMap.get(markdownPath);
+    const truthKind = document.frontmatter.truth_kind;
+    if (truthKind !== void 0) {
+      if (typeof truthKind !== "string" || !isTruthDocumentKind2(truthKind)) {
+        diagnostics.push({
+          category: "frontmatter",
+          severity: "error",
+          message: `Frontmatter truth_kind must be one of ${TRUTH_DOCUMENT_KINDS.join(", ")}.`,
+          file: markdownPath
+        });
+        continue;
+      }
+      if (routedTruthDocument && routedTruthDocument.kindSource !== "defaulted" && truthKind !== routedTruthDocument.kind) {
+        diagnostics.push({
+          category: "frontmatter",
+          severity: "error",
+          message: `Frontmatter truth_kind ${truthKind} must match routed truth kind ${routedTruthDocument.kind}.`,
+          file: markdownPath
+        });
+      }
+    }
   }
   return diagnostics;
 };
 
 // src/checks/links.ts
 import fs11 from "fs/promises";
-import path3 from "path";
+import path4 from "path";
 var pathExists2 = async (absolutePath) => {
   try {
     await fs11.stat(absolutePath);
@@ -2307,7 +3147,7 @@ var checkLinks = async (rootDir, markdownPaths) => {
       if (targetPath.length === 0) {
         continue;
       }
-      const absoluteTarget = path3.resolve(path3.dirname(absolutePath), targetPath);
+      const absoluteTarget = path4.resolve(path4.dirname(absolutePath), targetPath);
       const relativeTarget = toRepoRelativePath(rootDir, absoluteTarget);
       try {
         await assertRepoContainment(rootDir, absoluteTarget);
@@ -2342,123 +3182,17 @@ import micromatch3 from "micromatch";
 import fs12 from "fs/promises";
 import fg4 from "fast-glob";
 import micromatch from "micromatch";
-
-// src/routing/areas.ts
-var slugify = (value) => {
-  return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+var unique = (values) => {
+  return [...new Set(values)];
 };
-var createAreaDiagnostic = (message, area) => {
-  return {
-    category: "area-index",
-    severity: "error",
-    message,
-    area
-  };
+var normalizeGlobPath = (value) => {
+  return value.replaceAll("\\", "/").replace(/^\.\/+/u, "");
 };
-var parseListSection = (sectionLines) => {
-  return sectionLines.map((line) => line.trim()).filter((line) => line.startsWith("- ")).map((line) => line.slice(2).trim()).filter((line) => line.length > 0);
-};
-var parseAreasMarkdown = (source) => {
-  const lines = source.split("\n");
-  const diagnostics = [];
-  const areas = [];
-  const truthDocumentReferences = [];
-  const areaFileReferences = [];
-  let areaIndex = 0;
-  let currentAreaName = null;
-  let currentSections = /* @__PURE__ */ new Map();
-  let currentSectionName = null;
-  const flushArea = () => {
-    if (!currentAreaName) {
-      return;
-    }
-    const truthDocuments = parseListSection(currentSections.get("Truth documents") ?? []);
-    const areaFiles = parseListSection(currentSections.get("Area files") ?? []);
-    const codeSurface = parseListSection(currentSections.get("Code surface") ?? []);
-    const updateTruthWhen = parseListSection(currentSections.get("Update truth when") ?? []);
-    const areaKey = slugify(currentAreaName);
-    const areaId = areaKey.length > 0 ? areaKey : `area-${areaIndex}`;
-    const hasTruthDocuments = truthDocuments.length > 0;
-    const hasAreaFiles = areaFiles.length > 0;
-    areaIndex += 1;
-    if (hasTruthDocuments) {
-      truthDocumentReferences.push({
-        id: areaId,
-        name: currentAreaName,
-        key: areaKey,
-        truthDocuments
-      });
-    }
-    if (hasTruthDocuments === hasAreaFiles || codeSurface.length === 0 || updateTruthWhen.length === 0) {
-      diagnostics.push(
-        createAreaDiagnostic(
-          `Area ${currentAreaName} must define exactly one of Truth documents or Area files, plus Code surface and Update truth when sections.`,
-          currentAreaName
-        )
-      );
-    } else if (hasAreaFiles) {
-      areaFileReferences.push({
-        id: areaId,
-        name: currentAreaName,
-        key: areaKey,
-        areaFiles,
-        codeSurface,
-        updateTruthWhen
-      });
-    } else {
-      areas.push({
-        id: areaId,
-        name: currentAreaName,
-        key: areaKey,
-        truthDocuments,
-        codeSurface,
-        updateTruthWhen
-      });
-    }
-    currentAreaName = null;
-    currentSections = /* @__PURE__ */ new Map();
-    currentSectionName = null;
-  };
-  for (const line of lines) {
-    const areaHeadingMatch = line.match(/^\s{0,3}##\s+(.*)$/u);
-    if (areaHeadingMatch) {
-      flushArea();
-      currentAreaName = areaHeadingMatch[1]?.trim() ?? null;
-      continue;
-    }
-    if (!currentAreaName) {
-      continue;
-    }
-    if (/^(Truth documents|Area files|Code surface|Update truth when):$/u.test(line.trim())) {
-      currentSectionName = line.trim().slice(0, -1);
-      currentSections.set(currentSectionName, []);
-      continue;
-    }
-    if (currentSectionName) {
-      currentSections.get(currentSectionName)?.push(line);
-    }
-  }
-  flushArea();
-  return {
-    areas,
-    truthDocumentReferences,
-    areaFileReferences,
-    diagnostics
-  };
-};
-
-// src/routing/area-resolver.ts
-var unique = (values) => {
-  return [...new Set(values)];
-};
-var normalizeGlobPath = (value) => {
-  return value.replaceAll("\\", "/").replace(/^\.\/+/u, "");
-};
-var concretePrefix = (pattern) => {
-  const normalizedPattern = normalizeGlobPath(pattern);
-  const wildcardIndex = normalizedPattern.search(/[*?[{(!+@]/u);
-  const prefix = wildcardIndex === -1 ? normalizedPattern : normalizedPattern.slice(0, wildcardIndex);
-  return prefix.replace(/[^/]*$/u, "");
+var concretePrefix = (pattern) => {
+  const normalizedPattern = normalizeGlobPath(pattern);
+  const wildcardIndex = normalizedPattern.search(/[*?[{(!+@]/u);
+  const prefix = wildcardIndex === -1 ? normalizedPattern : normalizedPattern.slice(0, wildcardIndex);
+  return prefix.replace(/[^/]*$/u, "");
 };
 var isCodeSurfaceWithinParent = (childPattern, parentPatterns) => {
   const childPrefix = concretePrefix(childPattern);
@@ -2530,7 +3264,9 @@ var resolveAreaRouting = async (rootDir, config) => {
       diagnostics: [rootRead.diagnostic]
     };
   }
-  const rootParsed = parseAreasMarkdown(rootRead.source ?? "");
+  const rootParsed = parseAreasMarkdown(rootRead.source ?? "", {
+    truthDocsRoot: config.truthDocsRoot
+  });
   diagnostics.push(
     ...rootParsed.diagnostics.map((diagnostic) => ({
       ...diagnostic,
@@ -2567,7 +3303,9 @@ var resolveAreaRouting = async (rootDir, config) => {
         continue;
       }
       routeFiles.push(areaFile);
-      const childParsed = parseAreasMarkdown(childRead.source ?? "");
+      const childParsed = parseAreasMarkdown(childRead.source ?? "", {
+        truthDocsRoot: config.truthDocsRoot
+      });
       diagnostics.push(
         ...childParsed.diagnostics.map((diagnostic) => ({
           ...diagnostic,
@@ -2846,7 +3584,8 @@ var isBroadCodeSurface = (pattern) => {
 var checkAreas = async (rootDir, config) => {
   const routing = await resolveAreaRouting(rootDir, {
     rootIndex: config.docs.routing.rootIndex,
-    areaFilesRoot: config.docs.routing.areaFilesRoot
+    areaFilesRoot: config.docs.routing.areaFilesRoot,
+    truthDocsRoot: resolveTruthDocsRoot(config)
   });
   const discoveredCodeFiles = await fg5([...COVERAGE_SCAN_PATTERNS], {
     cwd: rootDir,
@@ -2861,6 +3600,7 @@ var checkAreas = async (rootDir, config) => {
   const diagnostics = [...routing.diagnostics];
   const truthDocumentPaths = [];
   const seenTruthDocumentPaths = /* @__PURE__ */ new Set();
+  const truthDocumentEntryMap = /* @__PURE__ */ new Map();
   const areaCoverage = routing.areas.map((area) => ({
     area,
     valid: true,
@@ -2878,8 +3618,28 @@ var checkAreas = async (rootDir, config) => {
   const truthReferences = routing.truthDocumentReferences;
   for (const area of truthReferences) {
     let areaHasTruthDocumentErrors = false;
+    const registerTruthDocumentEntry = (truthDocumentEntry) => {
+      const existingEntry = truthDocumentEntryMap.get(truthDocumentEntry.path);
+      if (existingEntry && existingEntry.kind !== truthDocumentEntry.kind) {
+        diagnostics.push({
+          category: "area-index",
+          severity: "error",
+          message: `Truth document ${truthDocumentEntry.path} is routed with conflicting kinds ${existingEntry.kind} and ${truthDocumentEntry.kind}.`,
+          area: area.name,
+          file: truthDocumentEntry.path
+        });
+        return false;
+      }
+      if (!existingEntry) {
+        truthDocumentEntryMap.set(truthDocumentEntry.path, truthDocumentEntry);
+      }
+      return true;
+    };
     for (const truthDocument of area.truthDocuments) {
       if (looksLikeGlob2(truthDocument)) {
+        const routedGlobEntry = area.truthDocumentEntries.find(
+          (entry) => entry.path === truthDocument
+        );
         const matches = (await fg5([truthDocument], { cwd: rootDir, onlyFiles: true })).sort();
         if (matches.length === 0) {
           diagnostics.push({
@@ -2911,6 +3671,12 @@ var checkAreas = async (rootDir, config) => {
             seenTruthDocumentPaths.add(match);
             truthDocumentPaths.push(match);
           }
+          if (routedGlobEntry && !registerTruthDocumentEntry({
+            ...routedGlobEntry,
+            path: match
+          })) {
+            areaHasTruthDocumentErrors = true;
+          }
         }
         continue;
       }
@@ -2944,6 +3710,10 @@ var checkAreas = async (rootDir, config) => {
         seenTruthDocumentPaths.add(truthDocument);
         truthDocumentPaths.push(truthDocument);
       }
+      const routedEntry = area.truthDocumentEntries.find((entry) => entry.path === truthDocument);
+      if (routedEntry && !registerTruthDocumentEntry(routedEntry)) {
+        areaHasTruthDocumentErrors = true;
+      }
     }
     if (areaHasTruthDocumentErrors) {
       const matchingArea = areaCoverage.find(
@@ -3056,6 +3826,7 @@ var checkAreas = async (rootDir, config) => {
   return {
     diagnostics,
     truthDocumentPaths,
+    truthDocumentEntries: [...truthDocumentEntryMap.values()],
     routePrecision: {
       leafAreaCount: routing.areas.length,
       broadAreaCount
@@ -3067,36 +3838,97 @@ var checkAreas = async (rootDir, config) => {
 // src/checks/decisions.ts
 import fs14 from "fs/promises";
 import micromatch4 from "micromatch";
-var REQUIRED_DECISION_HEADINGS = ["Product Decisions", "Rationale"];
+var REQUIRED_DECISION_HEADINGS = ["Scope", "Product Decisions", "Rationale"];
+var isTruthDocumentKind3 = (value) => {
+  return TRUTH_DOCUMENT_KINDS.includes(value);
+};
 var escapeRegExp2 = (value) => {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 };
 var hasHeading = (source, heading) => {
   return new RegExp(`^#{2,3}\\s+${escapeRegExp2(heading)}\\s*$`, "mu").test(source);
 };
+var kindSpecificHeadingMessages = (source, kind) => {
+  if (kind === null) {
+    return [];
+  }
+  if (kind === "behavior") {
+    return hasHeading(source, "Current Behavior") ? [] : ["Current Behavior"];
+  }
+  if (kind === "contract") {
+    const missingMessages = [];
+    if (!hasHeading(source, "Contract Surface")) {
+      missingMessages.push("Contract Surface");
+    }
+    if (!hasHeading(source, "Inputs") && !hasHeading(source, "Outputs") && !hasHeading(source, "Compatibility Rules")) {
+      missingMessages.push("one of Inputs, Outputs, or Compatibility Rules");
+    }
+    return missingMessages;
+  }
+  if (kind === "architecture") {
+    return hasHeading(source, "Boundaries") || hasHeading(source, "Components") ? [] : ["Boundaries or Components"];
+  }
+  if (kind === "workflow") {
+    const missingMessages = [];
+    if (!hasHeading(source, "Triggers")) {
+      missingMessages.push("Triggers");
+    }
+    if (!hasHeading(source, "Execution Model")) {
+      missingMessages.push("Execution Model");
+    }
+    return missingMessages;
+  }
+  if (kind === "operations") {
+    return hasHeading(source, "Runtime Topology") || hasHeading(source, "Configuration") ? [] : ["Runtime Topology or Configuration"];
+  }
+  if (kind === "test-behavior") {
+    const missingMessages = [];
+    if (!hasHeading(source, "Execution Model")) {
+      missingMessages.push("Execution Model");
+    }
+    if (!hasHeading(source, "Fixtures And Data Model") && !hasHeading(source, "Assertions And Invariants")) {
+      missingMessages.push("Fixtures And Data Model or Assertions And Invariants");
+    }
+    return missingMessages;
+  }
+  return [];
+};
 var decisionTruthGlobs = (config) => {
   return [
     config.docs.roots.architecture,
-    config.docs.roots.features ?? config.docs.roots.features_current,
+    resolveTruthDocsRoot(config),
     config.docs.roots.api
   ].filter((root) => Boolean(root)).map((root) => `${root}/**/*.md`);
 };
 var isDecisionTruthCandidate = (config, filePath) => {
   return !filePath.endsWith("/README.md") && micromatch4.isMatch(filePath, decisionTruthGlobs(config));
 };
-var checkDecisionSections = async (rootDir, config, markdownPaths) => {
+var checkDecisionSections = async (rootDir, config, markdownPaths, truthDocumentEntries = []) => {
   const diagnostics = [];
-  const candidatePaths = [...new Set(markdownPaths)].filter((filePath) => isDecisionTruthCandidate(config, filePath)).sort();
+  const truthDocumentMap = new Map(
+    truthDocumentEntries.map((entry) => [entry.path, entry])
+  );
+  const candidatePaths = [...new Set(markdownPaths)].filter(
+    (filePath) => truthDocumentMap.has(filePath) || isDecisionTruthCandidate(config, filePath)
+  ).sort();
   for (const filePath of candidatePaths) {
     const source = await fs14.readFile(resolveRepoPath(rootDir, filePath), "utf8");
-    const missingHeadings = REQUIRED_DECISION_HEADINGS.filter((heading) => !hasHeading(source, heading));
+    const document = parseMarkdownDocument(source);
+    const routedTruthDocument = truthDocumentMap.get(filePath);
+    const frontmatterTruthKind = typeof document.frontmatter.truth_kind === "string" ? document.frontmatter.truth_kind : null;
+    const routedTruthKind = routedTruthDocument?.kindSource === "defaulted" ? null : routedTruthDocument?.kind;
+    const truthKind = routedTruthKind ?? (frontmatterTruthKind && isTruthDocumentKind3(frontmatterTruthKind) ? frontmatterTruthKind : inferTruthDocumentKindFromPath(filePath));
+    const missingHeadings = REQUIRED_DECISION_HEADINGS.filter(
+      (heading) => !hasHeading(source, heading)
+    );
+    missingHeadings.push(...kindSpecificHeadingMessages(source, truthKind));
     if (missingHeadings.length === 0) {
       continue;
     }
     diagnostics.push({
       category: "doc-structure",
       severity: "review",
-      message: `Canonical truth doc ${filePath} should include active ${missingHeadings.join(" and ")} section(s). Decisions should live beside current behavior, not in timestamped planning logs.`,
+      message: `Canonical truth doc ${filePath} should include ${missingHeadings.join(" and ")} section(s). Decisions should live beside current behavior, not in timestamped planning logs.`,
       file: filePath
     });
   }
@@ -3105,252 +3937,984 @@ var checkDecisionSections = async (rootDir, config, markdownPaths) => {
 
 // src/checks/generated-surfaces.ts
 import fs15 from "fs/promises";
-
-// src/templates/generated-surfaces.ts
-var workflowSkillFiles2 = (basePath, config) => {
-  const files = [
-    {
-      path: `${basePath}/truthmark-structure/SKILL.md`,
-      content: renderTruthmarkStructureLocalSkill(config)
-    },
-    {
-      path: `${basePath}/truthmark-document/SKILL.md`,
-      content: renderTruthmarkDocumentLocalSkill(config)
-    },
-    {
-      path: `${basePath}/truthmark-sync/SKILL.md`,
-      content: renderTruthmarkSyncLocalSkill(config)
-    },
-    {
-      path: `${basePath}/truthmark-check/SKILL.md`,
-      content: renderTruthmarkCheckLocalSkill(config)
+var readOptionalFile = async (rootDir, filePath) => {
+  try {
+    return await fs15.readFile(resolveRepoPath(rootDir, filePath), "utf8");
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return null;
     }
-  ];
-  if (config.realization.enabled) {
-    files.push({
-      path: `${basePath}/truthmark-realize/SKILL.md`,
-      content: renderTruthmarkRealizeLocalSkill()
-    });
+    throw error;
   }
-  return files;
 };
-var codexFiles2 = (config) => {
-  const files = [
-    {
-      path: TRUTHMARK_STRUCTURE_SKILL_PATH,
-      content: renderTruthmarkStructureSkill(config)
-    },
-    {
-      path: TRUTHMARK_STRUCTURE_SKILL_METADATA_PATH,
-      content: renderTruthmarkStructureSkillMetadata()
-    },
-    {
-      path: TRUTHMARK_DOCUMENT_SKILL_PATH,
-      content: renderTruthmarkDocumentSkill(config)
-    },
-    {
-      path: TRUTHMARK_DOCUMENT_SKILL_METADATA_PATH,
-      content: renderTruthmarkDocumentSkillMetadata()
-    },
-    {
-      path: TRUTHMARK_SYNC_SKILL_PATH,
-      content: renderTruthmarkSyncSkill(config)
-    },
-    {
-      path: TRUTHMARK_SYNC_SKILL_METADATA_PATH,
-      content: renderTruthmarkSyncSkillMetadata()
-    },
-    {
-      path: TRUTHMARK_CHECK_SKILL_PATH,
-      content: renderTruthmarkCheckSkill(config)
-    },
-    {
-      path: TRUTHMARK_CHECK_SKILL_METADATA_PATH,
-      content: renderTruthmarkCheckSkillMetadata()
-    }
+var extractManagedBlock = (content) => {
+  const startIndex = content.indexOf(TRUTHMARK_BLOCK_START);
+  const endIndex = content.indexOf(TRUTHMARK_BLOCK_END);
+  if (startIndex === -1 || endIndex === -1 || endIndex < startIndex) {
+    return null;
+  }
+  return content.slice(startIndex, endIndex + TRUTHMARK_BLOCK_END.length);
+};
+var normalizeGeneratedSurfaceContent = (content) => {
+  if (content === null) {
+    return null;
+  }
+  return content.replace(/\r\n/g, "\n").replace(/\n$/u, "");
+};
+var versionMarkers = (content) => {
+  const markers = [];
+  const patterns = [
+    /truthmark-version:\s*([^\s]+)/gu,
+    /Generated by Truthmark\s+([^\s.]+(?:\.[^\s.]+){1,2})/gu,
+    /^version:\s*"(\d+\.\d+\.\d+)"\s*$/gmu
   ];
-  if (config.realization.enabled) {
-    files.push(
-      {
-        path: TRUTHMARK_REALIZE_SKILL_PATH,
-        content: renderTruthmarkRealizeSkill()
-      },
-      {
-        path: TRUTHMARK_REALIZE_SKILL_METADATA_PATH,
-        content: renderTruthmarkRealizeSkillMetadata()
+  for (const pattern of patterns) {
+    for (const match of content.matchAll(pattern)) {
+      if (match[1]) {
+        markers.push(match[1]);
       }
+    }
+  }
+  return markers;
+};
+var checkGeneratedSurfaces = async (rootDir, config) => {
+  const diagnostics = [];
+  for (const surface of renderGeneratedSurfaces(config)) {
+    const content = await readOptionalFile(rootDir, surface.path);
+    if (content === null) {
+      diagnostics.push({
+        category: "generated-surface",
+        severity: "review",
+        message: `Generated surface ${surface.path} is missing; rerun truthmark init.`,
+        file: surface.path
+      });
+      continue;
+    }
+    const comparableContent = normalizeGeneratedSurfaceContent(
+      surface.managedBlock ? extractManagedBlock(content) : content
     );
+    const expectedContent = normalizeGeneratedSurfaceContent(surface.content);
+    if (comparableContent !== expectedContent) {
+      diagnostics.push({
+        category: "generated-surface",
+        severity: "review",
+        message: `Generated surface ${surface.path} is stale; rerun truthmark init.`,
+        file: surface.path
+      });
+    }
+    const versionContent = surface.managedBlock ? comparableContent ?? "" : content;
+    const mismatchedVersions = versionMarkers(versionContent).filter(
+      (version) => version !== TRUTHMARK_VERSION
+    );
+    if (mismatchedVersions.length > 0) {
+      diagnostics.push({
+        category: "generated-surface",
+        severity: "review",
+        message: `Generated surface ${surface.path} has Truthmark version ${mismatchedVersions[0]} but current version is ${TRUTHMARK_VERSION}; rerun truthmark init.`,
+        file: surface.path
+      });
+    }
   }
-  return files;
+  return diagnostics;
 };
-var copilotFiles2 = (config, block) => {
-  const files = [
-    ...instructionBlockFiles2([".github/copilot-instructions.md"], block),
-    {
-      path: TRUTHMARK_COPILOT_STRUCTURE_PROMPT_PATH,
-      content: renderTruthmarkCopilotStructurePrompt(config)
-    },
-    {
-      path: TRUTHMARK_COPILOT_DOCUMENT_PROMPT_PATH,
-      content: renderTruthmarkCopilotDocumentPrompt(config)
-    },
-    {
-      path: TRUTHMARK_COPILOT_SYNC_PROMPT_PATH,
-      content: renderTruthmarkCopilotSyncPrompt(config)
-    },
+
+// src/impact/build.ts
+import path9 from "path";
+import micromatch6 from "micromatch";
+
+// src/repo-index/build.ts
+import fs18 from "fs/promises";
+import path7 from "path";
+
+// src/repo-index/file-tree.ts
+import fs16 from "fs/promises";
+import path5 from "path";
+import { execa as execa2 } from "execa";
+import fg6 from "fast-glob";
+import matter2 from "gray-matter";
+import micromatch5 from "micromatch";
+var languageByExtension = /* @__PURE__ */ new Map([
+  [".ts", "typescript"],
+  [".tsx", "typescript"],
+  [".js", "javascript"],
+  [".jsx", "javascript"],
+  [".mjs", "javascript"],
+  [".cjs", "javascript"],
+  [".md", "markdown"],
+  [".json", "json"],
+  [".yml", "yaml"],
+  [".yaml", "yaml"],
+  [".toml", "toml"]
+]);
+var sourceExtensions = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
+var isJavaScriptLikePath = (filePath) => {
+  return sourceExtensions.has(path5.posix.extname(filePath));
+};
+var isTestPath = (filePath) => {
+  return filePath.startsWith("tests/") || filePath.includes("/__tests__/") || /(?:^|[./-])(test|spec)\.[cm]?[jt]sx?$/u.test(path5.posix.basename(filePath));
+};
+var fileKind = (filePath, ignore) => {
+  const classification = classifyPath(filePath, ignore);
+  if (classification === "derived") {
+    return "generated";
+  }
+  if (isTestPath(filePath)) {
+    return "test";
+  }
+  if (filePath.endsWith(".md")) {
+    return "doc";
+  }
+  if (classification === "functional-code") {
+    return "source";
+  }
+  if (classification === "markdown") {
+    return "doc";
+  }
+  if (classification === "config") {
+    return "config";
+  }
+  return "other";
+};
+var targetHintsForTest = (filePath) => {
+  const hints = /* @__PURE__ */ new Set();
+  const basename = path5.posix.basename(filePath).replace(/\.(test|spec)\.[cm]?[jt]sx?$/u, "");
+  if (basename.length > 0) {
+    hints.add(basename);
+  }
+  const segments = filePath.split("/");
+  const testRootIndex = segments.findIndex((segment) => segment === "tests" || segment === "__tests__");
+  if (testRootIndex >= 0) {
+    for (const segment of segments.slice(testRootIndex + 1, -1)) {
+      if (segment.length > 0) {
+        hints.add(segment);
+      }
+    }
+  }
+  return [...hints].sort();
+};
+var defaultIgnore = [".git/**", "node_modules/**", "dist/**", "build/**"];
+var normalizePath2 = (filePath) => filePath.replaceAll("\\", "/").replace(/^\.\/+/u, "");
+var gitDiscoverableFiles = async (rootDir) => {
+  const result = await execa2(
+    "git",
+    ["ls-files", "--cached", "--others", "--exclude-standard", "--deduplicate"],
     {
-      path: TRUTHMARK_COPILOT_CHECK_PROMPT_PATH,
-      content: renderTruthmarkCopilotCheckPrompt(config)
+      cwd: rootDir,
+      reject: false
     }
-  ];
-  if (config.realization.enabled) {
+  );
+  if ((result.exitCode ?? 1) !== 0) {
+    return null;
+  }
+  return result.stdout.split("\n").map((line) => normalizePath2(line.trim())).filter((line) => line.length > 0);
+};
+var isIgnoredPath = (filePath, ignore) => {
+  return micromatch5.isMatch(filePath, [...defaultIgnore, ...ignore]);
+};
+var discoverRepoFiles = async (rootDir, ignore) => {
+  const discoveredFiles = await gitDiscoverableFiles(rootDir) ?? await fg6(["**/*"], {
+    cwd: rootDir,
+    onlyFiles: true,
+    dot: true,
+    ignore: [...defaultIgnore, ...ignore],
+    followSymbolicLinks: false
+  });
+  const files = [];
+  const docs = [];
+  const tests = [];
+  for (const filePath of discoveredFiles.filter((entry) => !isIgnoredPath(entry, ignore)).sort()) {
+    const extension = path5.posix.extname(filePath);
+    const kind = fileKind(filePath, ignore);
     files.push({
-      path: TRUTHMARK_COPILOT_REALIZE_PROMPT_PATH,
-      content: renderTruthmarkCopilotRealizePrompt()
+      path: filePath,
+      kind,
+      language: languageByExtension.get(extension) ?? null
     });
+    if (kind === "test") {
+      tests.push({
+        path: filePath,
+        targetHints: targetHintsForTest(filePath)
+      });
+    }
+    if (kind === "doc") {
+      const source = await fs16.readFile(path5.join(rootDir, filePath), "utf8");
+      const parsed = matter2(source);
+      const markdown = parseMarkdownDocument(parsed.content);
+      const title = markdown.headings.find((heading) => heading.depth === 1)?.text ?? null;
+      const sourceOfTruth = Array.isArray(parsed.data.source_of_truth) ? parsed.data.source_of_truth.filter((entry) => typeof entry === "string") : [];
+      docs.push({
+        path: filePath,
+        title,
+        docType: typeof parsed.data.doc_type === "string" ? parsed.data.doc_type : null,
+        truthKind: typeof parsed.data.truth_kind === "string" ? parsed.data.truth_kind : null,
+        sourceOfTruth: sourceOfTruth.sort()
+      });
+    }
   }
-  return files;
+  return {
+    files: files.sort((left, right) => left.path.localeCompare(right.path)),
+    docs: docs.sort((left, right) => left.path.localeCompare(right.path)),
+    tests: tests.sort((left, right) => left.path.localeCompare(right.path))
+  };
 };
-var instructionBlockFiles2 = (paths, block) => {
-  return paths.map((path4) => ({
-    path: path4,
-    content: block,
-    managedBlock: true
-  }));
+
+// src/repo-index/package-metadata.ts
+import fs17 from "fs/promises";
+import path6 from "path";
+import fg7 from "fast-glob";
+var packageManagerFor = async (rootDir, packageDir) => {
+  const lockfiles = [
+    ["package-lock.json", "npm"],
+    ["pnpm-lock.yaml", "pnpm"],
+    ["yarn.lock", "yarn"],
+    ["bun.lockb", "bun"],
+    ["bun.lock", "bun"]
+  ];
+  for (const [lockfile, manager] of lockfiles) {
+    try {
+      await fs17.access(path6.join(rootDir, packageDir, lockfile));
+      return manager;
+    } catch {
+      continue;
+    }
+  }
+  return "npm";
 };
-var filesForPlatform2 = (platform, config, block) => {
-  switch (platform) {
-    case "codex":
-      return codexFiles2(config);
-    case "opencode":
-      return workflowSkillFiles2(".opencode/skills", config);
-    case "claude-code":
-      return [
-        ...instructionBlockFiles2(["CLAUDE.md"], block),
-        ...workflowSkillFiles2(".claude/skills", config)
-      ];
-    case "github-copilot":
-      return copilotFiles2(config, block);
-    case "gemini-cli":
-      return [
-        ...instructionBlockFiles2(["GEMINI.md"], block),
-        {
-          path: TRUTHMARK_GEMINI_STRUCTURE_COMMAND_PATH,
-          content: renderTruthmarkGeminiStructureCommand(config)
-        },
-        {
-          path: TRUTHMARK_GEMINI_DOCUMENT_COMMAND_PATH,
-          content: renderTruthmarkGeminiDocumentCommand(config)
-        },
-        {
-          path: TRUTHMARK_GEMINI_SYNC_COMMAND_PATH,
-          content: renderTruthmarkGeminiSyncCommand(config)
-        },
-        {
-          path: TRUTHMARK_GEMINI_CHECK_COMMAND_PATH,
-          content: renderTruthmarkGeminiCheckCommand(config)
-        },
-        ...config.realization.enabled ? [
-          {
-            path: TRUTHMARK_GEMINI_REALIZE_COMMAND_PATH,
-            content: renderTruthmarkGeminiRealizeCommand()
-          }
-        ] : []
-      ];
+var discoverPackageMetadata = async (rootDir) => {
+  const packageFiles = await fg7(["package.json", "*/package.json", "packages/*/package.json"], {
+    cwd: rootDir,
+    onlyFiles: true,
+    ignore: ["node_modules/**", "dist/**", "build/**"],
+    followSymbolicLinks: false
+  });
+  const packages = [];
+  for (const packageFile of packageFiles.sort()) {
+    const packageDir = path6.posix.dirname(packageFile) === "." ? "" : path6.posix.dirname(packageFile);
+    const raw = JSON.parse(await fs17.readFile(path6.join(rootDir, packageFile), "utf8"));
+    const scripts = raw.scripts && typeof raw.scripts === "object" ? Object.keys(raw.scripts).sort() : [];
+    packages.push({
+      path: packageFile,
+      manager: await packageManagerFor(rootDir, packageDir),
+      name: typeof raw.name === "string" ? raw.name : null,
+      version: typeof raw.version === "string" ? raw.version : null,
+      private: typeof raw.private === "boolean" ? raw.private : null,
+      scripts
+    });
   }
+  return packages;
 };
-var renderGeneratedSurfaces = (config, block = renderAgentsBlock(config)) => {
-  const files = [
-    ...instructionBlockFiles2(config.instructionTargets, block),
-    ...config.platforms.flatMap((platform) => filesForPlatform2(platform, config, block))
-  ];
-  return Array.from(new Map(files.map((file) => [file.path, file])).values()).sort(
-    (left, right) => left.path.localeCompare(right.path)
+
+// src/repo-index/route-map.ts
+var buildRouteMap = async (rootDir) => {
+  const loadResult = await loadConfig(rootDir);
+  if (!loadResult.config) {
+    return {
+      schemaVersion: "route-map/v0",
+      routes: [],
+      diagnostics: loadResult.diagnostics
+    };
+  }
+  const routing = await resolveAreaRouting(rootDir, {
+    rootIndex: loadResult.config.docs.routing.rootIndex,
+    areaFilesRoot: loadResult.config.docs.routing.areaFilesRoot,
+    truthDocsRoot: resolveTruthDocsRoot(loadResult.config)
+  });
+  return {
+    schemaVersion: "route-map/v0",
+    routes: routing.areas.map((area) => ({
+      id: area.id,
+      name: area.name,
+      key: area.key,
+      sourcePath: area.sourcePath,
+      parentName: area.parentName,
+      codeSurface: [...area.codeSurface].sort(),
+      truthDocs: [...area.truthDocuments].sort(),
+      updateTruthWhen: [...area.updateTruthWhen]
+    })).sort((left, right) => left.key.localeCompare(right.key)),
+    diagnostics: routing.diagnostics
+  };
+};
+
+// src/repo-index/typescript-symbols.ts
+import ts from "typescript";
+var sortStrings = (values) => [...new Set(values)].sort();
+var hasExportModifier = (node) => {
+  return Boolean(
+    ts.canHaveModifiers(node) && ts.getModifiers(node)?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword)
   );
 };
+var declarationName = (node) => {
+  if (!node.name || !ts.isIdentifier(node.name)) {
+    return null;
+  }
+  return node.name.text;
+};
+var addExport = (exports, publicSymbols, path12, name, kind) => {
+  if (!name) {
+    return;
+  }
+  const entry = { path: path12, name, kind };
+  exports.push(entry);
+  publicSymbols.push(entry);
+};
+var analyzeTypeScriptSource = (path12, source) => {
+  const sourceFile = ts.createSourceFile(path12, source, ts.ScriptTarget.Latest, true);
+  const imports = [];
+  const exports = [];
+  const publicSymbols = [];
+  for (const statement of sourceFile.statements) {
+    if (ts.isImportDeclaration(statement) && ts.isStringLiteral(statement.moduleSpecifier)) {
+      const imported = [];
+      const clause = statement.importClause;
+      if (clause?.name) {
+        imported.push("default");
+      }
+      if (clause?.namedBindings && ts.isNamespaceImport(clause.namedBindings)) {
+        imported.push("*");
+      }
+      if (clause?.namedBindings && ts.isNamedImports(clause.namedBindings)) {
+        for (const element of clause.namedBindings.elements) {
+          imported.push(element.propertyName?.text ?? element.name.text);
+        }
+      }
+      imports.push({
+        from: path12,
+        specifier: statement.moduleSpecifier.text,
+        imported: sortStrings(imported)
+      });
+      continue;
+    }
+    if (ts.isExportDeclaration(statement)) {
+      if (statement.exportClause && ts.isNamedExports(statement.exportClause)) {
+        for (const element of statement.exportClause.elements) {
+          addExport(exports, publicSymbols, path12, element.name.text, "re-export");
+        }
+      }
+      continue;
+    }
+    if (ts.isFunctionDeclaration(statement) && hasExportModifier(statement)) {
+      addExport(exports, publicSymbols, path12, declarationName(statement), "function");
+      continue;
+    }
+    if (ts.isClassDeclaration(statement) && hasExportModifier(statement)) {
+      addExport(exports, publicSymbols, path12, declarationName(statement), "class");
+      continue;
+    }
+    if (ts.isInterfaceDeclaration(statement) && hasExportModifier(statement)) {
+      addExport(exports, publicSymbols, path12, declarationName(statement), "interface");
+      continue;
+    }
+    if (ts.isTypeAliasDeclaration(statement) && hasExportModifier(statement)) {
+      addExport(exports, publicSymbols, path12, declarationName(statement), "type");
+      continue;
+    }
+    if (ts.isEnumDeclaration(statement) && hasExportModifier(statement)) {
+      addExport(exports, publicSymbols, path12, declarationName(statement), "enum");
+      continue;
+    }
+    if (ts.isVariableStatement(statement) && hasExportModifier(statement)) {
+      for (const declaration of statement.declarationList.declarations) {
+        addExport(exports, publicSymbols, path12, declarationName(declaration), "const");
+      }
+    }
+  }
+  return {
+    imports: imports.sort((left, right) => left.specifier.localeCompare(right.specifier)),
+    exports: exports.sort((left, right) => left.name.localeCompare(right.name)),
+    publicSymbols: publicSymbols.sort((left, right) => left.name.localeCompare(right.name))
+  };
+};
 
-// src/checks/generated-surfaces.ts
-var readOptionalFile = async (rootDir, filePath) => {
+// src/repo-index/build.ts
+var buildRepoIndex = async (cwd) => {
+  const repository = await getGitRepository(cwd);
+  const rootDir = repository.worktreePath;
+  const loadResult = await loadConfig(rootDir);
+  const ignore = loadResult.config?.ignore ?? [];
+  const diagnostics = [...loadResult.diagnostics];
+  const [packages, fileTree, routeMap] = await Promise.all([
+    discoverPackageMetadata(rootDir),
+    discoverRepoFiles(rootDir, ignore),
+    buildRouteMap(rootDir)
+  ]);
+  const imports = [];
+  const exports = [];
+  const publicSymbols = [];
+  diagnostics.push(...routeMap.diagnostics);
+  for (const file of fileTree.files) {
+    if (!isJavaScriptLikePath(file.path)) {
+      continue;
+    }
+    const source = await fs18.readFile(path7.join(rootDir, file.path), "utf8");
+    const analysis = analyzeTypeScriptSource(file.path, source);
+    imports.push(...analysis.imports);
+    exports.push(...analysis.exports);
+    publicSymbols.push(...analysis.publicSymbols);
+  }
+  return {
+    schemaVersion: "repo-index/v0",
+    repository: {
+      root: rootDir,
+      branchName: repository.branchName,
+      headSha: repository.headSha
+    },
+    packages,
+    files: fileTree.files,
+    docs: fileTree.docs,
+    tests: fileTree.tests,
+    imports: imports.sort((left, right) => `${left.from}:${left.specifier}`.localeCompare(`${right.from}:${right.specifier}`)),
+    exports: exports.sort((left, right) => `${left.path}:${left.name}`.localeCompare(`${right.path}:${right.name}`)),
+    publicSymbols: publicSymbols.sort(
+      (left, right) => `${left.path}:${left.name}`.localeCompare(`${right.path}:${right.name}`)
+    ),
+    routeMap,
+    diagnostics
+  };
+};
+
+// src/impact/git-diff.ts
+import { execa as execa4 } from "execa";
+
+// src/git/changes.ts
+import fs19 from "fs/promises";
+import path8 from "path";
+import { execa as execa3 } from "execa";
+var normalizePath3 = (filePath) => {
+  return filePath.replaceAll("\\", "/").replace(/^\.\//u, "");
+};
+var listChangedPaths = async (cwd, args) => {
+  const result = await execa3("git", args, { cwd });
+  return result.stdout.split("\n").map((line) => line.trim()).filter((line) => line.length > 0).map((line) => normalizePath3(line));
+};
+var pathExists4 = async (filePath) => {
   try {
-    return await fs15.readFile(resolveRepoPath(rootDir, filePath), "utf8");
-  } catch (error) {
-    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
-      return null;
+    await fs19.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var getOrCreateChange = (changesByPath, filePath) => {
+  const existingChange = changesByPath.get(filePath);
+  if (existingChange) {
+    return existingChange;
+  }
+  const nextChange = {
+    path: filePath,
+    staged: false,
+    unstaged: false,
+    untracked: false,
+    deleted: false
+  };
+  changesByPath.set(filePath, nextChange);
+  return nextChange;
+};
+var getUncommittedChanges = async (cwd) => {
+  const repository = await getGitRepository(cwd);
+  const rootDir = repository.worktreePath;
+  const [stagedPaths, unstagedPaths, untrackedPaths, stagedDeletedPaths, unstagedDeletedPaths] = await Promise.all([
+    listChangedPaths(rootDir, ["diff", "--name-only", "--cached", "--diff-filter=ACDMRTUXB"]),
+    listChangedPaths(rootDir, ["diff", "--name-only", "--diff-filter=ACDMRTUXB"]),
+    listChangedPaths(rootDir, ["ls-files", "--others", "--exclude-standard"]),
+    listChangedPaths(rootDir, ["diff", "--name-only", "--cached", "--diff-filter=D"]),
+    listChangedPaths(rootDir, ["diff", "--name-only", "--diff-filter=D"])
+  ]);
+  const changesByPath = /* @__PURE__ */ new Map();
+  for (const stagedPath of stagedPaths) {
+    getOrCreateChange(changesByPath, stagedPath).staged = true;
+  }
+  for (const unstagedPath of unstagedPaths) {
+    getOrCreateChange(changesByPath, unstagedPath).unstaged = true;
+  }
+  for (const untrackedPath of untrackedPaths) {
+    getOrCreateChange(changesByPath, untrackedPath).untracked = true;
+  }
+  const deletedPathCandidates = /* @__PURE__ */ new Set([...stagedDeletedPaths, ...unstagedDeletedPaths]);
+  for (const deletedPath of deletedPathCandidates) {
+    const change = getOrCreateChange(changesByPath, deletedPath);
+    change.deleted = !await pathExists4(path8.join(rootDir, deletedPath));
+  }
+  return Array.from(changesByPath.values()).sort((left, right) => {
+    return left.path.localeCompare(right.path);
+  });
+};
+
+// src/impact/git-diff.ts
+var normalizePath4 = (filePath) => filePath.replaceAll("\\", "/").replace(/^\.\//u, "");
+var statusForCode = (code) => {
+  if (code.startsWith("A")) return "added";
+  if (code.startsWith("D")) return "deleted";
+  if (code.startsWith("R")) return "renamed";
+  if (code.startsWith("C")) return "copied";
+  if (code.startsWith("T")) return "type-changed";
+  return "modified";
+};
+var mergeFile = (files, next) => {
+  const existing = files.get(next.path);
+  if (!existing) {
+    files.set(next.path, next);
+    return;
+  }
+  files.set(next.path, {
+    ...existing,
+    status: existing.status === "deleted" || existing.status === "renamed" ? existing.status : next.status,
+    previousPath: existing.previousPath ?? next.previousPath,
+    staged: existing.staged || next.staged,
+    unstaged: existing.unstaged || next.unstaged,
+    untracked: existing.untracked || next.untracked,
+    deleted: existing.deleted || next.deleted
+  });
+};
+var getChangedFiles = async (cwd, base) => {
+  const repository = await getGitRepository(cwd);
+  const files = /* @__PURE__ */ new Map();
+  const diagnostics = [];
+  let diff = await execa4("git", ["diff", "--name-status", "--find-renames", `${base}...HEAD`], {
+    cwd: repository.worktreePath,
+    reject: false
+  });
+  if ((diff.exitCode ?? 1) !== 0) {
+    diff = await execa4("git", ["diff", "--name-status", "--find-renames", base, "HEAD"], {
+      cwd: repository.worktreePath,
+      reject: false
+    });
+  }
+  if ((diff.exitCode ?? 1) === 0) {
+    for (const line of diff.stdout.split("\n").filter(Boolean)) {
+      const [rawStatus, rawPath, rawNewPath] = line.split("	");
+      const filePath = normalizePath4(rawNewPath ?? rawPath);
+      const previousPath = rawNewPath && rawStatus.startsWith("R") ? normalizePath4(rawPath) : void 0;
+      mergeFile(files, {
+        path: filePath,
+        previousPath,
+        status: statusForCode(rawStatus),
+        staged: false,
+        unstaged: false,
+        untracked: false,
+        deleted: rawStatus.startsWith("D")
+      });
     }
-    throw error;
+  } else {
+    diagnostics.push({
+      category: "impact",
+      severity: "error",
+      message: `Unable to compare base ref ${base} to HEAD.`
+    });
+  }
+  for (const change of await getUncommittedChanges(repository.worktreePath)) {
+    mergeFile(files, {
+      path: change.path,
+      status: change.untracked ? "added" : change.deleted ? "deleted" : "modified",
+      staged: change.staged,
+      unstaged: change.unstaged,
+      untracked: change.untracked,
+      deleted: change.deleted
+    });
   }
+  return {
+    files: [...files.values()].sort((left, right) => left.path.localeCompare(right.path)),
+    diagnostics
+  };
+};
+var readBaseFile = async (cwd, base, filePath) => {
+  const repository = await getGitRepository(cwd);
+  const result = await execa4("git", ["show", `${base}:${filePath}`], {
+    cwd: repository.worktreePath,
+    reject: false
+  });
+  return (result.exitCode ?? 1) === 0 ? result.stdout : null;
+};
+
+// src/impact/build.ts
+var uniqueSorted = (values) => [...new Set(values)].sort();
+var routeMatchesFile = (route, filePath) => {
+  return route.codeSurface.some((pattern) => micromatch6.isMatch(filePath, pattern));
+};
+var routeOwnsTruthDoc = (route, filePath) => {
+  return route.truthDocs.includes(filePath);
+};
+var toImpactRoute = (route) => ({
+  id: route.id,
+  name: route.name,
+  key: route.key,
+  sourcePath: route.sourcePath,
+  truthDocs: [...route.truthDocs].sort(),
+  codeSurface: [...route.codeSurface].sort()
+});
+var changedPathSet = (changedFiles) => {
+  return new Set(
+    changedFiles.flatMap((file) => [file.path, ...file.previousPath ? [file.previousPath] : []])
+  );
 };
-var extractManagedBlock = (content) => {
-  const startIndex = content.indexOf(TRUTHMARK_BLOCK_START);
-  const endIndex = content.indexOf(TRUTHMARK_BLOCK_END);
-  if (startIndex === -1 || endIndex === -1 || endIndex < startIndex) {
+var changedFilePaths = (changedFile) => {
+  return [changedFile.path, ...changedFile.previousPath ? [changedFile.previousPath] : []];
+};
+var resolveImportPath = (importEdge) => {
+  if (!importEdge.specifier.startsWith(".")) {
     return null;
   }
-  return content.slice(startIndex, endIndex + TRUTHMARK_BLOCK_END.length);
+  const basePath = path9.posix.normalize(path9.posix.join(path9.posix.dirname(importEdge.from), importEdge.specifier));
+  const withoutExtension = basePath.replace(/\.[cm]?[jt]sx?$/u, "");
+  return withoutExtension;
 };
-var normalizeGeneratedSurfaceContent = (content) => {
-  if (content === null) {
-    return null;
+var importTargetsChangedFile = (importEdge, changedPath) => {
+  const resolved = resolveImportPath(importEdge);
+  if (!resolved) {
+    return false;
   }
-  return content.replace(/\r\n/g, "\n").replace(/\n$/u, "");
+  return changedPath.replace(/\.[cm]?[jt]sx?$/u, "") === resolved;
 };
-var versionMarkers = (content) => {
-  const markers = [];
-  const patterns = [
-    /truthmark-version:\s*([^\s]+)/gu,
-    /Generated by Truthmark\s+([^\s.]+(?:\.[^\s.]+){1,2})/gu,
-    /^version:\s*"(\d+\.\d+\.\d+)"\s*$/gmu
-  ];
-  for (const pattern of patterns) {
-    for (const match of content.matchAll(pattern)) {
-      if (match[1]) {
-        markers.push(match[1]);
-      }
+var pathSegments = (filePath) => filePath.split("/").filter(Boolean);
+var testHintMatchesChangedFile = (hints, changedPath) => {
+  const changedBaseName = path9.posix.basename(changedPath);
+  const changedSegments = pathSegments(changedPath);
+  return hints.some((hint) => changedBaseName.startsWith(hint) || changedSegments.includes(hint));
+};
+var changedSymbolsFor = async (cwd, base, basePath, currentPath, currentExports) => {
+  if (!isJavaScriptLikePath(basePath) && !isJavaScriptLikePath(currentPath)) {
+    return [];
+  }
+  const baseSource = await readBaseFile(cwd, base, basePath);
+  const baseExports = baseSource ? analyzeTypeScriptSource(basePath, baseSource).exports : [];
+  const currentByName = new Map(currentExports.map((entry) => [entry.name, entry]));
+  const baseByName = new Map(baseExports.map((entry) => [entry.name, entry]));
+  const changes = [];
+  if (basePath !== currentPath) {
+    for (const entry of currentExports) {
+      changes.push({ path: currentPath, name: entry.name, kind: entry.kind, change: "added" });
     }
+    for (const entry of baseExports) {
+      changes.push({ path: basePath, name: entry.name, kind: entry.kind, change: "removed" });
+    }
+    return changes;
   }
-  return markers;
+  for (const [name, entry] of currentByName) {
+    if (!baseByName.has(name)) {
+      changes.push({ path: currentPath, name, kind: entry.kind, change: "added" });
+    }
+  }
+  for (const [name, entry] of baseByName) {
+    if (!currentByName.has(name)) {
+      changes.push({ path: basePath, name, kind: entry.kind, change: "removed" });
+    }
+  }
+  return changes;
 };
-var checkGeneratedSurfaces = async (rootDir, config) => {
-  const diagnostics = [];
-  for (const surface of renderGeneratedSurfaces(config)) {
-    const content = await readOptionalFile(rootDir, surface.path);
-    if (content === null) {
+var buildImpactSet = async (cwd, options) => {
+  const repository = await getGitRepository(cwd);
+  const rootDir = repository.worktreePath;
+  const [loadResult, repoIndex, changedFilesResult] = await Promise.all([
+    loadConfig(rootDir),
+    buildRepoIndex(rootDir),
+    getChangedFiles(rootDir, options.base)
+  ]);
+  const changedFiles = changedFilesResult.files;
+  const ignore = loadResult.config?.ignore ?? [];
+  const diagnostics = [...repoIndex.diagnostics, ...changedFilesResult.diagnostics];
+  const affectedRoutes = /* @__PURE__ */ new Map();
+  const affectedTruthDocs = [];
+  const affectedTests = [];
+  const changedPublicSymbols = [];
+  const knownTestPaths = new Set(repoIndex.tests.map((test) => test.path));
+  for (const changedFile of changedFiles) {
+    const routeCandidatePaths = changedFilePaths(changedFile);
+    if (routeCandidatePaths.some((filePath) => knownTestPaths.has(filePath))) {
+      affectedTests.push(changedFile.path);
+    }
+    const matchingRoutes = repoIndex.routeMap.routes.filter(
+      (route) => routeCandidatePaths.some(
+        (filePath) => routeMatchesFile(route, filePath) || routeOwnsTruthDoc(route, filePath)
+      )
+    );
+    for (const route of matchingRoutes) {
+      affectedRoutes.set(route.key, toImpactRoute(route));
+      affectedTruthDocs.push(...route.truthDocs);
+      if (route.truthDocs.length === 0) {
+        diagnostics.push({
+          category: "impact",
+          severity: "review",
+          message: `Changed file ${changedFile.path} maps to route ${route.name} but the route has no truth document.`,
+          file: changedFile.path,
+          area: route.name
+        });
+      }
+    }
+    if (matchingRoutes.length === 0 && !routeCandidatePaths.some((filePath) => knownTestPaths.has(filePath)) && routeCandidatePaths.some((filePath) => classifyPath(filePath, ignore) === "functional-code")) {
       diagnostics.push({
-        category: "generated-surface",
+        category: "impact",
         severity: "review",
-        message: `Generated surface ${surface.path} is missing; rerun truthmark init.`,
-        file: surface.path
+        message: `Changed file ${changedFile.path} is not mapped to a Truthmark route.`,
+        file: changedFile.path
       });
-      continue;
     }
-    const comparableContent = normalizeGeneratedSurfaceContent(
-      surface.managedBlock ? extractManagedBlock(content) : content
+    const currentExports = repoIndex.exports.filter((entry) => entry.path === changedFile.path);
+    changedPublicSymbols.push(
+      ...await changedSymbolsFor(
+        rootDir,
+        options.base,
+        changedFile.previousPath ?? changedFile.path,
+        changedFile.path,
+        currentExports
+      )
     );
-    const expectedContent = normalizeGeneratedSurfaceContent(surface.content);
-    if (comparableContent !== expectedContent) {
+  }
+  const uniqueAffectedTruthDocs = uniqueSorted(affectedTruthDocs);
+  const changedPaths = changedPathSet(changedFiles);
+  for (const symbol of changedPublicSymbols) {
+    if (uniqueAffectedTruthDocs.length === 0) {
       diagnostics.push({
-        category: "generated-surface",
+        category: "impact",
         severity: "review",
-        message: `Generated surface ${surface.path} is stale; rerun truthmark init.`,
-        file: surface.path
+        message: `Changed public symbol ${symbol.name} in ${symbol.path} has no affected truth document.`,
+        file: symbol.path,
+        data: {
+          symbol: symbol.name,
+          change: symbol.change
+        }
       });
+      continue;
     }
-    const versionContent = surface.managedBlock ? comparableContent ?? "" : content;
-    const mismatchedVersions = versionMarkers(versionContent).filter(
-      (version) => version !== TRUTHMARK_VERSION
-    );
-    if (mismatchedVersions.length > 0) {
+    if (!uniqueAffectedTruthDocs.some((truthDoc) => changedPaths.has(truthDoc))) {
       diagnostics.push({
-        category: "generated-surface",
+        category: "impact",
         severity: "review",
-        message: `Generated surface ${surface.path} has Truthmark version ${mismatchedVersions[0]} but current version is ${TRUTHMARK_VERSION}; rerun truthmark init.`,
-        file: surface.path
+        message: `Changed public symbol ${symbol.name} in ${symbol.path} has affected truth docs but none were changed in this impact set.`,
+        file: symbol.path,
+        data: {
+          symbol: symbol.name,
+          change: symbol.change,
+          affectedTruthDocs: uniqueAffectedTruthDocs
+        }
       });
     }
   }
+  for (const test of repoIndex.tests) {
+    const testImports = repoIndex.imports.filter((edge) => edge.from === test.path);
+    const importsChangedFile = changedFiles.some(
+      (changedFile) => changedFilePaths(changedFile).some(
+        (filePath) => testImports.some((importEdge) => importTargetsChangedFile(importEdge, filePath))
+      )
+    );
+    const hintMatchesChangedFile = changedFiles.some(
+      (changedFile) => changedFilePaths(changedFile).some(
+        (filePath) => testHintMatchesChangedFile(test.targetHints, filePath)
+      )
+    );
+    if (importsChangedFile || hintMatchesChangedFile) {
+      affectedTests.push(test.path);
+    }
+  }
+  return {
+    schemaVersion: "impact-set/v0",
+    base: options.base,
+    headSha: repository.headSha,
+    changedFiles,
+    affectedRoutes: [...affectedRoutes.values()].sort(
+      (left, right) => left.key.localeCompare(right.key)
+    ),
+    affectedTruthDocs: uniqueAffectedTruthDocs,
+    affectedTests: uniqueSorted(affectedTests),
+    changedPublicSymbols: changedPublicSymbols.sort(
+      (left, right) => `${left.path}:${left.name}:${left.change}`.localeCompare(`${right.path}:${right.name}:${right.change}`)
+    ),
+    diagnostics
+  };
+};
+
+// src/evidence/validate.ts
+import fs21 from "fs/promises";
+import fg8 from "fast-glob";
+
+// src/evidence/parse.ts
+import fs20 from "fs/promises";
+import path10 from "path";
+import matter3 from "gray-matter";
+import { parse as parse3 } from "yaml";
+var evidenceBlockPattern = /```ya?ml\s*\n([\s\S]*?)```/giu;
+var repoRootPrefixes = [".codex/", ".github/", ".truthmark/", "docs/", "src/", "tests/"];
+var normalizeReferencePath = (truthDocPath, referencePath) => {
+  const strippedPath = referencePath.split("#")[0]?.trim() ?? "";
+  const isRepoRelative = repoRootPrefixes.some((prefix) => strippedPath.startsWith(prefix));
+  if (!isRepoRelative && (strippedPath.startsWith(".") || !strippedPath.includes("/"))) {
+    return path10.posix.normalize(path10.posix.join(path10.posix.dirname(truthDocPath), strippedPath));
+  }
+  return path10.posix.normalize(strippedPath);
+};
+var toEvidenceReference = (truthDocPath, raw) => {
+  if (!raw || typeof raw !== "object" || !("path" in raw) || typeof raw.path !== "string") {
+    return null;
+  }
+  return {
+    truthDocPath,
+    path: normalizeReferencePath(truthDocPath, raw.path),
+    symbol: "symbol" in raw && typeof raw.symbol === "string" ? raw.symbol : void 0,
+    startLine: "start_line" in raw && typeof raw.start_line === "number" ? raw.start_line : void 0,
+    endLine: "end_line" in raw && typeof raw.end_line === "number" ? raw.end_line : void 0,
+    contentHash: "content_hash" in raw && typeof raw.content_hash === "string" ? raw.content_hash : void 0,
+    source: "evidence-block"
+  };
+};
+var parseEvidenceReferences = async (rootDir, truthDocPath) => {
+  const source = await fs20.readFile(path10.join(rootDir, truthDocPath), "utf8");
+  const parsed = matter3(source);
+  const references = [];
+  const sourceOfTruth = Array.isArray(parsed.data.source_of_truth) ? parsed.data.source_of_truth : [];
+  for (const entry of sourceOfTruth) {
+    if (typeof entry !== "string") {
+      continue;
+    }
+    references.push({
+      truthDocPath,
+      path: normalizeReferencePath(truthDocPath, entry),
+      source: "frontmatter"
+    });
+  }
+  for (const match of parsed.content.matchAll(evidenceBlockPattern)) {
+    const block = parse3(match[1] ?? "");
+    const rawEvidence = block && typeof block === "object" && "evidence" in block ? block.evidence : null;
+    if (!Array.isArray(rawEvidence)) {
+      continue;
+    }
+    for (const rawReference of rawEvidence) {
+      const reference = toEvidenceReference(truthDocPath, rawReference);
+      if (reference) {
+        references.push(reference);
+      }
+    }
+  }
+  return references;
+};
+
+// src/evidence/validate.ts
+var pathExists5 = async (filePath) => {
+  try {
+    await fs21.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var diagnosticFor = (reference, message) => ({
+  category: "freshness",
+  severity: "error",
+  message,
+  file: reference.truthDocPath,
+  data: {
+    reference: reference.path,
+    source: reference.source
+  }
+});
+var isGlobReference = (referencePath) => /[*?[\]{}()]/u.test(referencePath);
+var validateGlob = async (rootDir, reference) => {
+  if (reference.path.startsWith("../") || reference.path.startsWith("/")) {
+    return diagnosticFor(reference, `Referenced file pattern ${reference.path} must stay inside the repository root.`);
+  }
+  const matches = await fg8(reference.path, {
+    cwd: rootDir,
+    dot: true,
+    onlyFiles: true,
+    followSymbolicLinks: false
+  });
+  return matches.length > 0 ? null : diagnosticFor(reference, `Referenced file pattern ${reference.path} does not match any file.`);
+};
+var validateSymbol = async (rootDir, reference) => {
+  if (!reference.symbol || !isJavaScriptLikePath(reference.path)) {
+    return null;
+  }
+  const source = await fs21.readFile(resolveRepoPath(rootDir, reference.path), "utf8");
+  const analysis = analyzeTypeScriptSource(reference.path, source);
+  const hasSymbol = analysis.publicSymbols.some((symbol) => symbol.name === reference.symbol);
+  return hasSymbol ? null : diagnosticFor(reference, `Evidence symbol ${reference.symbol} was not found in ${reference.path}.`);
+};
+var validateHash = async (rootDir, reference) => {
+  if (!reference.contentHash) {
+    return null;
+  }
+  if (!reference.contentHash.startsWith("sha256:")) {
+    return diagnosticFor(reference, `Evidence hash for ${reference.path} must use sha256:.`);
+  }
+  const source = await fs21.readFile(resolveRepoPath(rootDir, reference.path), "utf8");
+  const lines = source.split("\n");
+  const startLine = reference.startLine ?? 1;
+  const endLine = reference.endLine ?? lines.length;
+  if (startLine < 1 || endLine < startLine || endLine > lines.length) {
+    return diagnosticFor(reference, `Evidence line span for ${reference.path} is outside the file.`);
+  }
+  const actualHash = `sha256:${hashText(lines.slice(startLine - 1, endLine).join("\n"))}`;
+  return actualHash === reference.contentHash ? null : diagnosticFor(reference, `Evidence hash for ${reference.path} is stale.`);
+};
+var validateLineSpan = async (rootDir, reference) => {
+  if (reference.startLine === void 0 && reference.endLine === void 0) {
+    return null;
+  }
+  const source = await fs21.readFile(resolveRepoPath(rootDir, reference.path), "utf8");
+  const lines = source.split("\n");
+  const startLine = reference.startLine ?? 1;
+  const endLine = reference.endLine ?? lines.length;
+  return startLine < 1 || endLine < startLine || endLine > lines.length ? diagnosticFor(reference, `Evidence line span for ${reference.path} is outside the file.`) : null;
+};
+var validateReference = async (rootDir, reference) => {
+  const diagnostics = [];
+  try {
+    if (isGlobReference(reference.path)) {
+      const globDiagnostic = await validateGlob(rootDir, reference);
+      return globDiagnostic ? [globDiagnostic] : [];
+    }
+    const absolutePath = resolveRepoPath(rootDir, reference.path);
+    await assertRepoContainment(rootDir, absolutePath);
+    if (!await pathExists5(absolutePath)) {
+      diagnostics.push(diagnosticFor(reference, `Referenced file ${reference.path} does not exist.`));
+      return diagnostics;
+    }
+    const symbolDiagnostic = await validateSymbol(rootDir, reference);
+    if (symbolDiagnostic) {
+      diagnostics.push(symbolDiagnostic);
+    }
+    const lineSpanDiagnostic = await validateLineSpan(rootDir, reference);
+    if (lineSpanDiagnostic) {
+      diagnostics.push(lineSpanDiagnostic);
+    } else {
+      const hashDiagnostic = await validateHash(rootDir, reference);
+      if (hashDiagnostic) {
+        diagnostics.push(hashDiagnostic);
+      }
+    }
+  } catch {
+    diagnostics.push(diagnosticFor(reference, `Referenced file ${reference.path} must stay inside the repository root.`));
+  }
+  return diagnostics;
+};
+var validateEvidenceReferences = async (rootDir, truthDocPaths) => {
+  const diagnostics = [];
+  for (const truthDocPath of [...truthDocPaths].sort()) {
+    const references = await parseEvidenceReferences(rootDir, truthDocPath);
+    for (const reference of references) {
+      diagnostics.push(...await validateReference(rootDir, reference));
+    }
+  }
   return diagnostics;
 };
 
+// src/freshness/check.ts
+var checkFreshness = async (rootDir, _config, truthDocumentPaths, base) => {
+  const impactSet = await buildImpactSet(rootDir, { base });
+  const diagnostics = [...await validateEvidenceReferences(rootDir, truthDocumentPaths)];
+  for (const diagnostic of impactSet.diagnostics) {
+    if (diagnostic.category !== "impact") {
+      continue;
+    }
+    diagnostics.push({
+      ...diagnostic,
+      category: "freshness",
+      message: diagnostic.message.replace("not mapped to a Truthmark route", "not routed to truth ownership")
+    });
+  }
+  return {
+    diagnostics,
+    impactSet
+  };
+};
+
 // src/checks/check.ts
 var summarizeDiagnostics = (diagnostics) => {
   const errorCount = diagnostics.filter((diagnostic) => diagnostic.severity === "error").length;
@@ -3360,7 +4924,7 @@ var summarizeDiagnostics = (diagnostics) => {
   }
   return `Truthmark check completed with ${errorCount} error diagnostics and ${reviewCount} review diagnostics.`;
 };
-var runCheck = async (cwd) => {
+var runCheck = async (cwd, options = {}) => {
   const repository = await getGitRepository(cwd);
   const rootDir = repository.worktreePath;
   const branchScope = await getBranchScopeData(rootDir);
@@ -3378,10 +4942,21 @@ var runCheck = async (cwd) => {
   const authority = await checkAuthority(rootDir, loadResult.config);
   const areas = await checkAreas(rootDir, loadResult.config);
   const markdownPaths = [.../* @__PURE__ */ new Set([...authority.paths, ...areas.truthDocumentPaths])];
-  const frontmatter = await checkFrontmatter(rootDir, loadResult.config, markdownPaths);
+  const frontmatter = await checkFrontmatter(
+    rootDir,
+    loadResult.config,
+    markdownPaths,
+    areas.truthDocumentEntries
+  );
   const links = await checkLinks(rootDir, markdownPaths);
-  const decisionSections = await checkDecisionSections(rootDir, loadResult.config, markdownPaths);
+  const decisionSections = await checkDecisionSections(
+    rootDir,
+    loadResult.config,
+    markdownPaths,
+    areas.truthDocumentEntries
+  );
   const generatedSurfaces = await checkGeneratedSurfaces(rootDir, loadResult.config);
+  const freshness = options.base ? await checkFreshness(rootDir, loadResult.config, areas.truthDocumentPaths, options.base) : null;
   const diagnostics = [
     ...loadResult.diagnostics,
     ...authority.diagnostics,
@@ -3389,7 +4964,8 @@ var runCheck = async (cwd) => {
     ...links,
     ...areas.diagnostics,
     ...decisionSections,
-    ...generatedSurfaces
+    ...generatedSurfaces,
+    ...freshness?.diagnostics ?? []
   ];
   const truthVisibility = {
     routePrecision: areas.routePrecision,
@@ -3400,7 +4976,8 @@ var runCheck = async (cwd) => {
     syncCompletenessIssueCount: diagnostics.filter(
       (diagnostic) => diagnostic.category === "doc-structure" || diagnostic.category === "generated-surface"
     ).length,
-    topologyPressureCount: areas.topologyPressureCount
+    topologyPressureCount: areas.topologyPressureCount,
+    freshnessDiagnosticCount: freshness?.diagnostics.length ?? 0
   };
   return {
     command: "check",
@@ -3408,11 +4985,170 @@ var runCheck = async (cwd) => {
     diagnostics,
     data: {
       branchScope,
-      truthVisibility
+      truthVisibility,
+      ...freshness ? { impactSet: freshness.impactSet } : {}
+    }
+  };
+};
+
+// src/context-pack/build.ts
+import fs22 from "fs/promises";
+import path11 from "path";
+import fg9 from "fast-glob";
+var uniqueSorted2 = (values) => [...new Set(values)].sort();
+var repoRootPrefixes2 = [".codex/", ".github/", ".truthmark/", "docs/", "src/", "tests/"];
+var isGlobReference2 = (referencePath) => /[*?[\]{}()]/u.test(referencePath);
+var normalizeDocReferencePath = (docPath, referencePath) => {
+  const strippedPath = referencePath.split("#")[0]?.trim() ?? "";
+  if (strippedPath.length === 0 || strippedPath.startsWith("/")) {
+    return null;
+  }
+  const isRepoRelative = repoRootPrefixes2.some((prefix) => strippedPath.startsWith(prefix));
+  const normalized = isRepoRelative ? path11.posix.normalize(strippedPath) : path11.posix.normalize(path11.posix.join(path11.posix.dirname(docPath), strippedPath));
+  return normalized === ".." || normalized.startsWith("../") ? null : normalized;
+};
+var readIfExists = async (rootDir, filePath) => {
+  try {
+    return await fs22.readFile(path11.join(rootDir, filePath), "utf8");
+  } catch {
+    return null;
+  }
+};
+var boundedContent = (filePath, content, warnings) => {
+  const lines = content.split("\n");
+  if (lines.length <= 200) {
+    return { path: filePath, content, truncated: false };
+  }
+  warnings.push({
+    category: "context-pack",
+    severity: "review",
+    message: `Context source file ${filePath} was truncated to fit ContextPack v0 bounds.`,
+    file: filePath
+  });
+  return {
+    path: filePath,
+    content: [...lines.slice(0, 80), "...", ...lines.slice(-40)].join("\n"),
+    truncated: true
+  };
+};
+var documentsFor = async (rootDir, paths) => {
+  const documents = [];
+  for (const filePath of uniqueSorted2(paths)) {
+    const content = await readIfExists(rootDir, filePath);
+    if (content !== null) {
+      documents.push({ path: filePath, content });
+    }
+  }
+  return documents;
+};
+var sourceFilesFor = async (rootDir, paths, warnings) => {
+  const sourceFiles = [];
+  for (const filePath of uniqueSorted2(paths)) {
+    const content = await readIfExists(rootDir, filePath);
+    if (content !== null) {
+      sourceFiles.push(boundedContent(filePath, content, warnings));
     }
+  }
+  return sourceFiles;
+};
+var sourceOfTruthPathsFor = async (rootDir, docs, truthDocPaths) => {
+  const selectedTruthDocs = new Set(truthDocPaths);
+  const sourcePaths = [];
+  for (const doc of docs) {
+    if (!selectedTruthDocs.has(doc.path)) {
+      continue;
+    }
+    for (const referencePath of doc.sourceOfTruth) {
+      const normalizedPath = normalizeDocReferencePath(doc.path, referencePath);
+      if (!normalizedPath) {
+        continue;
+      }
+      if (isGlobReference2(normalizedPath)) {
+        sourcePaths.push(
+          ...await fg9(normalizedPath, {
+            cwd: rootDir,
+            dot: true,
+            onlyFiles: true,
+            followSymbolicLinks: false
+          })
+        );
+      } else {
+        sourcePaths.push(normalizedPath);
+      }
+    }
+  }
+  return uniqueSorted2(sourcePaths);
+};
+var writePathsFor = (workflow, truthDocs, routes) => {
+  if (workflow === "truth-sync") {
+    return uniqueSorted2(["docs/truthmark/areas.md", ...truthDocs]);
+  }
+  if (workflow === "truth-document") {
+    return uniqueSorted2(["docs/truthmark/areas.md", ...truthDocs]);
+  }
+  return uniqueSorted2(routes.flatMap((route) => route.codeSurface));
+};
+var testCommandsFor = (affectedTests) => {
+  return affectedTests.length === 0 ? ["npm test"] : [`npm test -- ${affectedTests.join(" ")}`];
+};
+var buildContextPack = async (cwd, options) => {
+  const repoIndex = await buildRepoIndex(cwd);
+  const rootDir = repoIndex.repository.root;
+  const impactSet = options.base ? await buildImpactSet(rootDir, { base: options.base }) : null;
+  const routeMap = impactSet ? repoIndex.routeMap : repoIndex.routeMap;
+  const warnings = [];
+  const truthDocPaths = impactSet?.affectedTruthDocs ?? (options.workflow === "truth-realize" ? [] : routeMap.routes.flatMap((route) => route.truthDocs));
+  const contextRoutes = impactSet?.affectedRoutes ?? (options.workflow === "truth-realize" ? [] : routeMap.routes);
+  if (options.workflow === "truth-realize" && !impactSet) {
+    warnings.push({
+      category: "context-pack",
+      severity: "review",
+      message: "truth-realize requires --base to derive bounded allowed write paths."
+    });
+  }
+  const sourceOfTruthPaths = await sourceOfTruthPathsFor(rootDir, repoIndex.docs, truthDocPaths);
+  const sourceFilePaths = uniqueSorted2([
+    ...impactSet?.changedFiles.filter((file) => !file.deleted).map((file) => file.path) ?? [],
+    ...sourceOfTruthPaths
+  ]);
+  return {
+    schemaVersion: "context-pack/v0",
+    workflow: options.workflow,
+    base: options.base ?? null,
+    impactSet,
+    routeMap,
+    allowedWritePaths: writePathsFor(options.workflow, truthDocPaths, contextRoutes),
+    truthDocs: await documentsFor(rootDir, truthDocPaths),
+    sourceFiles: await sourceFilesFor(rootDir, sourceFilePaths, warnings),
+    testCommands: testCommandsFor(impactSet?.affectedTests ?? []),
+    warnings
   };
 };
 
+// src/context-pack/render.ts
+var renderContextPackMarkdown = (pack) => {
+  const lines = [
+    `# Truthmark ContextPack (${pack.workflow})`,
+    "",
+    `Schema: ${pack.schemaVersion}`,
+    `Base: ${pack.base ?? "none"}`,
+    "",
+    "## Allowed Write Paths",
+    ...pack.allowedWritePaths.map((filePath) => `- ${filePath}`),
+    "",
+    "## Truth Docs",
+    ...pack.truthDocs.map((doc) => `- ${doc.path}`),
+    "",
+    "## Source Files",
+    ...pack.sourceFiles.map((file) => `- ${file.path}${file.truncated ? " (truncated)" : ""}`),
+    "",
+    "## Test Commands",
+    ...pack.testCommands.map((command) => `- ${command}`)
+  ];
+  return `${lines.join("\n")}
+`;
+};
+
 // src/cli/handlers.ts
 var runConfig2 = async (options) => {
   return runConfig(process.cwd(), options);
@@ -3420,8 +5156,96 @@ var runConfig2 = async (options) => {
 var runInit2 = async () => {
   return runInit(process.cwd());
 };
-var runCheck2 = async () => {
-  return runCheck(process.cwd());
+var runCheck2 = async (options = {}) => {
+  return runCheck(process.cwd(), options);
+};
+var runIndex = async () => {
+  const repoIndex = await buildRepoIndex(process.cwd());
+  const errorCount = repoIndex.diagnostics.filter((diagnostic) => diagnostic.severity === "error").length;
+  const reviewCount = repoIndex.diagnostics.filter((diagnostic) => diagnostic.severity === "review").length;
+  return {
+    command: "index",
+    summary: `Truthmark index completed with ${errorCount} error diagnostics and ${reviewCount} review diagnostics.`,
+    diagnostics: repoIndex.diagnostics,
+    data: {
+      repoIndex,
+      routeMap: repoIndex.routeMap
+    }
+  };
+};
+var runImpact = async (options) => {
+  if (!options.base) {
+    return {
+      command: "impact",
+      summary: "Truthmark impact requires --base.",
+      diagnostics: [
+        {
+          category: "impact",
+          severity: "error",
+          message: "truthmark impact requires --base <ref>."
+        }
+      ]
+    };
+  }
+  const impactSet = await buildImpactSet(process.cwd(), { base: options.base });
+  const errorCount = impactSet.diagnostics.filter((diagnostic) => diagnostic.severity === "error").length;
+  const reviewCount = impactSet.diagnostics.filter((diagnostic) => diagnostic.severity === "review").length;
+  return {
+    command: "impact",
+    summary: `Truthmark impact completed with ${errorCount} error diagnostics and ${reviewCount} review diagnostics.`,
+    diagnostics: impactSet.diagnostics,
+    data: {
+      impactSet
+    }
+  };
+};
+var isContextPackWorkflow = (value) => {
+  return value === "truth-sync" || value === "truth-document" || value === "truth-realize";
+};
+var isContextPackFormat = (value) => {
+  return value === void 0 || value === "json" || value === "markdown";
+};
+var runContext = async (options) => {
+  if (!isContextPackWorkflow(options.workflow)) {
+    return {
+      command: "context",
+      summary: "Truthmark context requires a supported --workflow value.",
+      diagnostics: [
+        {
+          category: "context-pack",
+          severity: "error",
+          message: "truthmark context requires --workflow truth-sync, truth-document, or truth-realize."
+        }
+      ]
+    };
+  }
+  if (!isContextPackFormat(options.format)) {
+    return {
+      command: "context",
+      summary: "Truthmark context requires a supported --format value.",
+      diagnostics: [
+        {
+          category: "context-pack",
+          severity: "error",
+          message: "truthmark context requires --format json or markdown."
+        }
+      ]
+    };
+  }
+  const contextPack = await buildContextPack(process.cwd(), {
+    workflow: options.workflow,
+    base: options.base
+  });
+  const diagnostics = contextPack.warnings;
+  return {
+    command: "context",
+    summary: `Truthmark context generated ${contextPack.workflow} ContextPack with ${diagnostics.length} warnings.`,
+    diagnostics,
+    data: {
+      contextPack,
+      ...options.format === "markdown" ? { markdown: renderContextPackMarkdown(contextPack) } : {}
+    }
+  };
 };
 
 // src/cli/program.ts
@@ -3430,6 +5254,13 @@ var writeResult = (result, options) => {
   process.stdout.write(`${output}
 `);
 };
+var writeContextResult = (result, options) => {
+  if (!options.json && options.format === "markdown" && typeof result.data?.markdown === "string") {
+    process.stdout.write(result.data.markdown);
+    return;
+  }
+  writeResult(result, options);
+};
 var addJsonOption = (command) => {
   return command.option("--json", "Render command output as JSON");
 };
@@ -3447,9 +5278,31 @@ var buildProgram = () => {
     writeResult(await runInit2(), options);
   });
   addJsonOption(
-    program.command("check").description("Run local Truthmark diagnostics.")
+    program.command("check").description("Run local Truthmark diagnostics.").option("--base <ref>", "Base Git ref for freshness diagnostics")
+  ).action(async (options) => {
+    writeResult(await runCheck2({ base: options.base }), options);
+  });
+  addJsonOption(
+    program.command("index").description("Build the deterministic Truthmark repository index.")
   ).action(async (options) => {
-    writeResult(await runCheck2(), options);
+    writeResult(await runIndex(), options);
+  });
+  addJsonOption(
+    program.command("impact").description("Map changed files to truth routes, docs, owners, and tests.").requiredOption("--base <ref>", "Base Git ref to compare against")
+  ).action(async (options) => {
+    writeResult(await runImpact({ base: options.base }), options);
+  });
+  addJsonOption(
+    program.command("context").description("Generate a bounded workflow context pack.").requiredOption("--workflow <workflow>", "Workflow name: truth-sync, truth-document, or truth-realize").option("--base <ref>", "Base Git ref for impact-backed packs").option("--format <format>", "Output format: json or markdown", "json")
+  ).action(async (options) => {
+    writeContextResult(
+      await runContext({
+        workflow: options.workflow,
+        base: options.base,
+        format: options.format
+      }),
+      options
+    );
   });
   return program;
 };