@deftai/directive-core 0.55.0

package/dist/vbrief-validate/project-definition.js

@@ -0,0 +1,166 @@
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { pyStrRepr } from "../triage/scope/python-repr.js";
+import { isRelativeTo, resolveRefPath, scopeIdsForRefUri } from "./paths.js";
+import { runProjectDefinitionHooks } from "./plan-hooks.js";
+import { validateProjectDefNarratives } from "./schema.js";
+function itemLocalScopeUris(item, plan) {
+    const uris = [];
+    const metadata = item.metadata;
+    if (typeof metadata === "object" && metadata !== null && !Array.isArray(metadata)) {
+        const meta = metadata;
+        const sourcePath = meta.source_path;
+        if (typeof sourcePath === "string" && sourcePath) {
+            uris.push(sourcePath);
+        }
+        const metadataRefs = meta.references;
+        if (Array.isArray(metadataRefs)) {
+            for (const ref of metadataRefs) {
+                if (typeof ref === "object" &&
+                    ref !== null &&
+                    !Array.isArray(ref) &&
+                    ref.type === "x-vbrief/plan") {
+                    const uri = ref.uri;
+                    if (typeof uri === "string" && uri) {
+                        uris.push(uri);
+                    }
+                }
+            }
+        }
+    }
+    const refs = item.references;
+    if (Array.isArray(refs)) {
+        for (const ref of refs) {
+            if (typeof ref === "object" &&
+                ref !== null &&
+                !Array.isArray(ref) &&
+                ref.type === "x-vbrief/plan") {
+                const uri = ref.uri;
+                if (typeof uri === "string" && uri) {
+                    uris.push(uri);
+                }
+            }
+        }
+    }
+    const itemId = item.id;
+    const itemTitle = item.title;
+    const planRefs = plan.references;
+    if (Array.isArray(planRefs)) {
+        for (const ref of planRefs) {
+            if (typeof ref !== "object" || ref === null || Array.isArray(ref)) {
+                continue;
+            }
+            const refObj = ref;
+            if (refObj.type !== "x-vbrief/plan") {
+                continue;
+            }
+            const uri = refObj.uri;
+            if (typeof uri !== "string" || !uri) {
+                continue;
+            }
+            const titleMatches = typeof itemTitle === "string" && refObj.title === itemTitle;
+            const idMatches = typeof itemId === "string" && scopeIdsForRefUri(uri).has(itemId);
+            if (titleMatches || idMatches) {
+                uris.push(uri);
+            }
+        }
+    }
+    return [...new Set(uris)];
+}
+function validateProjectRegistryScopeStatus(item, itemIndex, plan, filepath, vbriefDir) {
+    const errors = [];
+    const itemStatus = item.status;
+    if (typeof itemStatus !== "string") {
+        return errors;
+    }
+    const resolvedRoot = resolve(vbriefDir);
+    for (const uri of itemLocalScopeUris(item, plan)) {
+        if (uri.startsWith("http://") || uri.startsWith("https://") || uri.startsWith("#")) {
+            continue;
+        }
+        const scopePath = resolveRefPath(uri, vbriefDir);
+        if (scopePath === null) {
+            continue;
+        }
+        if (!isRelativeTo(scopePath, resolvedRoot) || !existsSync(scopePath)) {
+            continue;
+        }
+        let scopeData;
+        try {
+            scopeData = JSON.parse(readFileSync(scopePath, "utf8"));
+        }
+        catch {
+            continue;
+        }
+        const scopePlan = scopeData.plan;
+        if (typeof scopePlan !== "object" || scopePlan === null || Array.isArray(scopePlan)) {
+            continue;
+        }
+        const scopeStatus = scopePlan.status;
+        if (typeof scopeStatus === "string" && scopeStatus !== itemStatus) {
+            errors.push(`${filepath}: items[${itemIndex}] status is ${pyStrRepr(itemStatus)} ` +
+                `but referenced scope '${uri}' has plan.status ${pyStrRepr(scopeStatus)} ` +
+                "(D3 registry-status)");
+        }
+    }
+    return errors;
+}
+/** Validate PROJECT-DEFINITION.vbrief.json specific requirements (D3). */
+export function validateProjectDefinition(filepath, data, vbriefDir) {
+    const errors = [];
+    const resolvedRoot = resolve(vbriefDir);
+    const plan = data.plan;
+    if (typeof plan !== "object" || plan === null || Array.isArray(plan)) {
+        return errors;
+    }
+    const planObj = plan;
+    errors.push(...validateProjectDefNarratives(filepath, planObj));
+    errors.push(...runProjectDefinitionHooks(planObj, filepath));
+    const items = planObj.items;
+    if (Array.isArray(items)) {
+        for (let i = 0; i < items.length; i += 1) {
+            const item = items[i];
+            if (typeof item !== "object" || item === null || Array.isArray(item)) {
+                continue;
+            }
+            const itemObj = item;
+            errors.push(...validateProjectRegistryScopeStatus(itemObj, i, planObj, filepath, vbriefDir));
+            const rawRefs = itemObj.references;
+            const refs = Array.isArray(rawRefs) ? rawRefs : [];
+            for (const ref of refs) {
+                if (typeof ref !== "object" || ref === null || Array.isArray(ref)) {
+                    continue;
+                }
+                const refObj = ref;
+                const uriRaw = refObj.uri;
+                const uri = typeof uriRaw === "string" ? uriRaw : "";
+                if (uri && uri.startsWith("file://")) {
+                    const refPath = uri.replace("file://", "");
+                    const fullPath = resolve(vbriefDir, refPath);
+                    if (!isRelativeTo(fullPath, resolvedRoot)) {
+                        errors.push(`${filepath}: items[${i}] references ` + `'${refPath}' outside vbrief directory (D3)`);
+                        continue;
+                    }
+                    if (!existsSync(fullPath)) {
+                        errors.push(`${filepath}: items[${i}] references ` + `'${refPath}' which does not exist (D3)`);
+                    }
+                }
+                else if (uri &&
+                    !uri.startsWith("http://") &&
+                    !uri.startsWith("https://") &&
+                    !uri.startsWith("#")) {
+                    const fullPath = resolve(vbriefDir, uri);
+                    if (!isRelativeTo(fullPath, resolvedRoot)) {
+                        errors.push(`${filepath}: items[${i}] references ` + `'${uri}' outside vbrief directory (D3)`);
+                        continue;
+                    }
+                    if (!existsSync(fullPath)) {
+                        errors.push(`${filepath}: items[${i}] references '${uri}' which does not exist (D3)`);
+                    }
+                }
+            }
+        }
+    }
+    return errors;
+}
+//# sourceMappingURL=project-definition.js.map

