@shahmarasy/prodo 0.1.3 → 0.1.5

package/dist/core/template-resolver.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveTemplate = resolveTemplate;
+exports.resolveCompanionTemplate = resolveCompanionTemplate;
+exports.extractRequiredHeadingsFromTemplate = extractRequiredHeadingsFromTemplate;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const paths_1 = require("./paths");
+const markdown_1 = require("./markdown");
+const utils_1 = require("./utils");
+async function resolveTemplate(options) {
+    const { cwd, artifactType } = options;
+    const candidates = [
+        ...(0, paths_1.overrideTemplateCandidatePaths)(cwd, artifactType),
+        ...(0, paths_1.templateCandidatePaths)(cwd, artifactType)
+    ];
+    for (const filePath of candidates) {
+        if (await (0, utils_1.fileExists)(filePath)) {
+            const content = await promises_1.default.readFile(filePath, "utf8");
+            return { path: filePath, content };
+        }
+    }
+    return null;
+}
+async function resolveCompanionTemplate(options) {
+    const { cwd, artifactType } = options;
+    const nativeExt = artifactType === "workflow" ? ".mmd" : artifactType === "wireframe" ? ".html" : null;
+    if (!nativeExt)
+        return null;
+    const candidates = [
+        ...(0, paths_1.overrideTemplateCandidatePaths)(cwd, artifactType),
+        ...(0, paths_1.templateCandidatePaths)(cwd, artifactType)
+    ].filter((candidate) => candidate.toLowerCase().endsWith(nativeExt));
+    for (const filePath of candidates) {
+        if (await (0, utils_1.fileExists)(filePath)) {
+            const content = await promises_1.default.readFile(filePath, "utf8");
+            return { path: filePath, content };
+        }
+    }
+    return null;
+}
+function extractRequiredHeadingsFromTemplate(content) {
+    return (0, markdown_1.extractRequiredHeadings)(content);
+}

package/dist/core/templates.d.ts

@@ -0,0 +1,33 @@
+import type { ArtifactType } from "./types";
+import type { WorkflowCommand } from "./workflow-commands";
+export declare function schemaTemplate(artifactType: ArtifactType): Record<string, unknown>;
+export declare function promptTemplate(artifactType: ArtifactType, lang?: string): string;
+export declare function artifactTemplateTemplate(artifactType: ArtifactType, lang?: string): string;
+export declare const START_BRIEF_TEMPLATE = "# Product Brief\n\n## Product Name\nExample Product\n\n## Problem\nDescribe the user problem.\n\n## Audience\nWho this product is for.\n\n## Core Features\n- Feature A\n- Feature B\n\n## Goals\n- Goal 1\n- Goal 2\n\n## Constraints\n- Budget or timeline constraints\n- Compliance or technical constraints\n";
+export declare const NORMALIZED_BRIEF_TEMPLATE: {
+    schema_version: string;
+    product_name: string;
+    problem: string;
+    audience: string[];
+    goals: string[];
+    core_features: string[];
+    constraints: string[];
+    assumptions: string[];
+    contracts: {
+        goals: {
+            id: string;
+            text: string;
+        }[];
+        core_features: {
+            id: string;
+            text: string;
+        }[];
+        constraints: {
+            id: string;
+            text: string;
+        }[];
+    };
+};
+export declare const NORMALIZE_PROMPT_TEMPLATE = "Normalize start-brief content into JSON.\n\nReturn JSON object with keys:\n- schema_version (string)\n- product_name (string)\n- problem (string)\n- audience (string[])\n- goals (string[])\n- core_features (string[])\n- constraints (string[])\n- assumptions (string[])\n- contracts.goals[] ({id,text})\n- contracts.core_features[] ({id,text})\n- contracts.constraints[] ({id,text})\n- confidence.product_name (0..1)\n- confidence.problem (0..1)\n- confidence.audience (0..1)\n- confidence.goals (0..1)\n- confidence.core_features (0..1)\n\nRules:\n- do NOT invent missing critical content\n- keep wording concise and concrete\n- preserve original language and Unicode characters exactly from brief\n- never transliterate Turkish letters (\u00E7, \u011F, \u0131, \u0130, \u00F6, \u015F, \u00FC) into ASCII\n- if critical field is missing, return empty and low confidence (<0.7)\n- assign deterministic IDs: goals => G1..Gn, features => F1..Fn, constraints => C1..Cn\n- input files are read-only; never modify, summarize, or rewrite `brief.md` in-place\n- write normalized output as a new JSON object only";
+export declare function commandTemplate(command: WorkflowCommand): string;
+export declare const HOOKS_TEMPLATE = "# Hook item fields:\n# - command: string (required)\n# - optional: boolean (default false)\n# - enabled: boolean (default true)\n# - condition: shell command; run hook only if condition exits 0\n# - timeout_ms: per-attempt timeout in milliseconds (default 30000)\n# - retry: extra retry count after first attempt (default 0)\n# - retry_delay_ms: delay between retries (default 500)\n#\n# Example:\n# hooks:\n#   before_prd:\n#     - command: \"node -e \\\"console.log('lint ok')\\\"\"\n#       optional: false\n#       enabled: true\n#       condition: \"node -e \\\"process.exit(0)\\\"\"\n#       timeout_ms: 15000\n#       retry: 1\n#       retry_delay_ms: 300\n\nhooks:\n  before_normalize: []\n  after_normalize: []\n  before_prd: []\n  after_prd: []\n  before_workflow: []\n  after_workflow: []\n  before_wireframe: []\n  after_wireframe: []\n  before_stories: []\n  after_stories: []\n  before_techspec: []\n  after_techspec: []\n  before_validate: []\n  after_validate: []\n";

