@deftai/directive-core 0.55.0

package/dist/validate-content/capacity-show.js

@@ -0,0 +1,336 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { CAPACITY_UNIT_COST, DEFAULT_CAPACITY_UNIT, DEFAULT_PENDING_DECISIONS_THRESHOLD, pendingDecisionsNudgeLine, recommendAutonomyLevel, resolveAutonomy, resolveCapacityAllocation, summarizeDecisionBacklog, } from "./capacity-policy.js";
+export const FORWARD_FOLDERS = ["pending", "active"];
+export const BACKWARD_FOLDER = "completed";
+export const UNASSIGNED_BUCKET = "unassigned";
+export const COST_COVERAGE_FLOOR = 0.5;
+const PARENT_KINDS = new Set(["epic", "phase"]);
+function parseIso(value) {
+    if (typeof value !== "string" || !value)
+        return null;
+    try {
+        const parsed = new Date(value.replace("Z", "+00:00"));
+        if (Number.isNaN(parsed.getTime()))
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+function planHasChildren(plan) {
+    const refs = plan.references;
+    if (!Array.isArray(refs))
+        return false;
+    return refs.some((ref) => typeof ref === "object" &&
+        ref !== null &&
+        ref.type === "x-vbrief/plan");
+}
+function coerceCost(value) {
+    if (typeof value === "boolean")
+        return null;
+    if (typeof value === "number" && value > 0)
+        return value;
+    return null;
+}
+function recordWeight(kind, plan, metadata, allocation) {
+    if (PARENT_KINDS.has(kind)) {
+        if (planHasChildren(plan))
+            return 0;
+        const estimated = metadata.estimatedChildren;
+        if (typeof estimated === "number" && Number.isInteger(estimated) && estimated > 0) {
+            return estimated;
+        }
+        return allocation.defaultEpicEstimate;
+    }
+    return 1;
+}
+export function classifyRecord(plan, folder, allocation, now) {
+    const metadata = typeof plan.metadata === "object" && plan.metadata !== null && !Array.isArray(plan.metadata)
+        ? plan.metadata
+        : {};
+    const kindRaw = metadata.kind;
+    const kind = typeof kindRaw === "string" && kindRaw ? kindRaw : "story";
+    const explicitBucket = metadata.capacityBucket;
+    const classified = typeof explicitBucket === "string" && explicitBucket.trim().length > 0;
+    let bucket;
+    if (classified) {
+        bucket = explicitBucket.trim();
+    }
+    else if (allocation.defaultBucket) {
+        bucket = allocation.defaultBucket;
+    }
+    else {
+        bucket = UNASSIGNED_BUCKET;
+    }
+    const weight = recordWeight(kind, plan, metadata, allocation);
+    const rawCompletedAt = metadata.completedAt;
+    const completedAtPresent = typeof rawCompletedAt === "string" && rawCompletedAt.trim().length > 0;
+    let inWindow = false;
+    if (folder === BACKWARD_FOLDER) {
+        const completedAt = parseIso(rawCompletedAt);
+        if (completedAt !== null) {
+            const ageDays = (now.getTime() - completedAt.getTime()) / 86400000;
+            inWindow = ageDays >= 0 && ageDays <= allocation.windowDays;
+        }
+    }
+    const outcome = metadata.outcome;
+    const isRework = (typeof outcome === "string" && outcome.toLowerCase() === "rework") || metadata.rework === true;
+    return {
+        bucket,
+        kind,
+        weight,
+        folder,
+        classified,
+        inWindow,
+        completedAtPresent,
+        isRework,
+        cost: coerceCost(metadata.cost),
+    };
+}
+export function iterVbriefPlans(vbriefRoot) {
+    const out = [];
+    for (const folder of [...FORWARD_FOLDERS, BACKWARD_FOLDER]) {
+        const folderPath = join(vbriefRoot, folder);
+        if (!existsSync(folderPath) || !statSync(folderPath).isDirectory())
+            continue;
+        for (const name of readdirSync(folderPath).sort()) {
+            if (!name.endsWith(".vbrief.json"))
+                continue;
+            const child = join(folderPath, name);
+            try {
+                const data = JSON.parse(readFileSync(child, "utf8"));
+                const plan = typeof data === "object" && data !== null ? data.plan : null;
+                if (typeof plan === "object" && plan !== null && !Array.isArray(plan)) {
+                    out.push({ folder, plan: plan });
+                }
+            }
+            catch {
+                // skip unreadable
+            }
+        }
+    }
+    return out;
+}
+function resolveEffectiveUnit(unitRequested, costEligible, costWithActual) {
+    if (unitRequested !== CAPACITY_UNIT_COST)
+        return [unitRequested, false, null];
+    if (costEligible === 0) {
+        return [
+            DEFAULT_CAPACITY_UNIT,
+            true,
+            "unit:cost requested but no classified completions carry grounded " +
+                "cost actuals -- falling back to advisory vbrief-count " +
+                "(cost overlay: none/estimate-only)",
+        ];
+    }
+    const coverage = costWithActual / costEligible;
+    if (coverage < COST_COVERAGE_FLOOR) {
+        return [
+            DEFAULT_CAPACITY_UNIT,
+            true,
+            `unit:cost requested but only ${costWithActual}/${costEligible} ` +
+                `(${Math.round(coverage * 100)}%) classified completions carry grounded cost ` +
+                `actuals (< ${Math.round(COST_COVERAGE_FLOOR * 100)}% floor) -- falling back to ` +
+                "advisory vbrief-count (cost overlay: none/estimate-only)",
+        ];
+    }
+    return [CAPACITY_UNIT_COST, false, null];
+}
+export function bucketDeficit(report, tally) {
+    const targetWeight = tally.target * report.totalBackward;
+    return Math.round((targetWeight - tally.backwardWeight) * 10000) / 10000;
+}
+export function computeReport(projectRoot, options = {}) {
+    const now = options.now ?? new Date();
+    const allocation = options.allocation ?? resolveCapacityAllocation(projectRoot);
+    const vbriefRoot = join(projectRoot, "vbrief");
+    const records = iterVbriefPlans(vbriefRoot).map(({ folder, plan }) => classifyRecord(plan, folder, allocation, now));
+    const tallies = new Map();
+    for (const bucket of allocation.buckets) {
+        tallies.set(bucket.bucketId, {
+            bucketId: bucket.bucketId,
+            target: bucket.target,
+            forwardWeight: 0,
+            backwardWeight: 0,
+            reworkWeight: 0,
+            costActual: null,
+        });
+    }
+    for (const record of records) {
+        if (!tallies.has(record.bucket)) {
+            tallies.set(record.bucket, {
+                bucketId: record.bucket,
+                target: 0,
+                forwardWeight: 0,
+                backwardWeight: 0,
+                reworkWeight: 0,
+                costActual: null,
+            });
+        }
+    }
+    let classifiedCompletions = 0;
+    let unclassifiedCompletions = 0;
+    let costEligible = 0;
+    let costWithActual = 0;
+    for (const record of records) {
+        const tally = tallies.get(record.bucket);
+        if (!tally)
+            continue;
+        if (FORWARD_FOLDERS.includes(record.folder)) {
+            tally.forwardWeight += record.weight;
+        }
+        else if (record.folder === BACKWARD_FOLDER && record.inWindow) {
+            tally.backwardWeight += record.weight;
+            if (record.isRework)
+                tally.reworkWeight += record.weight;
+            if (record.classified) {
+                classifiedCompletions += 1;
+                costEligible += 1;
+                if (record.cost !== null) {
+                    costWithActual += 1;
+                    tally.costActual = (tally.costActual ?? 0) + record.cost;
+                }
+            }
+        }
+        if (record.folder === BACKWARD_FOLDER &&
+            !record.classified &&
+            (record.inWindow || !record.completedAtPresent)) {
+            unclassifiedCompletions += 1;
+        }
+    }
+    const totalForward = [...tallies.values()].reduce((s, t) => s + t.forwardWeight, 0);
+    const totalBackward = [...tallies.values()].reduce((s, t) => s + t.backwardWeight, 0);
+    const totalRework = [...tallies.values()].reduce((s, t) => s + t.reworkWeight, 0);
+    const configuredIds = allocation.buckets.map((b) => b.bucketId);
+    const extras = [...tallies.keys()].filter((id) => !configuredIds.includes(id)).sort();
+    const ordered = [
+        ...configuredIds.map((id) => tallies.get(id)),
+        ...extras.map((id) => tallies.get(id)),
+    ];
+    const unitRequested = [DEFAULT_CAPACITY_UNIT, CAPACITY_UNIT_COST].includes(allocation.unit)
+        ? allocation.unit
+        : DEFAULT_CAPACITY_UNIT;
+    const [unitEffective, costFallback, costReason] = resolveEffectiveUnit(unitRequested, costEligible, costWithActual);
+    const advisoryReasons = [];
+    if (!allocation.configured) {
+        advisoryReasons.push("capacityAllocation not configured -- showing discovered buckets only");
+    }
+    const sampleShort = classifiedCompletions < allocation.minSampleSize;
+    if (sampleShort) {
+        advisoryReasons.push(`only ${classifiedCompletions} classified completion(s) in window ` +
+            `(< minSampleSize=${allocation.minSampleSize}) -- deferring to ordering`);
+        if (allocation.configured && unclassifiedCompletions > 0) {
+            advisoryReasons.push(`${unclassifiedCompletions} completed vBRIEF(s) are unclassified ` +
+                "-- run `task capacity:backfill --apply` (one-time) to classify " +
+                "history and activate capacity accounting");
+        }
+    }
+    if (costFallback && costReason)
+        advisoryReasons.push(costReason);
+    const backlog = summarizeDecisionBacklog(projectRoot, {
+        now,
+        windowDays: allocation.windowDays,
+    });
+    const reworkRate = totalBackward > 0 ? totalRework / totalBackward : 0;
+    const autonomyPolicy = resolveAutonomy(projectRoot);
+    const autonomy = autonomyPolicy.enabled
+        ? recommendAutonomyLevel(autonomyPolicy.defaultLevel, {
+            overrideRate: backlog.overrideRate,
+            reworkRate,
+            sampleSize: backlog.resolvedInWindow,
+            p0Reversal: backlog.p0ReversalInWindow,
+            policy: autonomyPolicy,
+        })
+        : null;
+    return {
+        configured: allocation.configured,
+        source: allocation.source,
+        unitRequested,
+        unitEffective,
+        costFallback,
+        costFallbackReason: costReason,
+        windowDays: allocation.windowDays,
+        minSampleSize: allocation.minSampleSize,
+        classifiedCompletions,
+        unclassifiedCompletions,
+        advisoryMode: sampleShort || !allocation.configured,
+        advisoryReasons,
+        buckets: ordered,
+        totalForward,
+        totalBackward,
+        policyError: allocation.error,
+        pendingDecisions: backlog.pendingCount,
+        pendingDecisionsThreshold: DEFAULT_PENDING_DECISIONS_THRESHOLD,
+        pendingByKind: backlog.byKind,
+        pendingNudge: pendingDecisionsNudgeLine(backlog.pendingCount),
+        autonomyEnabled: autonomyPolicy.enabled,
+        autonomy,
+    };
+}
+function formatCost(value) {
+    if (value === null)
+        return "none/estimate-only";
+    return value.toFixed(2);
+}
+function appendBacklogAndAutonomy(lines, report) {
+    lines.push(`  Pending human decisions: ${report.pendingDecisions} ` +
+        `(threshold ${report.pendingDecisionsThreshold})`);
+    const kinds = Object.entries(report.pendingByKind).sort(([a], [b]) => a.localeCompare(b));
+    if (kinds.length > 0) {
+        lines.push(`    by kind: ${kinds.map(([k, c]) => `${k}=${c}`).join(", ")}`);
+    }
+    if (report.pendingNudge)
+        lines.push(`  ${report.pendingNudge}`);
+    if (report.autonomyEnabled && report.autonomy !== null) {
+        const rec = report.autonomy;
+        lines.push(`  Autonomy dial (advisory-only): ${rec.currentLevel} -> ` +
+            `${rec.recommendedLevel} [${rec.action}]`);
+        lines.push(`    ${rec.rationale}`);
+    }
+}
+export function renderReport(report) {
+    const lines = [];
+    lines.push("Capacity allocation (advisory, offline / filesystem-truth)");
+    lines.push(`  unit: ${report.unitEffective}` +
+        (report.costFallback ? ` (requested ${report.unitRequested}; cost fallback active)` : ""));
+    lines.push(`  window: trailing ${report.windowDays}d | ` +
+        `classified completions: ${report.classifiedCompletions} ` +
+        `(minSampleSize ${report.minSampleSize}) | source: ${report.source}`);
+    if (report.policyError)
+        lines.push(`  CONFIG ERROR: ${report.policyError}`);
+    if (report.advisoryMode) {
+        lines.push("  MODE: ADVISORY -- deferring to selection ordering.");
+    }
+    for (const reason of report.advisoryReasons) {
+        lines.push(`    - ${reason}`);
+    }
+    appendBacklogAndAutonomy(lines, report);
+    if (report.buckets.length === 0) {
+        lines.push("  (no buckets configured and no classified work on disk)");
+        return lines.join("\n");
+    }
+    const header = `  ${"bucket".padEnd(16)} ${"target".padStart(7)} ${"fwd".padStart(7)} ${"back".padStart(7)} ${"deficit".padStart(8)} ${"rework".padStart(7)} ${"cost".padStart(18)}`;
+    lines.push(header);
+    lines.push(`  ${"-".repeat(header.length - 2)}`);
+    for (const tally of report.buckets) {
+        const deficit = bucketDeficit(report, tally);
+        const deficitStr = deficit >= 0 ? `+${deficit.toFixed(2)}` : deficit.toFixed(2);
+        lines.push(`  ${tally.bucketId.padEnd(16)} ` +
+            `${(tally.target * 100).toFixed(1).padStart(6)}% ` +
+            `${tally.forwardWeight.toFixed(1).padStart(7)} ` +
+            `${tally.backwardWeight.toFixed(1).padStart(7)} ` +
+            `${deficitStr.padStart(8)} ` +
+            `${tally.reworkWeight.toFixed(1).padStart(7)} ` +
+            `${formatCost(tally.costActual).padStart(18)}`);
+    }
+    lines.push(`  ${"TOTAL".padEnd(16)} ${"".padStart(7)} ${report.totalForward.toFixed(1).padStart(7)} ` +
+        `${report.totalBackward.toFixed(1).padStart(7)}`);
+    if (report.costFallback) {
+        lines.push("  Note: cost overlay shows none/estimate-only -- no grounded cost " +
+            "telemetry (out of scope / upstream-blocked, OQ2).");
+    }
+    return lines.join("\n");
+}
+//# sourceMappingURL=capacity-show.js.map

package/dist/validate-content/filename.d.ts

@@ -0,0 +1,3 @@
+/** Linear filename validator for YYYY-MM-DD-<slug>.vbrief.json (no nested regex). */
+export declare function isDatePrefixedVbriefFilename(name: string): boolean;
+//# sourceMappingURL=filename.d.ts.map

package/dist/validate-content/filename.js

@@ -0,0 +1,54 @@
+/** Linear filename validator for YYYY-MM-DD-<slug>.vbrief.json (no nested regex). */
+export function isDatePrefixedVbriefFilename(name) {
+    const suffix = ".vbrief.json";
+    if (!name.endsWith(suffix))
+        return false;
+    const base = name.slice(0, -suffix.length);
+    if (base.length < 12)
+        return false;
+    const y = base.slice(0, 4);
+    const sep1 = base[4];
+    const mo = base.slice(5, 7);
+    const sep2 = base[7];
+    const day = base.slice(8, 10);
+    const sep3 = base[10];
+    if (sep1 !== "-" || sep2 !== "-" || sep3 !== "-")
+        return false;
+    if (!isDigits(y) || !isDigits(mo) || !isDigits(day))
+        return false;
+    const slug = base.slice(11);
+    if (!slug)
+        return false;
+    return isSlugSegments(slug);
+}
+function isDigits(value) {
+    if (value.length === 0)
+        return false;
+    for (const ch of value) {
+        if (ch < "0" || ch > "9")
+            return false;
+    }
+    return true;
+}
+function isLowerAlnum(ch) {
+    return (ch >= "a" && ch <= "z") || (ch >= "0" && ch <= "9");
+}
+function isSlugSegments(slug) {
+    let i = 0;
+    while (i < slug.length) {
+        if (!isLowerAlnum(slug[i] ?? ""))
+            return false;
+        i += 1;
+        while (i < slug.length && isLowerAlnum(slug[i] ?? ""))
+            i += 1;
+        if (i < slug.length) {
+            if (slug[i] !== "-")
+                return false;
+            i += 1;
+            if (i >= slug.length || !isLowerAlnum(slug[i] ?? ""))
+                return false;
+        }
+    }
+    return true;
+}
+//# sourceMappingURL=filename.js.map

package/dist/validate-content/index.d.ts

@@ -0,0 +1,9 @@
+export { resolveCapacityAllocation } from "./capacity-policy.js";
+export { computeReport, renderReport } from "./capacity-show.js";
+export { isDatePrefixedVbriefFilename } from "./filename.js";
+export { extractLinkTargets, shouldSkipLinkTarget } from "./link-parser.js";
+export * from "./types.js";
+export * as validateLinks from "./validate-links.js";
+export * as validateStrategyOutput from "./validate-strategy-output.js";
+export * as verifyCapacity from "./verify-capacity.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/validate-content/index.js

@@ -0,0 +1,9 @@
+export { resolveCapacityAllocation } from "./capacity-policy.js";
+export { computeReport, renderReport } from "./capacity-show.js";
+export { isDatePrefixedVbriefFilename } from "./filename.js";
+export { extractLinkTargets, shouldSkipLinkTarget } from "./link-parser.js";
+export * from "./types.js";
+export * as validateLinks from "./validate-links.js";
+export * as validateStrategyOutput from "./validate-strategy-output.js";
+export * as verifyCapacity from "./verify-capacity.js";
+//# sourceMappingURL=index.js.map

package/dist/validate-content/link-parser.d.ts

@@ -0,0 +1,5 @@
+/** Linear markdown link target extractor — avoids polynomial regex backtracking. */
+export declare function extractLinkTargets(line: string): string[];
+/** Mirrors Python SKIP_PATTERNS.search(target) without regex backtracking. */
+export declare function shouldSkipLinkTarget(target: string): boolean;
+//# sourceMappingURL=link-parser.d.ts.map

package/dist/validate-content/link-parser.js

@@ -0,0 +1,42 @@
+/** Linear markdown link target extractor — avoids polynomial regex backtracking. */
+export function extractLinkTargets(line) {
+    const targets = [];
+    let i = 0;
+    while (i < line.length) {
+        const bracket = line.indexOf("[", i);
+        if (bracket === -1)
+            break;
+        let closeBracket = bracket + 1;
+        while (closeBracket < line.length && line[closeBracket] !== "]") {
+            closeBracket += 1;
+        }
+        if (closeBracket >= line.length || line[closeBracket + 1] !== "(") {
+            i = bracket + 1;
+            continue;
+        }
+        let paren = closeBracket + 2;
+        const start = paren;
+        while (paren < line.length && line[paren] !== ")") {
+            paren += 1;
+        }
+        if (paren >= line.length)
+            break;
+        targets.push(line.slice(start, paren));
+        i = paren + 1;
+    }
+    return targets;
+}
+/** Mirrors Python SKIP_PATTERNS.search(target) without regex backtracking. */
+export function shouldSkipLinkTarget(target) {
+    if (target.includes("{") || target.includes("}") || target.includes("@")) {
+        return true;
+    }
+    if (target.startsWith("["))
+        return true;
+    if (target.startsWith("./relative-"))
+        return true;
+    if (target === "path")
+        return true;
+    return false;
+}
+//# sourceMappingURL=link-parser.js.map

package/dist/validate-content/types.d.ts

@@ -0,0 +1,8 @@
+export type OutputStream = "stdout" | "stderr" | "none";
+/** Three-state gate result mirroring the Python verify/validate gates. */
+export interface EvaluateResult {
+    readonly code: 0 | 1 | 2;
+    readonly message: string;
+    readonly stream: OutputStream;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/validate-content/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/validate-content/validate-links.d.ts

@@ -0,0 +1,17 @@
+import type { EvaluateResult } from "./types.js";
+export interface BrokenLink {
+    readonly file: string;
+    readonly line: number;
+    readonly target: string;
+}
+export interface ValidateLinksOptions {
+    readonly cwd?: string;
+    readonly strict?: boolean;
+    readonly linkCheckStrict?: boolean;
+    readonly argv?: readonly string[];
+}
+/**
+ * Validate internal markdown links. Faithful to `scripts/validate-links.py`.
+ */
+export declare function evaluate(options?: ValidateLinksOptions): EvaluateResult;
+//# sourceMappingURL=validate-links.d.ts.map

package/dist/validate-content/validate-links.js

@@ -0,0 +1,114 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { extractLinkTargets, shouldSkipLinkTarget } from "./link-parser.js";
+const EXCLUDE_DIRS = new Set([
+    ".git",
+    "backup",
+    "node_modules",
+    ".venv",
+    "__pycache__",
+    "dist",
+    ".planning",
+    "specs",
+]);
+function shouldSkipPath(parts) {
+    if (parts.some((p) => EXCLUDE_DIRS.has(p)))
+        return true;
+    return parts.includes("history") && parts.includes("archive");
+}
+function collectMarkdownFiles(root) {
+    const out = [];
+    const walk = (dir, parts) => {
+        if (shouldSkipPath(parts))
+            return;
+        let entries;
+        try {
+            entries = readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+            const full = join(dir, entry.name);
+            const nextParts = [...parts, entry.name];
+            if (shouldSkipPath(nextParts))
+                continue;
+            if (entry.isDirectory()) {
+                walk(full, nextParts);
+            }
+            else if (entry.isFile() && entry.name.endsWith(".md")) {
+                out.push(full);
+            }
+        }
+    };
+    walk(root, []);
+    return out.sort();
+}
+function findBrokenLinks(cwd) {
+    const broken = [];
+    const root = resolve(cwd);
+    for (const md of collectMarkdownFiles(root)) {
+        let text;
+        try {
+            text = readFileSync(md, "utf8");
+        }
+        catch {
+            continue;
+        }
+        const rel = md.startsWith(`${root}/`) ? md.slice(root.length + 1) : md;
+        const lines = text.split("\n");
+        for (let i = 0; i < lines.length; i += 1) {
+            const line = lines[i] ?? "";
+            for (const target of extractLinkTargets(line)) {
+                if (target.startsWith("http://") ||
+                    target.startsWith("https://") ||
+                    target.startsWith("mailto:") ||
+                    target.startsWith("#")) {
+                    continue;
+                }
+                if (shouldSkipLinkTarget(target))
+                    continue;
+                const clean = target.split("#")[0]?.split("?")[0] ?? "";
+                if (!clean)
+                    continue;
+                const resolved = resolve(join(md, ".."), clean);
+                if (!existsSync(resolved)) {
+                    broken.push({ file: rel, line: i + 1, target });
+                }
+            }
+        }
+    }
+    return broken;
+}
+/**
+ * Validate internal markdown links. Faithful to `scripts/validate-links.py`.
+ */
+export function evaluate(options = {}) {
+    const cwd = resolve(options.cwd ?? ".");
+    const strict = options.strict === true ||
+        options.linkCheckStrict === true ||
+        (options.argv ?? []).includes("--strict") ||
+        process.env.LINK_CHECK_STRICT === "1";
+    const broken = findBrokenLinks(cwd);
+    if (broken.length === 0) {
+        return {
+            code: 0,
+            message: "All internal markdown links valid",
+            stream: "stdout",
+        };
+    }
+    const mode = strict ? "errors" : "warnings";
+    const lines = [`Found ${broken.length} broken internal link(s) (${mode}):`];
+    for (const item of broken.slice(0, 50)) {
+        lines.push(`  ${item.file}:${item.line} -> ${item.target}`);
+    }
+    if (broken.length > 50) {
+        lines.push(`  ... and ${broken.length - 50} more`);
+    }
+    return {
+        code: strict ? 1 : 0,
+        message: lines.join("\n"),
+        stream: "stdout",
+    };
+}
+//# sourceMappingURL=validate-links.js.map

package/dist/validate-content/validate-strategy-output.d.ts

@@ -0,0 +1,11 @@
+import type { EvaluateResult } from "./types.js";
+/** Pure validator returning error strings (empty == pass). */
+export declare function validateStrategyOutput(projectRoot: string, strict?: boolean): string[];
+export interface StrategyOutputOptions {
+    readonly projectRoot?: string;
+    readonly strict?: boolean;
+    readonly quiet?: boolean;
+}
+/** CLI-shaped evaluator mirroring `scripts/validate_strategy_output.py::main`. */
+export declare function evaluate(options?: StrategyOutputOptions): EvaluateResult;
+//# sourceMappingURL=validate-strategy-output.d.ts.map