package/dist/vbrief-validate/schema.d.ts

@@ -0,0 +1,8 @@
+export type JsonObject = Record<string, unknown>;
+/** Validate vBRIEF structural requirements (v0.6). */
+export declare function validateVbriefSchema(data: JsonObject, filepath: string): string[];
+/** Normalize a narrative key for D3 comparison. */
+export declare function normalizeNarrativeKey(key: string): string;
+/** Check expected PROJECT-DEFINITION narrative keys (D3). */
+export declare function validateProjectDefNarratives(filepath: string, plan: JsonObject): string[];
+//# sourceMappingURL=schema.d.ts.map

package/dist/vbrief-validate/schema.js

@@ -0,0 +1,150 @@
+import { pyStrRepr, pythonTypeName } from "../triage/scope/python-repr.js";
+import { PROJECT_DEF_EXPECTED_NARRATIVES, VALID_STATUSES, VALID_VBRIEF_VERSIONS, } from "./constants.js";
+function validateNarratives(narratives, path, errors) {
+    if (typeof narratives !== "object" || narratives === null || Array.isArray(narratives)) {
+        errors.push(`${path} must be an object`);
+        return;
+    }
+    for (const [key, value] of Object.entries(narratives)) {
+        if (typeof value !== "string") {
+            errors.push(`${path}.${key} must be a string, got ${pythonTypeName(value)}`);
+        }
+    }
+}
+function validatePlanItem(item, path, errors) {
+    const itemId = typeof item.id === "string" ? item.id : "<no-id>";
+    const itemPath = `${path}[${itemId}]`;
+    if (!("title" in item)) {
+        errors.push(`${itemPath} missing 'title'`);
+    }
+    if (!("status" in item)) {
+        errors.push(`${itemPath} missing 'status'`);
+    }
+    else if (!VALID_STATUSES.has(String(item.status))) {
+        errors.push(`${itemPath} invalid status: ${pyStrRepr(String(item.status))}`);
+    }
+    if ("narrative" in item) {
+        validateNarratives(item.narrative, `${itemPath}.narrative`, errors);
+    }
+    if ("items" in item) {
+        if (!Array.isArray(item.items)) {
+            errors.push(`${itemPath}.items must be an array`);
+        }
+        else {
+            for (let j = 0; j < item.items.length; j += 1) {
+                const sub = item.items[j];
+                if (typeof sub !== "object" || sub === null || Array.isArray(sub)) {
+                    errors.push(`${itemPath}.items[${j}] must be an object`);
+                    continue;
+                }
+                validatePlanItem(sub, `${itemPath}.items`, errors);
+            }
+        }
+    }
+    if ("subItems" in item) {
+        if (!Array.isArray(item.subItems)) {
+            errors.push(`${itemPath}.subItems must be an array`);
+        }
+        else {
+            for (let j = 0; j < item.subItems.length; j += 1) {
+                const sub = item.subItems[j];
+                if (typeof sub !== "object" || sub === null || Array.isArray(sub)) {
+                    errors.push(`${itemPath}.subItems[${j}] must be an object`);
+                    continue;
+                }
+                validatePlanItem(sub, `${itemPath}.subItems`, errors);
+            }
+        }
+    }
+}
+/** Validate vBRIEF structural requirements (v0.6). */
+export function validateVbriefSchema(data, filepath) {
+    const errors = [];
+    if (!("vBRIEFInfo" in data)) {
+        errors.push(`${filepath}: missing required top-level key 'vBRIEFInfo'`);
+    }
+    else {
+        const info = data.vBRIEFInfo;
+        if (typeof info !== "object" || info === null || Array.isArray(info)) {
+            errors.push(`${filepath}: 'vBRIEFInfo' must be an object`);
+        }
+        else {
+            const version = info.version;
+            if (!VALID_VBRIEF_VERSIONS.has(String(version))) {
+                errors.push(`${filepath}: 'vBRIEFInfo.version' must be '0.6' ` +
+                    `(canonical v0.6 schema, #533), got ` +
+                    `${pyStrRepr(String(version))}. Run \`task migrate:vbrief\` to ` +
+                    `upgrade pre-existing v0.5 vBRIEFs in-place.`);
+            }
+        }
+    }
+    if (!("plan" in data)) {
+        errors.push(`${filepath}: missing required top-level key 'plan'`);
+    }
+    else {
+        const plan = data.plan;
+        if (typeof plan !== "object" || plan === null || Array.isArray(plan)) {
+            errors.push(`${filepath}: 'plan' must be an object`);
+        }
+        else {
+            const planObj = plan;
+            for (const field of ["title", "status", "items"]) {
+                if (!(field in planObj)) {
+                    errors.push(`${filepath}: 'plan' missing required field '${field}'`);
+                }
+            }
+            if ("title" in planObj && (typeof planObj.title !== "string" || !planObj.title)) {
+                errors.push(`${filepath}: 'plan.title' must be a non-empty string`);
+            }
+            if ("status" in planObj && !VALID_STATUSES.has(String(planObj.status))) {
+                const sorted = [...VALID_STATUSES]
+                    .sort()
+                    .map((s) => `'${s}'`)
+                    .join(", ");
+                errors.push(`${filepath}: 'plan.status' invalid: ${pyStrRepr(String(planObj.status))} ` +
+                    `(expected one of [${sorted}])`);
+            }
+            if ("narratives" in planObj) {
+                validateNarratives(planObj.narratives, `${filepath}: plan.narratives`, errors);
+            }
+            if ("items" in planObj) {
+                if (!Array.isArray(planObj.items)) {
+                    errors.push(`${filepath}: 'plan.items' must be an array`);
+                }
+                else {
+                    for (let i = 0; i < planObj.items.length; i += 1) {
+                        const item = planObj.items[i];
+                        if (typeof item !== "object" || item === null || Array.isArray(item)) {
+                            errors.push(`${filepath}: plan.items[${i}] must be an object`);
+                            continue;
+                        }
+                        validatePlanItem(item, `${filepath}: plan.items`, errors);
+                    }
+                }
+            }
+        }
+    }
+    return errors;
+}
+/** Normalize a narrative key for D3 comparison. */
+export function normalizeNarrativeKey(key) {
+    return (key ?? "").toLowerCase().replace(/[\s_-]+/g, "");
+}
+/** Check expected PROJECT-DEFINITION narrative keys (D3). */
+export function validateProjectDefNarratives(filepath, plan) {
+    const errors = [];
+    // Mirror Python ``plan.get("narratives", {})`` -- a missing ``narratives``
+    // key defaults to an empty object, which still triggers the
+    // "missing expected key" D3 diagnostics (parity with validate_all).
+    const narratives = "narratives" in plan ? plan.narratives : {};
+    if (typeof narratives === "object" && narratives !== null && !Array.isArray(narratives)) {
+        const present = new Set(Object.keys(narratives).map((key) => normalizeNarrativeKey(key)));
+        for (const expected of PROJECT_DEF_EXPECTED_NARRATIVES) {
+            if (!present.has(expected)) {
+                errors.push(`${filepath}: narratives missing expected key '${expected}' (D3)`);
+            }
+        }
+    }
+    return errors;
+}
+//# sourceMappingURL=schema.js.map