package/dist/core/templates.js

@@ -0,0 +1,440 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HOOKS_TEMPLATE = exports.NORMALIZE_PROMPT_TEMPLATE = exports.NORMALIZED_BRIEF_TEMPLATE = exports.START_BRIEF_TEMPLATE = void 0;
+exports.schemaTemplate = schemaTemplate;
+exports.promptTemplate = promptTemplate;
+exports.artifactTemplateTemplate = artifactTemplateTemplate;
+exports.commandTemplate = commandTemplate;
+const constants_1 = require("./constants");
+const BASE_SCHEMA = {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    type: "object",
+    required: ["frontmatter", "body"],
+    properties: {
+        frontmatter: {
+            type: "object",
+            required: ["artifact_type", "version", "source_brief", "generated_at", "status"],
+            properties: {
+                artifact_type: { type: "string" },
+                version: { type: "string", minLength: 1 },
+                source_brief: { type: "string", minLength: 1 },
+                generated_at: { type: "string", format: "date-time" },
+                status: { type: "string", enum: ["draft", "reviewed", "approved"] },
+                title: { type: "string" },
+                upstream_artifacts: {
+                    type: "array",
+                    items: { type: "string" }
+                },
+                contract_coverage: {
+                    type: "object",
+                    required: ["goals", "core_features", "constraints"],
+                    properties: {
+                        goals: { type: "array", items: { type: "string", pattern: "^G[0-9]+$" } },
+                        core_features: { type: "array", items: { type: "string", pattern: "^F[0-9]+$" } },
+                        constraints: { type: "array", items: { type: "string", pattern: "^C[0-9]+$" } }
+                    },
+                    additionalProperties: false
+                }
+            },
+            additionalProperties: true
+        },
+        body: {
+            type: "string",
+            minLength: 40
+        }
+    },
+    additionalProperties: false
+};
+function schemaTemplate(artifactType) {
+    return {
+        ...BASE_SCHEMA,
+        properties: {
+            ...BASE_SCHEMA.properties,
+            frontmatter: {
+                ...BASE_SCHEMA.properties.frontmatter,
+                properties: {
+                    ...BASE_SCHEMA.properties.frontmatter
+                        .properties,
+                    artifact_type: { const: artifactType }
+                }
+            }
+        },
+        x_required_headings: (0, constants_1.defaultRequiredHeadings)(artifactType)
+    };
+}
+function promptTemplate(artifactType, lang = "en") {
+    const tr = lang.toLowerCase().startsWith("tr");
+    if (artifactType === "workflow") {
+        return `You are Prodo's artifact generator for WORKFLOW.
+
+Goal:
+- Produce paired workflow outputs for the same flow.
+
+Output contract (STRICT):
+- Return Markdown explanation first (no frontmatter), following required headings exactly.
+- Include actionable flow details and contract tags like [F1].
+- Then append a mandatory Mermaid block for the same flow:
+\`\`\`mermaid
+flowchart TD
+  A --> B
+\`\`\`
+- Do not return prose-only markdown without Mermaid.
+
+Input immutability:
+- Input files are read-only.
+- Do not modify, rewrite, summarize, or optimize \`brief.md\`.
+
+Language contract:
+- Output text in requested language from inputContext.outputLanguage.
+- If outputLanguage is "tr", every sentence and heading MUST be Turkish.
+- Never mix Turkish and English in the same artifact.
+
+Quality bar:
+- Main flow must be implementation-ready.
+- Edge cases and postconditions must be explicit.`;
+    }
+    if (artifactType === "wireframe") {
+        return `You are Prodo's artifact generator for WIREFRAME.
+
+Goal:
+- Produce a human-readable wireframe explanation in Markdown.
+
+Output contract (STRICT):
+- Return Markdown body only (no frontmatter).
+- Include all required headings exactly as provided.
+- Describe one concrete screen at a time with actionable details.
+- HTML wireframe is generated by Prodo as a companion .html file; do not output raw HTML as primary markdown body.
+
+Input immutability:
+- Input files are read-only.
+- Do not modify, rewrite, summarize, or optimize \`brief.md\`.
+
+Language contract:
+- Output text in requested language from inputContext.outputLanguage.
+- If outputLanguage is "tr", every sentence and heading MUST be Turkish.
+- Never mix Turkish and English in the same artifact.
+
+Quality bar:
+- Keep sections concise but specific.
+- Ensure actions/states/messages are testable and implementation-relevant.`;
+    }
+    return `You are Prodo's artifact generator for ${artifactType.toUpperCase()}.
+
+Goal:
+- Produce a decision-ready product artifact from normalized brief and upstream artifacts.
+
+Output contract:
+- Return only Markdown body (NO YAML frontmatter).
+- Keep all required section headings exactly as provided.
+- When referencing brief contracts, use explicit tags like [G1], [F2], [C1].
+- Use concrete statements, avoid placeholders like "TBD" unless unavoidable.
+- Reference upstream constraints and tradeoffs explicitly.
+
+Input immutability:
+- Input files are read-only.
+- Do not modify, rewrite, summarize, or optimize \`brief.md\`.
+
+Language contract:
+- Output text in requested language from inputContext.outputLanguage.
+- If outputLanguage is "tr", every sentence and heading MUST be Turkish.
+- Never mix Turkish and English in the same artifact.
+- Do not translate or change required headings unless outputLanguage is "tr" and Turkish headings are provided.
+
+Quality bar:
+- Every section must contain actionable content.
+- Include assumptions and risks where relevant.
+- Keep content concise but implementation-ready.
+
+Required headings:
+${(0, constants_1.defaultRequiredHeadings)(artifactType).map((heading) => `- ${heading}`).join("\n")}
+
+When data is missing:
+${tr ? "- varsayim yaparken Turkce yaz\n- varsayimi ilgili bolumde acikca belirt" : "- infer a sensible default\n- state the assumption clearly in the relevant section"}`;
+}
+function artifactTemplateTemplate(artifactType, lang = "en") {
+    const tr = lang.toLowerCase().startsWith("tr");
+    const base = [`# ${artifactType.toUpperCase()} Template`, ""];
+    if (artifactType === "prd") {
+        return [
+            ...base,
+            "## Problem",
+            "- User pain and why now",
+            "- Existing workaround and gap",
+            "",
+            "## Goals",
+            "- Business goals (measurable)",
+            "- User outcomes",
+            "",
+            "## Scope",
+            "- In scope",
+            "- Out of scope",
+            "",
+            "## Requirements",
+            "- Functional requirements",
+            "- Non-functional requirements",
+            "- Compliance/security requirements",
+            "",
+            "## Risks",
+            "- Top risks and mitigations",
+            "",
+            "## Assumptions",
+            "- Key assumptions"
+        ].join("\n");
+    }
+    if (artifactType === "workflow") {
+        return [
+            "flowchart TD",
+            `  A[${tr ? "Baslangic" : "Start"}] --> B[[F1] ${tr ? "Kullanici islemi" : "User action"}]`,
+            `  B --> C[${tr ? "Sistem islemi" : "System process"}]`,
+            `  C --> D[${tr ? "Basari" : "Success"}]`,
+            `  C --> E[${tr ? "Hata" : "Error"}]`
+        ].join("\n");
+    }
+    if (artifactType === "wireframe") {
+        return `<!doctype html>
+<html lang="${tr ? "tr" : "en"}">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>${tr ? "Wireframe Ekrani" : "Wireframe Screen"}</title>
+</head>
+<body>
+  <header>
+    <h1>${tr ? "Ekran Basligi" : "Screen Title"}</h1>
+    <nav>
+      <button type="button">${tr ? "Geri" : "Back"}</button>
+      <button type="button">${tr ? "Devam" : "Next"}</button>
+    </nav>
+  </header>
+  <main>
+    <section>
+      <h2>${tr ? "Birincil Icerik" : "Primary Content"}</h2>
+      <ul>
+        <li>${tr ? "Durum ozeti" : "Status summary"}</li>
+        <li>${tr ? "Aksiyon alani" : "Action area"}</li>
+      </ul>
+    </section>
+    <section>
+      <h2>${tr ? "Form" : "Form"}</h2>
+      <form>
+        <label>${tr ? "Alan" : "Field"} <input type="text" /></label>
+        <button type="submit">${tr ? "Kaydet" : "Save"}</button>
+      </form>
+    </section>
+  </main>
+</body>
+</html>`;
+    }
+    if (artifactType === "stories") {
+        return [
+            ...base,
+            "## User Stories",
+            "- As a <user>, I want <goal>, so that <benefit>",
+            "",
+            "## Acceptance Criteria",
+            "- Given / When / Then criteria",
+            "- Negative and edge scenarios",
+            "",
+            "## Traceability",
+            "- Map each story to PRD requirement"
+        ].join("\n");
+    }
+    if (artifactType === "techspec") {
+        return [
+            ...base,
+            "## Architecture",
+            "- High-level components and boundaries",
+            "",
+            "## Data Model",
+            "- Entities, fields, relations",
+            "",
+            "## APIs",
+            "- Endpoints/interfaces and contracts",
+            "",
+            "## Risks",
+            "- Technical risks and mitigation",
+            "",
+            "## Observability",
+            "- Logs, metrics, alerts"
+        ].join("\n");
+    }
+    const fallbackTemplate = [
+        ...base,
+        tr ? "## Ozet" : "## Summary",
+        tr ? "- Ana amac ve beklenen cikti" : "- Core intent and outcomes",
+        "",
+        tr ? "## Detaylar" : "## Details",
+        tr ? "- Kararlar, varsayimlar ve riskler" : "- Key decisions, assumptions, and risks",
+        "",
+        tr ? "## Izlenebilirlik" : "## Traceability",
+        tr ? "- Kararlari kontrat etiketleri ile eslestir" : "- Link decisions to contract tags"
+    ].join("\n");
+    return fallbackTemplate;
+}
+exports.START_BRIEF_TEMPLATE = `# Product Brief
+
+## Product Name
+Example Product
+
+## Problem
+Describe the user problem.
+
+## Audience
+Who this product is for.
+
+## Core Features
+- Feature A
+- Feature B
+
+## Goals
+- Goal 1
+- Goal 2
+
+## Constraints
+- Budget or timeline constraints
+- Compliance or technical constraints
+`;
+exports.NORMALIZED_BRIEF_TEMPLATE = {
+    schema_version: "1.0",
+    product_name: "Example Product",
+    problem: "Describe the user problem clearly.",
+    audience: ["Primary users"],
+    goals: ["Goal 1", "Goal 2"],
+    core_features: ["Feature A", "Feature B"],
+    constraints: ["Constraint 1"],
+    assumptions: ["Assumption 1"],
+    contracts: {
+        goals: [
+            { id: "G1", text: "Goal 1" },
+            { id: "G2", text: "Goal 2" }
+        ],
+        core_features: [
+            { id: "F1", text: "Feature A" },
+            { id: "F2", text: "Feature B" }
+        ],
+        constraints: [{ id: "C1", text: "Constraint 1" }]
+    }
+};
+exports.NORMALIZE_PROMPT_TEMPLATE = `Normalize start-brief content into JSON.
+
+Return JSON object with keys:
+- schema_version (string)
+- product_name (string)
+- problem (string)
+- audience (string[])
+- goals (string[])
+- core_features (string[])
+- constraints (string[])
+- assumptions (string[])
+- contracts.goals[] ({id,text})
+- contracts.core_features[] ({id,text})
+- contracts.constraints[] ({id,text})
+- confidence.product_name (0..1)
+- confidence.problem (0..1)
+- confidence.audience (0..1)
+- confidence.goals (0..1)
+- confidence.core_features (0..1)
+
+Rules:
+- do NOT invent missing critical content
+- keep wording concise and concrete
+- preserve original language and Unicode characters exactly from brief
+- never transliterate Turkish letters (ç, ğ, ı, İ, ö, ş, ü) into ASCII
+- if critical field is missing, return empty and low confidence (<0.7)
+- assign deterministic IDs: goals => G1..Gn, features => F1..Fn, constraints => C1..Cn
+- input files are read-only; never modify, summarize, or rewrite \`brief.md\` in-place
+- write normalized output as a new JSON object only`;
+function commandTemplate(command) {
+    const normalizeJsonGuard = command.cliSubcommand === "normalize"
+        ? `
+- Normalize output format check:
+  - \`.prodo/briefs/normalized-brief.json\` must be strict JSON object (no markdown fences).
+  - If invalid, rewrite file as pure JSON object only.`
+        : "";
+    return `---
+description: ${command.description}
+handoffs:
+  - label: Continue Workflow
+    agent: prodo-next
+    prompt: Continue with the next Prodo command in sequence.
+    send: true
+---
+
+## User Input
+
+\`\`\`text
+$ARGUMENTS
+\`\`\`
+
+Execution policy:
+- Execute-first, diagnose-second.
+- Perform only minimal prerequisite checks before execution.
+- Do not run shell commands or CLI commands from inside the agent.
+- Never run \`prodo-${command.cliSubcommand}\`, \`prodo ${command.cliSubcommand}\`, or \`prodo ...\` in shell.
+- Do not inspect hooks or internals unless command execution fails.
+- Input files are read-only; never modify or rewrite \`brief.md\`.
+- Never print full artifact content in chat.
+- Write/update files first, then reply with short status + written file path(s).
+
+## Execution
+
+1. Minimal prerequisites only:
+- Confirm project is initialized (\`.prodo/\` exists).
+- Confirm required input files for \`${command.cliSubcommand}\` exist.
+- Confirm output location is writable.
+
+2. Execute immediately:
+- Execute the \`${command.cliSubcommand}\` process directly using workspace files and Prodo rules.
+- Keep narration short and action-oriented.
+
+3. Verify result:
+- Confirm expected output file(s) were created/updated under \`product-docs/\` (or \`.prodo/briefs\` for normalize).
+- Confirm command success state (exit code or validation status).
+- Confirm \`brief.md\` hash/content did not change.
+- Do NOT create manual fallback files under \`.prodo/artifact\` or any ad-hoc folder.
+${normalizeJsonGuard}
+
+4. Diagnose only on failure:
+- Inspect \`.prodo/hooks.yml\` only after execution failure.
+- Explain root cause and next fix steps briefly.
+
+## Handoff
+
+Suggest the next slash command explicitly (for example: \`/prodo-prd\`, \`/prodo-workflow\`).`;
+}
+exports.HOOKS_TEMPLATE = `# Hook item fields:
+# - command: string (required)
+# - optional: boolean (default false)
+# - enabled: boolean (default true)
+# - condition: shell command; run hook only if condition exits 0
+# - timeout_ms: per-attempt timeout in milliseconds (default 30000)
+# - retry: extra retry count after first attempt (default 0)
+# - retry_delay_ms: delay between retries (default 500)
+#
+# Example:
+# hooks:
+#   before_prd:
+#     - command: "node -e \\"console.log('lint ok')\\""
+#       optional: false
+#       enabled: true
+#       condition: "node -e \\"process.exit(0)\\""
+#       timeout_ms: 15000
+#       retry: 1
+#       retry_delay_ms: 300
+
+hooks:
+  before_normalize: []
+  after_normalize: []
+  before_prd: []
+  after_prd: []
+  before_workflow: []
+  after_workflow: []
+  before_wireframe: []
+  after_wireframe: []
+  before_stories: []
+  after_stories: []
+  before_techspec: []
+  after_techspec: []
+  before_validate: []
+  after_validate: []
+`;

