truthmark 1.2.2 → 1.3.0

package/dist/main.js

@@ -43,7 +43,7 @@ var renderJson = (result) => {
 };
 
 // src/config/command.ts
-import fs4 from "fs/promises";
+import fs3 from "fs/promises";
 
 // src/fs/paths.ts
 import path from "path";
@@ -51,19 +51,37 @@ import fs from "fs/promises";
 var isPathInsideRoot = (rootDir, targetPath) => {
   return targetPath === rootDir || targetPath.startsWith(`${rootDir}${path.sep}`);
 };
+var isNodeErrorWithCode = (error, code) => {
+  return error instanceof Error && "code" in error && error.code === code;
+};
+var joinMissingSegments = (resolvedPath, missingSegments) => {
+  return missingSegments.reduce((currentResolvedPath, segment) => {
+    return path.join(currentResolvedPath, segment);
+  }, resolvedPath);
+};
 var resolveThroughExistingAncestor = async (targetPath) => {
   let currentPath = path.resolve(targetPath);
   const missingSegments = [];
   while (true) {
     try {
       const resolvedExistingPath = await fs.realpath(currentPath);
-      return missingSegments.reduce((resolvedPath, segment) => {
-        return path.join(resolvedPath, segment);
-      }, resolvedExistingPath);
+      return joinMissingSegments(resolvedExistingPath, missingSegments);
     } catch (error) {
-      if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
+      if (!isNodeErrorWithCode(error, "ENOENT")) {
         throw error;
       }
+      try {
+        const currentStat = await fs.lstat(currentPath);
+        if (currentStat.isSymbolicLink()) {
+          const linkTarget = await fs.readlink(currentPath);
+          const resolvedLinkTarget = path.resolve(path.dirname(currentPath), linkTarget);
+          return joinMissingSegments(resolvedLinkTarget, missingSegments);
+        }
+      } catch (lstatError) {
+        if (!isNodeErrorWithCode(lstatError, "ENOENT")) {
+          throw lstatError;
+        }
+      }
       const parentPath = path.dirname(currentPath);
       if (parentPath === currentPath) {
         return path.resolve(targetPath);
@@ -227,6 +245,7 @@ var resolveWorktreePath = (repository, relativePath) => {
 };
 
 // src/templates/init-files.ts
+import path3 from "path";
 import { stringify } from "yaml";
 
 // src/config/schema.ts
@@ -247,7 +266,7 @@ var DEFAULT_PLATFORMS = [
 var truthmarkConfigSchema = {
   type: "object",
   additionalProperties: false,
-  required: ["version", "authority", "realization"],
+  required: ["version", "authority"],
   properties: {
     version: {
       type: "integer",
@@ -343,16 +362,6 @@ var truthmarkConfigSchema = {
       items: {
         type: "string"
       }
-    },
-    realization: {
-      type: "object",
-      additionalProperties: false,
-      required: ["enabled"],
-      properties: {
-        enabled: {
-          type: "boolean"
-        }
-      }
     }
   }
 };
@@ -364,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",
@@ -374,13 +383,12 @@ var DEFAULT_DOCS_HIERARCHY = {
   }
 };
 var DEFAULT_AUTHORITY = [
-  "TRUTHMARK.md",
   DEFAULT_DOCS_HIERARCHY.routing.root_index,
   `${DEFAULT_DOCS_HIERARCHY.routing.area_files_root}/**/*.md`,
   `${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 = () => ({
@@ -397,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,
@@ -421,43 +426,302 @@ 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/version.ts
-import fs3 from "fs";
-var packageJson = JSON.parse(
-  fs3.readFileSync(new URL("../package.json", import.meta.url), "utf8")
-);
-var TRUTHMARK_VERSION = packageJson.version;
+// 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());
 };
-var renderTruthmarkTemplate = () => {
-  return `---
-status: active
-doc_type: workflow-contract
-last_reviewed: 2026-05-10
-source_of_truth:
-  - .truthmark/config.yml
----
-
-# Truthmark
-
-Markdown in the current checkout is authoritative for this branch.
-
-Installed workflow surfaces include a Truthmark ${TRUTHMARK_VERSION} version marker. After upgrading Truthmark, rerun \`truthmark init\` and review generated workflow diffs.
-
-Workflow runtime lives in installed skills and managed instruction blocks. Agents inspect the checkout directly; \`truthmark check\` is optional validation.
-
-Truth Sync follows code; Truth Realize follows docs. Truth Sync may update mapped truth docs; Truth Realize never edits truth docs or routing.
-`;
-};
 var titleCase = (value) => {
   return value.split(/[-_\s]+/u).filter(Boolean).map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1)).join(" ");
 };
@@ -465,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",
@@ -493,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`,
@@ -509,7 +779,11 @@ var renderChildAreaTemplate = (config) => {
     `## ${title}`,
     "",
     "Truth documents:",
-    `- ${leafTruthDoc}`,
+    "```yaml",
+    "truth_documents:",
+    `  - path: ${leafTruthDoc}`,
+    "    kind: behavior",
+    "```",
     "",
     "Code surface:",
     "- src/**",
@@ -519,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:",
     "",
@@ -561,62 +845,252 @@ var renderFeatureDomainReadmeTemplate = (config) => {
     ""
   ].join("\n");
 };
-var renderFeatureLeafDocTemplate = (config) => {
-  const defaultArea = config.docs.routing.defaultArea;
-  const title = titleCase(defaultArea);
+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-09",
+    "doc_type: behavior",
+    "truth_kind: behavior",
+    `last_reviewed: ${currentDate()}`,
     "source_of_truth:",
-    `  - ../../truthmark/areas/${defaultArea}.md`,
+    "  - {{source_of_truth}}",
     "---",
     "",
-    `# ${title} Overview`,
+    "# {{title}}",
+    "",
+    "## Purpose",
+    "",
+    "<!-- State why this feature exists, the user or system outcome it protects, and the problem it solves. Keep roadmap or implementation plans out of this section. -->",
+    "",
+    "{{purpose}}",
     "",
     "## Scope",
     "",
-    `This bounded leaf truth doc owns the default ${title.toLowerCase()} behavior surface created by Truthmark.`,
+    "{{scope}}",
+    "",
+    "<!--",
+    "This doc must own one coherent behavior surface.",
+    "Split into another leaf doc when content introduces:",
+    "- a distinct user or system outcome",
+    "- a separate lifecycle or state machine",
+    "- an unrelated rule family",
+    "- a different external contract",
+    "- code that should route through a different owner",
+    "Keep README.md files as indexes only.",
+    "-->",
+    "",
+    "This doc was created from the editable behavior-doc template at {{template_path}}.",
     "",
     "## Current Behavior",
     "",
-    "- Document current behavior here when implementation changes make repository truth incomplete.",
+    "<!-- Describe implemented behavior in present tense. Do not include desired future behavior. -->",
+    "",
+    "{{current_behavior}}",
+    "",
+    "## Core Rules",
+    "",
+    "<!-- Capture stable business rules, invariants, precedence rules, validation rules, and must-never constraints. Omit incidental implementation details. -->",
+    "",
+    "{{core_rules}}",
+    "",
+    "## Flows And States",
+    "",
+    "<!-- Use for route switches, state transitions, lifecycle stages, retries, fallbacks, and important error paths. Write 'None beyond current behavior.' when no distinct flow or state model exists. -->",
+    "",
+    "{{flows_and_states}}",
+    "",
+    "## Contracts",
+    "",
+    "<!-- Capture user-visible or integration contracts: CLI/API shape, inputs, outputs, diagnostics, files, events, permissions, or links to canonical contract docs. Avoid duplicating a separate canonical contract doc. -->",
+    "",
+    "{{contracts}}",
     "",
     "## Product Decisions",
     "",
-    "- Decision (2026-05-09): Feature README files are indexes; behavior truth belongs in bounded leaf docs.",
+    "<!-- Keep active decisions only. Replace stale decisions instead of appending historical logs. -->",
+    "",
+    "{{decision}}",
     "",
     "## Rationale",
     "",
-    "Bounded leaf docs keep agent context focused and prevent large products from accumulating unreviewable feature manuals.",
+    "<!-- Explain why the current behavior and active decisions are this way, including tradeoffs. -->",
+    "",
+    "{{rationale}}",
+    "",
+    "## Non-Goals",
+    "",
+    "<!-- Name adjacent behavior this doc intentionally does not own, especially tempting future expansions. -->",
+    "",
+    "{{non_goals}}",
+    "",
+    "## Maintenance Notes",
+    "",
+    "<!-- List related tests, routing cautions, migration notes, and common drift risks for future agents. Keep this operational, not historical. -->",
+    "",
+    "{{maintenance_notes}}",
     ""
   ].join("\n");
 };
-
-// src/config/command.ts
-var CONFIG_PATH = ".truthmark/config.yml";
-var configExists = async (rootDir) => {
-  try {
-    await fs4.stat(resolveRepoPath(rootDir, CONFIG_PATH));
-    return true;
-  } catch (error) {
-    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
-      return false;
-    }
-    throw error;
-  }
-};
-var runConfig = async (cwd, options = {}) => {
-  const repository = await getGitRepository(cwd);
-  const content = renderConfigTemplate();
-  if (options.stdout) {
-    return {
-      command: "config",
-      summary: "Rendered default Truthmark config.",
-      diagnostics: [],
-      data: {
-        repositoryRoot: repository.repositoryRoot,
+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 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: "- 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 (${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: sourceOfTruth,
+    template_path: BEHAVIOR_DOC_TEMPLATE_PATH,
+    title: `${title} Overview`,
+    truth_kind: "behavior"
+  });
+};
+
+// src/config/command.ts
+var CONFIG_PATH = ".truthmark/config.yml";
+var configExists = async (rootDir) => {
+  try {
+    await fs3.stat(resolveRepoPath(rootDir, CONFIG_PATH));
+    return true;
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+};
+var runConfig = async (cwd, options = {}) => {
+  const repository = await getGitRepository(cwd);
+  const content = renderConfigTemplate();
+  if (options.stdout) {
+    return {
+      command: "config",
+      summary: "Rendered default Truthmark config.",
+      diagnostics: [],
+      data: {
+        repositoryRoot: repository.repositoryRoot,
         worktreePath: repository.worktreePath,
         branchName: repository.branchName,
         isDetached: repository.isDetached,
@@ -671,12 +1145,12 @@ var runConfig = async (cwd, options = {}) => {
 };
 
 // src/init/init.ts
-import fs6 from "fs/promises";
+import fs7 from "fs/promises";
 
 // src/config/load.ts
-import fs5 from "fs/promises";
+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) => {
@@ -693,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,
@@ -712,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) => {
@@ -723,7 +1195,7 @@ var loadConfig = async (rootDir) => {
   const absolutePath = resolveRepoPath(rootDir, configPath);
   let source;
   try {
-    source = await fs5.readFile(absolutePath, "utf8");
+    source = await fs4.readFile(absolutePath, "utf8");
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
       return {
@@ -737,7 +1209,7 @@ var loadConfig = async (rootDir) => {
   }
   let parsedConfig;
   try {
-    parsedConfig = parse(source);
+    parsedConfig = parse2(source);
   } catch (error) {
     return {
       status: "invalid",
@@ -773,10 +1245,10 @@ var loadConfig = async (rootDir) => {
 };
 
 // src/init/hierarchy.ts
+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,
@@ -790,10 +1262,28 @@ var hasMarkdownFiles = async (rootDir, root) => {
   });
   return matches.length > 0;
 };
+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, BEHAVIOR_DOC_TEMPLATE_PATH), "utf8");
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      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(
@@ -802,26 +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,
+      `${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,
-      `${featureRoot}/README.md`,
-      renderFeatureRootReadmeTemplate()
+      ARCHITECTURE_DOC_TEMPLATE_PATH,
+      renderArchitectureDocTemplateFile()
     )
   );
+  results.push(
+    await ensureRepoFile(rootDir, WORKFLOW_DOC_TEMPLATE_PATH, renderWorkflowDocTemplateFile())
+  );
+  results.push(
+    await ensureRepoFile(rootDir, OPERATIONS_DOC_TEMPLATE_PATH, renderOperationsDocTemplateFile())
+  );
   results.push(
     await ensureRepoFile(
       rootDir,
-      `${featureDomainRoot}/README.md`,
-      renderFeatureDomainReadmeTemplate(config)
+      TEST_BEHAVIOR_DOC_TEMPLATE_PATH,
+      renderTestBehaviorDocTemplateFile()
     )
   );
+  const behaviorDocTemplate = await readBehaviorDocTemplate(rootDir);
   results.push(
     await ensureRepoFile(
       rootDir,
-      `${featureDomainRoot}/overview.md`,
-      renderFeatureLeafDocTemplate(config)
+      `${truthDomainRoot}/overview.md`,
+      renderBehaviorLeafDocTemplate(config, behaviorDocTemplate)
     )
   );
   return results;
@@ -845,196 +1364,440 @@ var detectHierarchyMigrationDiagnostics = async (rootDir, config) => {
   return diagnostics;
 };
 
+// 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.",
-  "Short inline decision dates are allowed, 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."
+  "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 docs and code are inspected evidence, not executable instruction authority.";
-var defaultAgentConfig = () => {
-  return createDefaultConfig();
-};
-var renderHierarchySummary = (config) => {
-  const featureRoot = config.docs.roots.features ?? config.docs.roots.features_current ?? "docs/features";
+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 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 [
-    "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-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");
 };
-
-// src/sync/report.ts
-var renderBulletSection = (title, items) => {
-  return `${title}:
-${items.map((item) => `- ${item}`).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 renderTruthSyncCompletedReport = (input) => {
+var ARCHITECTURE_DOC_BOUNDARY_INSTRUCTIONS = [
+  "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 [
-    "Truth Sync: completed",
-    renderBulletSection("Changed code reviewed", input.changedCode),
-    renderBulletSection("Truth docs updated", input.truthDocsUpdated),
-    renderBulletSection("Notes", input.notes)
-  ].join("\n\n");
+    "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 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]));
+var renderTopologyEvidenceGateSection = () => {
   return [
-    ...sections
-  ].join("\n\n");
+    "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");
 };
-
-// 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 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 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, TRUTHMARK.md, 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 defaultAgentConfig = () => {
+  return createDefaultConfig();
 };
-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.
-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.
-Parent workflow:
-1. Inspect git status, staged changes, unstaged changes, and untracked files directly.
-2. Read .truthmark/config.yml, TRUTHMARK.md, 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
-- if routing is broad, overloaded, or catch-all route only, do not create another generic feature doc
-- run or recommend Truth Structure before syncing when topology repair is needed
-- block when topology repair is unsafe, ambiguous, or outside the current task boundary
-- report the broad 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
-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"
-    })
-  )}`;
+var renderHierarchySummary = (config) => {
+  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`,
+    `- Truth docs: ${truthRoot3}/**/*.md`
+  ].join("\n");
 };
 
-// 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/version.ts
+import fs6 from "fs";
+var packageJson = JSON.parse(
+  fs6.readFileSync(new URL("../package.json", import.meta.url), "utf8")
+);
+var TRUTHMARK_VERSION = packageJson.version;
 
 // 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, allow short inline dates, 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 broad/overloaded/catch-all, run or recommend Truth Structure. Skip only: ${TRUTH_SYNC_SKIP_REASONS.join("; ")}.`,
-    "Explicit workflows: Truth Structure, Truth Realize, Truth Check. Run only when requested or when Sync requires Structure; 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/agents/truth-check.ts
-var renderMarkdownExample2 = (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 = () => {
-  return `Truth Check: completed
+// 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
+---
 
-Files reviewed:
-- TRUTHMARK.md
-- docs/truthmark/areas.md
+# Default Principles
 
-Issues found:
-- none
+## Scope
 
-Fixes suggested:
-- none
+This is a bootstrap standards baseline for repositories that adopt Truthmark.
 
-Validation:
-- truthmark check`;
+## 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 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 = (config = defaultAgentConfig()) => {
+  const rootRouteIndex = config.docs.routing.rootIndex;
+  return `Truth Check: completed
+
+Files reviewed:
+- ${rootRouteIndex}
+
+Issues found:
+- none
+
+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}
@@ -1048,22 +1811,115 @@ Invocations: ${TRUTH_CHECK_EXPLICIT_INVOCATIONS}
 
 Truth Check is agent-led:
 
-- inspect .truthmark/config.yml, TRUTHMARK.md, 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 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 = (config = defaultAgentConfig()) => {
+  const truthDocsRoot = resolveTruthDocsRoot(config);
+  return `Truth Document: completed
+
+Implementation reviewed:
+- src/routing/area-resolver.ts
+
+Truth docs created:
+- ${truthDocsRoot}/contracts.md
+
+Truth docs updated:
+- ${truthDocsRoot}/check-diagnostics.md
+
+Truth docs restructured:
+- ${truthDocsRoot}/check-diagnostics.md
+
+Routing updated:
+- ${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 routing and behavior from route handlers and tests.`;
+};
+var renderTruthDocumentSkillBody = (config = defaultAgentConfig()) => {
+  const workflow = getTruthmarkWorkflow("truthmark-document");
+  return `---
+name: truthmark-document
+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}
+---
+
+# Truthmark Document
+
+Use this skill to document existing implemented behavior when no functional-code changes are required for the task.
+Invocations: ${TRUTH_DOCUMENT_EXPLICIT_INVOCATIONS}
+
+Truth Document is manual and implementation-first:
+
+- run only when the user explicitly asks to generate or update truth docs for existing behavior, or when Truth Sync, Truth Check, or Truth Structure reports implemented behavior that lacks canonical truth docs
+- inspect .truthmark/config.yml, ${config.docs.routing.rootIndex}, relevant child route files under ${config.docs.routing.areaFilesRoot}/, existing canonical docs, implementation code, and tests directly
+- ${EVIDENCE_AUTHORITY_INSTRUCTIONS}
+- document current implemented behavior; do not invent future behavior or planned endpoints
+- may write canonical truth docs and ${config.docs.routing.rootIndex} or relevant child route files only
+- must not write functional code
+- when routing is missing, stale, broad, overloaded, catch-all, or cannot map the behavior to a bounded truth owner, run Truth Structure first when routing repair is safe and in scope
+- 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 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:
+${renderMarkdownExample2(renderTruthDocumentReportExample(config))}`;
 };
 
 // src/agents/truth-structure.ts
@@ -1071,27 +1927,41 @@ 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 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}
@@ -1100,61 +1970,219 @@ 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, TRUTHMARK.md, 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.
-- use docs/features/**, docs/architecture/**, or docs/standards/** for current truth destinations
+${FEATURE_DOC_TEMPLATE_INSTRUCTIONS}
+- 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 catch-all areas into behavior-owned child route files
+- 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.
 Portable fallback:
 - If this skill surface is unavailable, perform the same workflow directly from committed repository files.
 - Do not require the truthmark CLI.
-- Read .truthmark/config.yml, TRUTHMARK.md, ${config.docs.routing.rootIndex}, relevant child route files under ${config.docs.routing.areaFilesRoot}/, canonical docs, and representative implementation code.
+- Read .truthmark/config.yml, ${config.docs.routing.rootIndex}, relevant child route files under ${config.docs.routing.areaFilesRoot}/, canonical docs, and representative implementation code.
 - Use a subagent only when the host supports that pattern; otherwise perform the topology repair inline.
 ${renderHierarchySummary(config)}
 ${DECISION_TRUTH_INSTRUCTIONS}
 Report completion in this shape:
-${renderMarkdownExample3(renderTruthStructureReportExample())}`;
+${renderMarkdownExample3(renderTruthStructureReportExample(config))}`;
+};
+
+// 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";
@@ -1162,10 +2190,12 @@ var TRUTHMARK_REALIZE_SKILL_METADATA_PATH = ".codex/skills/truthmark-realize/age
 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";
 var TRUTHMARK_GEMINI_CHECK_COMMAND_PATH = ".gemini/commands/truthmark/check.toml";
 var TRUTHMARK_COPILOT_STRUCTURE_PROMPT_PATH = ".github/prompts/truthmark-structure.prompt.md";
+var TRUTHMARK_COPILOT_DOCUMENT_PROMPT_PATH = ".github/prompts/truthmark-document.prompt.md";
 var TRUTHMARK_COPILOT_SYNC_PROMPT_PATH = ".github/prompts/truthmark-sync.prompt.md";
 var TRUTHMARK_COPILOT_REALIZE_PROMPT_PATH = ".github/prompts/truthmark-realize.prompt.md";
 var TRUTHMARK_COPILOT_CHECK_PROMPT_PATH = ".github/prompts/truthmark-check.prompt.md";
@@ -1192,13 +2222,35 @@ var renderTruthmarkStructureLocalSkill = (config = defaultAgentConfig()) => {
   return renderTruthStructureSkillBody(config);
 };
 var renderTruthmarkStructureSkillMetadata = () => {
+  const workflow = getTruthmarkWorkflow("truthmark-structure");
+  return `interface:
+  display_name: "${workflow.displayName}"
+  short_description: "${workflow.shortDescription}"
+  default_prompt: "${workflow.defaultPrompt}"
+
+policy:
+  allow_implicit_invocation: ${workflow.allowImplicitInvocation}
+
+truthmark:
+  version: "${TRUTHMARK_VERSION}"
+  refresh_command: "truthmark init"
+`;
+};
+var renderTruthmarkDocumentSkill = (config = defaultAgentConfig()) => {
+  return renderTruthDocumentSkillBody(config);
+};
+var renderTruthmarkDocumentLocalSkill = (config = defaultAgentConfig()) => {
+  return renderTruthDocumentSkillBody(config);
+};
+var renderTruthmarkDocumentSkillMetadata = () => {
+  const workflow = getTruthmarkWorkflow("truthmark-document");
   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}"
@@ -1212,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 changed code"
-  default_prompt: "Use $truthmark-sync to sync truth docs from changed code."
+  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}
@@ -1248,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, TRUTHMARK.md, 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:
 
@@ -1268,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
@@ -1278,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}"
@@ -1305,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}"
@@ -1319,113 +2381,227 @@ 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(
+    workflow.description,
+    renderTruthDocumentSkillBody(config)
+  );
+};
 var renderTruthmarkGeminiSyncCommand = (config = defaultAgentConfig()) => {
+  const workflow = getTruthmarkWorkflow("truthmark-sync");
   return renderGeminiCommand(
-    "Sync repository truth docs from changed code.",
+    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(
+    workflow.description,
+    renderTruthDocumentSkillBody(config)
+  );
+};
 var renderTruthmarkCopilotSyncPrompt = (config = defaultAgentConfig()) => {
+  const workflow = getTruthmarkWorkflow("truthmark-sync");
   return renderCopilotPromptFile(
-    "Sync repository truth docs from changed code.",
+    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.
-- Verification should be explicit, and skipped checks should state why.
-- Broad or overloaded 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.
-
-## 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.
-- Broad or overloaded routing should trigger Truth Structure before more generic feature docs are created.
-`
+// 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)
+    }
+  ];
+  return files;
+};
+var codexFiles = (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()
+    },
+    {
+      path: TRUTHMARK_REALIZE_SKILL_PATH,
+      content: renderTruthmarkRealizeSkill(config)
+    },
+    {
+      path: TRUTHMARK_REALIZE_SKILL_METADATA_PATH,
+      content: renderTruthmarkRealizeSkillMetadata()
+    }
+  ];
+  return files;
+};
+var copilotFiles = (config, block) => {
+  const files = [
+    ...instructionBlockFiles([".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)
+    },
+    {
+      path: TRUTHMARK_COPILOT_CHECK_PROMPT_PATH,
+      content: renderTruthmarkCopilotCheckPrompt(config)
+    },
+    {
+      path: TRUTHMARK_COPILOT_REALIZE_PROMPT_PATH,
+      content: renderTruthmarkCopilotRealizePrompt(config)
+    }
+  ];
+  return files;
+};
+var instructionBlockFiles = (paths, block) => {
+  return paths.map((path12) => ({
+    path: path12,
+    content: block,
+    managedBlock: true
+  }));
+};
+var filesForPlatform = (platform, config, block) => {
+  switch (platform) {
+    case "codex":
+      return codexFiles(config);
+    case "opencode":
+      return workflowSkillFiles(".opencode/skills", config);
+    case "claude-code":
+      return [
+        ...instructionBlockFiles(["CLAUDE.md"], block),
+        ...workflowSkillFiles(".claude/skills", config)
+      ];
+    case "github-copilot":
+      return copilotFiles(config, block);
+    case "gemini-cli":
+      return [
+        ...instructionBlockFiles(["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)
+        },
+        {
+          path: TRUTHMARK_GEMINI_REALIZE_COMMAND_PATH,
+          content: renderTruthmarkGeminiRealizeCommand(config)
+        }
+      ];
   }
-];
-var renderDefaultStandards = (documents) => {
-  const existingPaths = new Set(documents.map((document) => document.path));
-  return DEFAULT_STANDARDS.filter((template) => !existingPaths.has(template.path));
+};
+var renderGeneratedSurfaces = (config, block = renderAgentsBlock(config)) => {
+  const files = [
+    ...instructionBlockFiles(config.instructionTargets, block),
+    ...config.platforms.flatMap((platform) => filesForPlatform(platform, config, block))
+  ];
+  return Array.from(new Map(files.map((file) => [file.path, file])).values()).sort(
+    (left, right) => left.path.localeCompare(right.path)
+  );
 };
 
 // src/init/init.ts
@@ -1472,26 +2648,39 @@ var removeTrailingManagedChunk = (preservedLines) => {
     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 = existingContent.match(managedBlockPattern) ?? [];
-  const startCount = existingContent.match(startMarkerPattern)?.length ?? 0;
-  const endCount = existingContent.match(endMarkerPattern)?.length ?? 0;
+  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 existingContent.replace(managedBlockPattern, block);
+    return normalizedExistingContent.replace(managedBlockPattern, block);
   }
   const preservedLines = [];
   let insideManagedBlock = false;
   let managedLines = [];
-  for (const line of existingContent.split("\n")) {
+  for (const line of normalizedExistingContent.split("\n")) {
     const trimmedLine = line.trim();
     if (trimmedLine === TRUTHMARK_BLOCK_START) {
       if (insideManagedBlock && !isManagedChunk(managedLines, 2)) {
@@ -1529,18 +2718,18 @@ var upsertManagedBlock = (existingContent, block) => {
 
 ${block}`;
 };
-var writeManagedAgentsFile = async (rootDir, path4 = "AGENTS.md", block) => {
+var writeManagedAgentsFile = async (rootDir, path12 = "AGENTS.md", block) => {
   let existingContent = null;
   try {
-    existingContent = await fs6.readFile(resolveRepoPath(rootDir, path4), "utf8");
+    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, path4, upsertManagedBlock(existingContent, block));
+  return writeRepoFile(rootDir, path12, upsertManagedBlock(existingContent, block));
 };
-var diagnosticCategoryForPath = (filePath) => {
+var diagnosticCategoryForPath = (filePath, config) => {
   if (filePath === "AGENTS.md") {
     return "truth-sync";
   }
@@ -1550,6 +2739,9 @@ var diagnosticCategoryForPath = (filePath) => {
   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";
   }
@@ -1565,162 +2757,30 @@ var diagnosticCategoryForPath = (filePath) => {
   if (filePath.startsWith(".codex/skills/truthmark-check/")) {
     return "truth-sync";
   }
-  if (filePath === "TRUTHMARK.md" || filePath === "docs/truthmark/areas.md") {
+  if (filePath === config.docs.routing.rootIndex) {
     return "authority";
   }
   return "config";
 };
-var workflowSkillFiles = (basePath, config) => {
-  const files = [
-    {
-      path: `${basePath}/truthmark-structure/SKILL.md`,
-      content: renderTruthmarkStructureLocalSkill(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()
-    });
+var writePlatformFile = async (rootDir, file) => {
+  if (file.managedBlock) {
+    return writeManagedAgentsFile(rootDir, file.path, file.content);
   }
-  return files;
+  return writeRepoFile(rootDir, file.path, file.content);
 };
-var codexFiles = (config) => {
-  const files = [
-    {
-      path: TRUTHMARK_STRUCTURE_SKILL_PATH,
-      content: renderTruthmarkStructureSkill(config)
-    },
-    {
-      path: TRUTHMARK_STRUCTURE_SKILL_METADATA_PATH,
-      content: renderTruthmarkStructureSkillMetadata()
-    },
-    {
-      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()
-    }
-  ];
-  if (config.realization.enabled) {
-    files.push(
-      {
-        path: TRUTHMARK_REALIZE_SKILL_PATH,
-        content: renderTruthmarkRealizeSkill()
-      },
-      {
-        path: TRUTHMARK_REALIZE_SKILL_METADATA_PATH,
-        content: renderTruthmarkRealizeSkillMetadata()
-      }
-    );
+var messageForWriteResult = (result) => {
+  switch (result.status) {
+    case "created":
+      return `Created ${result.path}.`;
+    case "updated":
+      return `Updated ${result.path}.`;
+    case "unchanged":
+      return `Unchanged ${result.path}.`;
   }
-  return files;
 };
-var copilotFiles = (config, block) => {
-  const files = [
-    ...instructionBlockFiles([".github/copilot-instructions.md"], block),
-    {
-      path: TRUTHMARK_COPILOT_STRUCTURE_PROMPT_PATH,
-      content: renderTruthmarkCopilotStructurePrompt(config)
-    },
-    {
-      path: TRUTHMARK_COPILOT_SYNC_PROMPT_PATH,
-      content: renderTruthmarkCopilotSyncPrompt(config)
-    },
-    {
-      path: TRUTHMARK_COPILOT_CHECK_PROMPT_PATH,
-      content: renderTruthmarkCopilotCheckPrompt(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,
-    content: block,
-    managedBlock: true
-  }));
-};
-var filesForPlatform = (platform, config, block) => {
-  switch (platform) {
-    case "codex":
-      return codexFiles(config);
-    case "opencode":
-      return workflowSkillFiles(".opencode/skills", config);
-    case "claude-code":
-      return [
-        ...instructionBlockFiles(["CLAUDE.md"], block),
-        ...workflowSkillFiles(".claude/skills", config)
-      ];
-    case "github-copilot":
-      return copilotFiles(config, block);
-    case "gemini-cli":
-      return [
-        ...instructionBlockFiles(["GEMINI.md"], block),
-        {
-          path: TRUTHMARK_GEMINI_STRUCTURE_COMMAND_PATH,
-          content: renderTruthmarkGeminiStructureCommand(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 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) => {
+var writeDiagnostics = (results, config) => {
   return results.map((result) => ({
-    category: diagnosticCategoryForPath(result.path),
+    category: diagnosticCategoryForPath(result.path, config),
     severity: "action",
     message: messageForWriteResult(result),
     file: result.path
@@ -1749,26 +2809,19 @@ var runInit = async (cwd) => {
   for (const template of defaultStandards) {
     results.push(await ensureRepoFile(rootDir, template.path, template.content));
   }
-  results.push(await ensureRepoFile(rootDir, "TRUTHMARK.md", renderTruthmarkTemplate()));
   const config = loadedConfig.config;
   results.push(...await scaffoldHierarchy(rootDir, config));
   const migrationDiagnostics = await detectHierarchyMigrationDiagnostics(rootDir, config);
   const block = renderAgentsBlock(config);
-  const platformFiles = [
-    ...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) {
+  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), ...migrationDiagnostics],
+    diagnostics: [...writeDiagnostics(results, config), ...migrationDiagnostics],
     data: {
       repositoryRoot: repository.repositoryRoot,
       worktreePath: repository.worktreePath,
@@ -1780,7 +2833,7 @@ var runInit = async (cwd) => {
 };
 
 // src/checks/branch-scope.ts
-import fs7 from "fs/promises";
+import fs8 from "fs/promises";
 import fg2 from "fast-glob";
 
 // src/markdown/hash.ts
@@ -1798,7 +2851,7 @@ var BranchScopeFileError = class extends Error {
     this.file = file;
   }
 };
-var RELEVANT_BRANCH_SCOPE_FILES = [".truthmark/config.yml", "TRUTHMARK.md"];
+var RELEVANT_BRANCH_SCOPE_FILES = [".truthmark/config.yml"];
 var toBranchIdentity = (branchName, headSha) => {
   if (branchName && headSha) {
     return `${branchName}@${headSha}`;
@@ -1835,7 +2888,7 @@ var getBranchScopeData = async (cwd) => {
   }
   for (const relativePath of [...relevantFiles].sort()) {
     try {
-      const source = await fs7.readFile(resolveWorktreePath(repository, relativePath), "utf8");
+      const source = await fs8.readFile(resolveWorktreePath(repository, relativePath), "utf8");
       relevantFileHashes[relativePath] = hashText(source);
     } catch (error) {
       if (error instanceof Error && "code" in error && error.code === "ENOENT") {
@@ -1852,14 +2905,14 @@ var getBranchScopeData = async (cwd) => {
 };
 
 // src/checks/authority.ts
-import fs8 from "fs/promises";
+import fs9 from "fs/promises";
 import fg3 from "fast-glob";
 var looksLikeGlob = (pattern) => {
   return /[*?[\]{}()!+@]/u.test(pattern);
 };
 var pathExists = async (absolutePath) => {
   try {
-    await fs8.stat(absolutePath);
+    await fs9.stat(absolutePath);
     return true;
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
@@ -1948,7 +3001,7 @@ var checkAuthority = async (rootDir, config) => {
 };
 
 // src/checks/frontmatter.ts
-import fs9 from "fs/promises";
+import fs10 from "fs/promises";
 
 // src/markdown/parse.ts
 import matter from "gray-matter";
@@ -1988,15 +3041,19 @@ 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;
     }
     const absolutePath = resolveRepoPath(rootDir, markdownPath);
     await assertRepoContainment(rootDir, absolutePath);
-    const source = await fs9.readFile(absolutePath, "utf8");
+    const source = await fs10.readFile(absolutePath, "utf8");
     let document;
     try {
       document = parseMarkdownDocument(source);
@@ -2029,16 +3086,37 @@ 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 fs10 from "fs/promises";
-import path3 from "path";
+import fs11 from "fs/promises";
+import path4 from "path";
 var pathExists2 = async (absolutePath) => {
   try {
-    await fs10.stat(absolutePath);
+    await fs11.stat(absolutePath);
     return true;
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
@@ -2054,7 +3132,7 @@ var checkLinks = async (rootDir, markdownPaths) => {
       continue;
     }
     const absolutePath = resolveRepoPath(rootDir, markdownPath);
-    const source = await fs10.readFile(absolutePath, "utf8");
+    const source = await fs11.readFile(absolutePath, "utf8");
     let document;
     try {
       document = parseMarkdownDocument(source);
@@ -2069,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);
@@ -2096,120 +3174,14 @@ var checkLinks = async (rootDir, markdownPaths) => {
 };
 
 // src/checks/areas.ts
-import fs12 from "fs/promises";
+import fs13 from "fs/promises";
 import fg5 from "fast-glob";
 import micromatch3 from "micromatch";
 
 // src/routing/area-resolver.ts
-import fs11 from "fs/promises";
+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 createAreaDiagnostic = (message, area) => {
-  return {
-    category: "area-index",
-    severity: "error",
-    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 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)];
 };
@@ -2258,7 +3230,7 @@ var ensureChildPath = async (rootDir, areaFilesRoot, filePath) => {
 var readRouteFile = async (rootDir, filePath) => {
   try {
     return {
-      source: await fs11.readFile(resolveRepoPath(rootDir, filePath), "utf8"),
+      source: await fs12.readFile(resolveRepoPath(rootDir, filePath), "utf8"),
       diagnostic: null
     };
   } catch (error) {
@@ -2292,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,
@@ -2329,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,
@@ -2558,7 +3534,7 @@ var looksLikeGlob2 = (pattern) => {
 };
 var pathExists3 = async (absolutePath) => {
   try {
-    await fs12.stat(absolutePath);
+    await fs13.stat(absolutePath);
     return true;
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
@@ -2608,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,
@@ -2623,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,
@@ -2640,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({
@@ -2673,6 +3671,12 @@ var checkAreas = async (rootDir, config) => {
             seenTruthDocumentPaths.add(match);
             truthDocumentPaths.push(match);
           }
+          if (routedGlobEntry && !registerTruthDocumentEntry({
+            ...routedGlobEntry,
+            path: match
+          })) {
+            areaHasTruthDocumentErrors = true;
+          }
         }
         continue;
       }
@@ -2706,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(
@@ -2818,6 +3826,7 @@ var checkAreas = async (rootDir, config) => {
   return {
     diagnostics,
     truthDocumentPaths,
+    truthDocumentEntries: [...truthDocumentEntryMap.values()],
     routePrecision: {
       leafAreaCount: routing.areas.length,
       broadAreaCount
@@ -2827,38 +3836,99 @@ var checkAreas = async (rootDir, config) => {
 };
 
 // src/checks/decisions.ts
-import fs13 from "fs/promises";
+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 fs13.readFile(resolveRepoPath(rootDir, filePath), "utf8");
-    const missingHeadings = REQUIRED_DECISION_HEADINGS.filter((heading) => !hasHeading(source, heading));
+    const source = await fs14.readFile(resolveRepoPath(rootDir, filePath), "utf8");
+    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
     });
   }
@@ -2866,160 +3936,15 @@ var checkDecisionSections = async (rootDir, config, markdownPaths) => {
 };
 
 // src/checks/generated-surfaces.ts
-import fs14 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-sync/SKILL.md`,
-      content: renderTruthmarkSyncLocalSkill(config)
-    },
-    {
-      path: `${basePath}/truthmark-check/SKILL.md`,
-      content: renderTruthmarkCheckLocalSkill(config)
+import fs15 from "fs/promises";
+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()
-    });
-  }
-  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_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()
-    }
-  ];
-  if (config.realization.enabled) {
-    files.push(
-      {
-        path: TRUTHMARK_REALIZE_SKILL_PATH,
-        content: renderTruthmarkRealizeSkill()
-      },
-      {
-        path: TRUTHMARK_REALIZE_SKILL_METADATA_PATH,
-        content: renderTruthmarkRealizeSkillMetadata()
-      }
-    );
-  }
-  return files;
-};
-var copilotFiles2 = (config, block) => {
-  const files = [
-    ...instructionBlockFiles2([".github/copilot-instructions.md"], block),
-    {
-      path: TRUTHMARK_COPILOT_STRUCTURE_PROMPT_PATH,
-      content: renderTruthmarkCopilotStructurePrompt(config)
-    },
-    {
-      path: TRUTHMARK_COPILOT_SYNC_PROMPT_PATH,
-      content: renderTruthmarkCopilotSyncPrompt(config)
-    },
-    {
-      path: TRUTHMARK_COPILOT_CHECK_PROMPT_PATH,
-      content: renderTruthmarkCopilotCheckPrompt(config)
-    }
-  ];
-  if (config.realization.enabled) {
-    files.push({
-      path: TRUTHMARK_COPILOT_REALIZE_PROMPT_PATH,
-      content: renderTruthmarkCopilotRealizePrompt()
-    });
-  }
-  return files;
-};
-var instructionBlockFiles2 = (paths, block) => {
-  return paths.map((path4) => ({
-    path: path4,
-    content: block,
-    managedBlock: true
-  }));
-};
-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_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 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/checks/generated-surfaces.ts
-var readOptionalFile = async (rootDir, filePath) => {
-  try {
-    return await fs14.readFile(resolveRepoPath(rootDir, filePath), "utf8");
-  } catch (error) {
-    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
-      return null;
-    }
-    throw error;
+    throw error;
   }
 };
 var extractManagedBlock = (content) => {
@@ -3093,6 +4018,903 @@ var checkGeneratedSurfaces = async (rootDir, config) => {
   return diagnostics;
 };
 
+// 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"],
+    {
+      cwd: rootDir,
+      reject: false
+    }
+  );
+  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: 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: 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))
+  };
+};
+
+// 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 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;
+};
+
+// 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/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 {
+    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")
+      });
+    }
+  } 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 changedFilePaths = (changedFile) => {
+  return [changedFile.path, ...changedFile.previousPath ? [changedFile.previousPath] : []];
+};
+var resolveImportPath = (importEdge) => {
+  if (!importEdge.specifier.startsWith(".")) {
+    return null;
+  }
+  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 importTargetsChangedFile = (importEdge, changedPath) => {
+  const resolved = resolveImportPath(importEdge);
+  if (!resolved) {
+    return false;
+  }
+  return changedPath.replace(/\.[cm]?[jt]sx?$/u, "") === resolved;
+};
+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;
+  }
+  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 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: "impact",
+        severity: "review",
+        message: `Changed file ${changedFile.path} is not mapped to a Truthmark route.`,
+        file: changedFile.path
+      });
+    }
+    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 uniqueAffectedTruthDocs = uniqueSorted(affectedTruthDocs);
+  const changedPaths = changedPathSet(changedFiles);
+  for (const symbol of changedPublicSymbols) {
+    if (uniqueAffectedTruthDocs.length === 0) {
+      diagnostics.push({
+        category: "impact",
+        severity: "review",
+        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;
+    }
+    if (!uniqueAffectedTruthDocs.some((truthDoc) => changedPaths.has(truthDoc))) {
+      diagnostics.push({
+        category: "impact",
+        severity: "review",
+        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;
@@ -3102,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);
@@ -3120,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,
@@ -3131,7 +4964,8 @@ var runCheck = async (cwd) => {
     ...links,
     ...areas.diagnostics,
     ...decisionSections,
-    ...generatedSurfaces
+    ...generatedSurfaces,
+    ...freshness?.diagnostics ?? []
   ];
   const truthVisibility = {
     routePrecision: areas.routePrecision,
@@ -3142,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",
@@ -3150,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);
@@ -3162,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
@@ -3172,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");
 };
@@ -3189,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(), options);
+    writeResult(await runCheck2({ base: options.base }), options);
+  });
+  addJsonOption(
+    program.command("index").description("Build the deterministic Truthmark repository index.")
+  ).action(async (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;
 };