package/dist/vbrief-validate/staleness.d.ts

@@ -0,0 +1,3 @@
+/** Warn if PRD.md or SPECIFICATION.md are stale relative to specification.vbrief.json (#398). */
+export declare function checkRenderStaleness(vbriefDir: string): string[];
+//# sourceMappingURL=staleness.d.ts.map

package/dist/vbrief-validate/staleness.js

@@ -0,0 +1,106 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { isCurrentGeneratedSpecification, isDeprecationRedirect } from "./precutover.js";
+function checkPrdStaleness(prdPath, narratives, title) {
+    let content;
+    try {
+        content = readFileSync(prdPath, "utf8");
+    }
+    catch {
+        return [];
+    }
+    if (Object.keys(narratives).length === 0) {
+        return [];
+    }
+    for (const value of Object.values(narratives)) {
+        if (typeof value === "string" && value.trim() && !content.includes(value.trim())) {
+            return [
+                "PRD.md may be stale relative to " +
+                    "vbrief/specification.vbrief.json -- " +
+                    "run `task prd:render` to refresh",
+            ];
+        }
+    }
+    if (title && !content.includes(title)) {
+        return [
+            "PRD.md may be stale relative to " +
+                "vbrief/specification.vbrief.json -- " +
+                "run `task prd:render` to refresh",
+        ];
+    }
+    return [];
+}
+function checkSpecStaleness(specMdPath, narratives, items, title) {
+    let content;
+    try {
+        content = readFileSync(specMdPath, "utf8");
+    }
+    catch {
+        return [];
+    }
+    const projectRoot = join(specMdPath, "..");
+    if (isDeprecationRedirect(content) || isCurrentGeneratedSpecification(projectRoot, content)) {
+        return [];
+    }
+    const msg = "SPECIFICATION.md may be stale relative to " +
+        "vbrief/specification.vbrief.json -- " +
+        "run `task spec:render` to refresh";
+    if (Array.isArray(items)) {
+        for (const item of items) {
+            if (typeof item !== "object" || item === null || Array.isArray(item)) {
+                continue;
+            }
+            const itemTitle = item.title;
+            if (typeof itemTitle === "string" && itemTitle && !content.includes(itemTitle)) {
+                return [msg];
+            }
+        }
+    }
+    for (const value of Object.values(narratives)) {
+        if (typeof value === "string" && value.trim() && !content.includes(value.trim())) {
+            return [msg];
+        }
+    }
+    if (title && !content.includes(title)) {
+        return [msg];
+    }
+    return [];
+}
+/** Warn if PRD.md or SPECIFICATION.md are stale relative to specification.vbrief.json (#398). */
+export function checkRenderStaleness(vbriefDir) {
+    const warnings = [];
+    const projectRoot = join(vbriefDir, "..");
+    const specPath = join(vbriefDir, "specification.vbrief.json");
+    if (!existsSync(specPath)) {
+        return warnings;
+    }
+    let data;
+    try {
+        data = JSON.parse(readFileSync(specPath, "utf8"));
+    }
+    catch {
+        return warnings;
+    }
+    const plan = data.plan;
+    if (typeof plan !== "object" || plan === null || Array.isArray(plan)) {
+        return warnings;
+    }
+    const planObj = plan;
+    const narratives = typeof planObj.narratives === "object" &&
+        planObj.narratives !== null &&
+        !Array.isArray(planObj.narratives)
+        ? planObj.narratives
+        : {};
+    const items = Array.isArray(planObj.items) ? planObj.items : [];
+    const title = typeof planObj.title === "string" ? planObj.title : "";
+    const prdPath = join(projectRoot, "PRD.md");
+    if (existsSync(prdPath)) {
+        warnings.push(...checkPrdStaleness(prdPath, narratives, title));
+    }
+    const specMdPath = join(projectRoot, "SPECIFICATION.md");
+    if (existsSync(specMdPath)) {
+        warnings.push(...checkSpecStaleness(specMdPath, narratives, items, title));
+    }
+    return warnings;
+}
+//# sourceMappingURL=staleness.js.map