package/dist/core/terminology.d.ts

@@ -0,0 +1,21 @@
+import type { NormalizedBrief } from "./normalized-brief";
+import type { ArtifactDoc, ArtifactType, ValidationIssue } from "./types";
+type LoadedArtifact = {
+    type: ArtifactType;
+    file: string;
+    doc: ArtifactDoc;
+};
+export type TermEntry = {
+    term: string;
+    normalizedTerm: string;
+    definition?: string;
+    sources: Array<{
+        artifactType: ArtifactType | "brief";
+        file: string;
+        heading?: string;
+    }>;
+};
+export type TermMap = Map<string, TermEntry>;
+export declare function buildTermMap(normalizedBrief: NormalizedBrief, loadedArtifacts: LoadedArtifact[]): TermMap;
+export declare function checkTermReconciliation(termMap: TermMap): ValidationIssue[];
+export {};

package/dist/core/terminology.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTermMap = buildTermMap;
+exports.checkTermReconciliation = checkTermReconciliation;
+const markdown_1 = require("./markdown");
+function normalizeTerm(term) {
+    return term
+        .toLowerCase()
+        .replace(/[^a-z0-9\u00c0-\u024f\s]/g, "")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function extractBoldTerms(body) {
+    const matches = body.match(/\*\*([^*]+)\*\*/g) ?? [];
+    return matches
+        .map((m) => m.replace(/\*\*/g, "").trim())
+        .filter((t) => t.length > 2 && t.length < 60);
+}
+function buildTermMap(normalizedBrief, loadedArtifacts) {
+    const termMap = new Map();
+    function addTerm(term, source, definition) {
+        const normalized = normalizeTerm(term);
+        if (!normalized || normalized.length < 2)
+            return;
+        const existing = termMap.get(normalized);
+        if (existing) {
+            existing.sources.push(source);
+            if (definition && !existing.definition) {
+                existing.definition = definition;
+            }
+        }
+        else {
+            termMap.set(normalized, {
+                term,
+                normalizedTerm: normalized,
+                definition,
+                sources: [source]
+            });
+        }
+    }
+    addTerm(normalizedBrief.product_name, { artifactType: "brief", file: "brief.md" });
+    for (const goal of normalizedBrief.goals) {
+        addTerm(goal, { artifactType: "brief", file: "brief.md" }, goal);
+    }
+    for (const feature of normalizedBrief.core_features) {
+        addTerm(feature, { artifactType: "brief", file: "brief.md" }, feature);
+    }
+    for (const constraint of normalizedBrief.constraints) {
+        addTerm(constraint, { artifactType: "brief", file: "brief.md" }, constraint);
+    }
+    for (const contract of normalizedBrief.contracts.goals) {
+        addTerm(contract.text, { artifactType: "brief", file: "brief.md" }, contract.text);
+    }
+    for (const contract of normalizedBrief.contracts.core_features) {
+        addTerm(contract.text, { artifactType: "brief", file: "brief.md" }, contract.text);
+    }
+    for (const contract of normalizedBrief.contracts.constraints) {
+        addTerm(contract.text, { artifactType: "brief", file: "brief.md" }, contract.text);
+    }
+    for (const artifact of loadedArtifacts) {
+        const sections = (0, markdown_1.parseMarkdownSections)(artifact.doc.body);
+        for (const section of sections) {
+            if (section.level === 2) {
+                addTerm(section.heading, {
+                    artifactType: artifact.type,
+                    file: artifact.file,
+                    heading: section.heading
+                });
+            }
+        }
+        const boldTerms = extractBoldTerms(artifact.doc.body);
+        for (const boldTerm of boldTerms) {
+            addTerm(boldTerm, { artifactType: artifact.type, file: artifact.file });
+        }
+    }
+    return termMap;
+}
+function levenshtein(a, b) {
+    const m = a.length;
+    const n = b.length;
+    if (m === 0)
+        return n;
+    if (n === 0)
+        return m;
+    const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+    for (let i = 0; i <= m; i++)
+        dp[i][0] = i;
+    for (let j = 0; j <= n; j++)
+        dp[0][j] = j;
+    for (let i = 1; i <= m; i++) {
+        for (let j = 1; j <= n; j++) {
+            dp[i][j] = a[i - 1] === b[j - 1]
+                ? dp[i - 1][j - 1]
+                : 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
+        }
+    }
+    return dp[m][n];
+}
+function sharesStem(a, b) {
+    const wordsA = a.split(/\s+/).filter((w) => w.length > 3);
+    const wordsB = b.split(/\s+/).filter((w) => w.length > 3);
+    for (const wa of wordsA) {
+        for (const wb of wordsB) {
+            const shorter = Math.min(wa.length, wb.length);
+            const prefix = Math.min(4, shorter);
+            if (wa.slice(0, prefix) === wb.slice(0, prefix) && wa !== wb) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function checkTermReconciliation(termMap) {
+    const issues = [];
+    const entries = Array.from(termMap.values()).filter((e) => e.sources.length > 0 && e.normalizedTerm.length > 3);
+    for (let i = 0; i < entries.length; i++) {
+        for (let j = i + 1; j < entries.length; j++) {
+            const a = entries[i];
+            const b = entries[j];
+            if (a.normalizedTerm === b.normalizedTerm)
+                continue;
+            const dist = levenshtein(a.normalizedTerm, b.normalizedTerm);
+            const maxLen = Math.max(a.normalizedTerm.length, b.normalizedTerm.length);
+            const ratio = dist / maxLen;
+            const isSimilar = (ratio < 0.25 && maxLen > 5) || sharesStem(a.normalizedTerm, b.normalizedTerm);
+            if (isSimilar) {
+                const aTypes = [...new Set(a.sources.map((s) => s.artifactType))];
+                const bTypes = [...new Set(b.sources.map((s) => s.artifactType))];
+                const crossDoc = aTypes.some((t) => !bTypes.includes(t)) || bTypes.some((t) => !aTypes.includes(t));
+                if (crossDoc) {
+                    issues.push({
+                        level: "warning",
+                        code: "term_inconsistency",
+                        check: "terminology",
+                        message: `Similar terms used across documents: "${a.term}" (${aTypes.join(", ")}) vs "${b.term}" (${bTypes.join(", ")})`,
+                        suggestion: "Standardize terminology across all artifacts to avoid ambiguity."
+                    });
+                }
+            }
+        }
+    }
+    return issues;
+}