package/dist/vbrief-validate/validate-all.d.ts

@@ -0,0 +1,17 @@
+export interface ValidateAllResult {
+    readonly errors: readonly string[];
+    readonly warnings: readonly string[];
+    readonly scopeCount: number;
+}
+/** Find all .vbrief.json files in lifecycle folders. */
+export declare function discoverVbriefs(vbriefDir: string): Array<{
+    display: string;
+    absolute: string;
+}>;
+/** Run all validators. Returns errors, warnings, and scope file count. */
+export declare function validateAll(vbriefDir: string, options?: {
+    strictOriginTypes?: boolean;
+}): ValidateAllResult;
+/** Migration gate helper: returns ``[errors, warnings]`` tuple only. */
+export declare function validateAllMigration(vbriefDir: string): readonly [string[], string[]];
+//# sourceMappingURL=validate-all.d.ts.map

package/dist/vbrief-validate/validate-all.js

@@ -0,0 +1,119 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { LIFECYCLE_FOLDERS } from "./constants.js";
+import { validateNoRootDecompositionDrafts } from "./decomposition.js";
+import { validateEpicStoryLinks } from "./epic-links.js";
+import { validateFilename } from "./filename.js";
+import { validateFolderStatus } from "./folder-status.js";
+import { validateOriginProvenance } from "./origin.js";
+import { validateDeprecatedPlaceholders } from "./placeholders.js";
+import { validateProjectDefinition } from "./project-definition.js";
+import { validateVbriefSchema } from "./schema.js";
+import { checkRenderStaleness } from "./staleness.js";
+/**
+ * Convert backslashes to forward slashes and strip any trailing slashes
+ * using a linear scan (no regex). Avoids the CodeQL ``js/polynomial-redos``
+ * alert that ``/\/+$/`` triggers while staying byte-identical to Python's
+ * normalization for display-path construction.
+ */
+function normalizeVbriefDir(vbriefDir) {
+    const forward = vbriefDir.split("\\").join("/");
+    let end = forward.length;
+    while (end > 0 && forward.charCodeAt(end - 1) === 47 /* "/" */) {
+        end -= 1;
+    }
+    return forward.slice(0, end);
+}
+function toDisplayPath(vbriefDir, folder, name) {
+    return `${normalizeVbriefDir(vbriefDir)}/${folder}/${name}`;
+}
+/** Find all .vbrief.json files in lifecycle folders. */
+export function discoverVbriefs(vbriefDir) {
+    const files = [];
+    for (const folder of LIFECYCLE_FOLDERS) {
+        const folderPath = join(vbriefDir, folder);
+        if (!existsSync(folderPath)) {
+            continue;
+        }
+        const names = readdirSync(folderPath)
+            .filter((name) => name.endsWith(".vbrief.json"))
+            .sort();
+        for (const name of names) {
+            files.push({
+                display: toDisplayPath(vbriefDir, folder, name),
+                absolute: resolve(folderPath, name),
+            });
+        }
+    }
+    return files;
+}
+function loadVbrief(filepath) {
+    try {
+        const raw = readFileSync(filepath, "utf8");
+        return { data: JSON.parse(raw), error: null };
+    }
+    catch (err) {
+        if (err instanceof SyntaxError) {
+            return { data: null, error: `${filepath}: invalid JSON: ${err.message}` };
+        }
+        return {
+            data: null,
+            error: `${filepath}: cannot read: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+}
+/** Run all validators. Returns errors, warnings, and scope file count. */
+export function validateAll(vbriefDir, options = {}) {
+    const errors = [];
+    const warnings = [];
+    const allVbriefs = new Map();
+    const resolvedToOriginal = new Map();
+    const strictOriginTypes = options.strictOriginTypes ?? false;
+    const scopeFiles = discoverVbriefs(vbriefDir);
+    errors.push(...validateNoRootDecompositionDrafts(vbriefDir));
+    for (const { display, absolute } of scopeFiles) {
+        const { data, error } = loadVbrief(absolute);
+        if (error !== null) {
+            errors.push(error);
+            continue;
+        }
+        if (data === null) {
+            continue;
+        }
+        const resolved = resolve(absolute);
+        allVbriefs.set(resolved, data);
+        resolvedToOriginal.set(resolved, display);
+        errors.push(...validateVbriefSchema(data, display));
+        errors.push(...validateFilename(display));
+        errors.push(...validateFolderStatus(display, data, vbriefDir));
+        warnings.push(...validateOriginProvenance(display, data, vbriefDir, strictOriginTypes));
+    }
+    const normalizedDir = normalizeVbriefDir(vbriefDir);
+    const projectDefDisplay = `${normalizedDir}/PROJECT-DEFINITION.vbrief.json`;
+    const projectDefAbsolute = join(vbriefDir, "PROJECT-DEFINITION.vbrief.json");
+    if (existsSync(projectDefAbsolute)) {
+        const { data, error } = loadVbrief(projectDefAbsolute);
+        if (error !== null) {
+            errors.push(error);
+        }
+        else if (data !== null) {
+            const resolvedPd = resolve(projectDefAbsolute);
+            allVbriefs.set(resolvedPd, data);
+            resolvedToOriginal.set(resolvedPd, projectDefDisplay);
+            errors.push(...validateVbriefSchema(data, projectDefDisplay));
+            errors.push(...validateProjectDefinition(projectDefDisplay, data, vbriefDir));
+        }
+    }
+    if (allVbriefs.size > 0) {
+        errors.push(...validateEpicStoryLinks(allVbriefs, vbriefDir, resolvedToOriginal));
+    }
+    warnings.push(...validateDeprecatedPlaceholders(vbriefDir));
+    warnings.push(...checkRenderStaleness(vbriefDir));
+    return { errors, warnings, scopeCount: scopeFiles.length };
+}
+/** Migration gate helper: returns ``[errors, warnings]`` tuple only. */
+export function validateAllMigration(vbriefDir) {
+    const { errors, warnings } = validateAll(vbriefDir);
+    return [[...errors], [...warnings]];
+}
+//# sourceMappingURL=validate-all.js.map

package/dist/vbrief-validation/fidelity.d.ts

@@ -0,0 +1,22 @@
+import { CANONICAL_SPEC_KEYS, SPEC_KNOWN_MAPPINGS } from "./legacy-sections.js";
+import type { JsonObject, MigrationLogEntry, SectionTuple, SpecTask } from "./types.js";
+export { CANONICAL_SPEC_KEYS, SPEC_KNOWN_MAPPINGS };
+/** Map a SPECIFICATION.md status token to a vBRIEF status (D2 vocabulary). */
+export declare function mapSpecStatus(raw: string | null | undefined): string;
+/** Parse ``tX.Y.Z`` task sections out of SPECIFICATION.md. */
+export declare function parseSpecTasks(content: string): SpecTask[];
+/** Parse FR-N / NFR-N definitions from SPECIFICATION.md. */
+export declare function parseRequirementDefinitions(content: string): Record<string, string>;
+/** Render FR/NFR definitions as a Requirements narrative string. */
+export declare function buildRequirementsNarrative(requirements: Readonly<Record<string, string>>): string;
+/** Build ``plan.edges[]`` from per-task ``depends_on`` lists. */
+export declare function buildEdgesFromTasks(tasks: Iterable<SpecTask | JsonObject>): JsonObject[];
+/** Reduce a narratives dict to the #506 D3 canonical spec shape. */
+export declare function alignSpecNarratives(narratives: unknown): Record<string, string>;
+/** Split SPECIFICATION.md into canonical narratives + legacy sections. */
+export declare function ingestSpecNarratives(specContent: string, sourceFile?: string): readonly [Record<string, string>, MigrationLogEntry[], SectionTuple[]];
+/** Format a routing-decision dict as a single migrator log line. */
+export declare function formatMigrationLogEntry(entry: MigrationLogEntry | JsonObject): string;
+/** Build the per-task scope-vBRIEF narrative dict. */
+export declare function taskScopeNarratives(task: SpecTask | JsonObject): Record<string, string>;
+//# sourceMappingURL=fidelity.d.ts.map