@deftai/directive-core 0.79.2 → 0.79.4

package/dist/check/orchestrator.d.ts

@@ -20,12 +20,16 @@ export interface CheckOrchestratorSeams {
         cwd: string;
         stdio: string;
         env?: NodeJS.ProcessEnv;
+        timeoutMs?: number;
     }) => {
         status: number | null;
+        signal?: NodeJS.Signals | null;
         error?: Error;
     };
     /** Child-process environment (default: process.env). */
     readonly env?: NodeJS.ProcessEnv;
+    /** Wall-clock spawn timeout in milliseconds (default: none). */
+    readonly timeoutMs?: number;
 }
 /**
  * True when `path` is the directive framework source checkout root (not a

package/dist/check/orchestrator.js

@@ -78,11 +78,16 @@ export function dispatchTaskCheck(frameworkRoot, projectRoot, seams = {}) {
         cwd,
         stdio: "inherit",
         env: seams.env,
+        timeoutMs: seams.timeoutMs,
     });
     if (result.error !== undefined) {
         process.stderr.write(`check: failed to invoke task: ${result.error.message}\n`);
         return 2;
     }
+    if (result.signal === "SIGTERM" && result.status === null && seams.timeoutMs !== undefined) {
+        process.stderr.write(`check: timed out after ${seams.timeoutMs / 60_000}m (Step 5 vitest coverage budget; #2652)\n`);
+        return 124;
+    }
     return result.status ?? 1;
 }
 function defaultSpawn(cmd, args, opts) {
@@ -90,7 +95,10 @@ function defaultSpawn(cmd, args, opts) {
         cwd: opts.cwd,
         stdio: opts.stdio,
         env: opts.env ?? process.env,
+        ...(opts.timeoutMs !== undefined
+            ? { timeout: opts.timeoutMs, killSignal: "SIGTERM" }
+            : {}),
     });
-    return { status: result.status, error: result.error };
+    return { status: result.status, signal: result.signal, error: result.error };
 }
 //# sourceMappingURL=orchestrator.js.map

package/dist/coverage-hotspots/evaluate.d.ts

@@ -0,0 +1,49 @@
+import { type CoverageMetric, type CoverageTotals, summarizeCoverageFinal } from "../vitest-runner/coverage-debt.js";
+import { type CoverageThresholds } from "./thresholds.js";
+export declare const DEFAULT_MIN_HEADROOM_PP = 0.3;
+export declare const DEFAULT_LOWEST_MODULE_LIMIT = 10;
+export interface ModuleCoverage {
+    readonly path: string;
+    readonly lines: number;
+    readonly functions: number;
+    readonly branches: number;
+    readonly statements: number;
+}
+export interface UncoveredBranchSample {
+    readonly path: string;
+    readonly line: number;
+    readonly branchId: string;
+    readonly type: string;
+}
+export interface CoverageHotspotsReport {
+    readonly ok: boolean;
+    readonly global: CoverageTotals;
+    readonly thresholds: CoverageThresholds;
+    readonly headroomPp: Record<CoverageMetric, number>;
+    readonly minHeadroomPp: number;
+    readonly failReasons: readonly string[];
+    readonly lowestModules: readonly ModuleCoverage[];
+    readonly uncoveredBranches: readonly UncoveredBranchSample[];
+    readonly pathFilter: readonly string[];
+    readonly coverageReportPath: string;
+}
+export interface CoverageHotspotsResult {
+    readonly exitCode: 0 | 1 | 2;
+    readonly report: CoverageHotspotsReport | null;
+    readonly message: string;
+}
+export interface CoverageHotspotsOptions {
+    readonly projectRoot: string;
+    readonly coverageDir?: string;
+    readonly minHeadroomPp?: number;
+    readonly baseRef?: string | null;
+    readonly pathFilter?: readonly string[] | null;
+    readonly useDiffPaths?: boolean;
+    readonly lowestModuleLimit?: number;
+}
+export declare function evaluateCoverageHotspots(options: CoverageHotspotsOptions): CoverageHotspotsResult;
+export declare function formatJsonReport(report: CoverageHotspotsReport): string;
+export declare function formatTextReport(report: CoverageHotspotsReport, failed: boolean): string;
+/** Re-export for tests that build synthetic reports. */
+export { summarizeCoverageFinal };
+//# sourceMappingURL=evaluate.d.ts.map

package/dist/coverage-hotspots/evaluate.js

@@ -0,0 +1,262 @@
+import * as childProcess from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { join, relative } from "node:path";
+import { summarizeCoverageFinal, } from "../vitest-runner/coverage-debt.js";
+import { readProjectCoverageThresholds } from "./thresholds.js";
+export const DEFAULT_MIN_HEADROOM_PP = 0.3;
+export const DEFAULT_LOWEST_MODULE_LIMIT = 10;
+class GitCommandError extends Error {
+}
+function runGit(args, projectRoot) {
+    try {
+        return childProcess.execFileSync("git", args, {
+            cwd: projectRoot,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+    }
+    catch (err) {
+        const e = err;
+        const stderr = String(e.stderr ?? e.message ?? err).trim();
+        throw new GitCommandError(`coverage-hotspots: git ${args.join(" ")} failed: ${stderr}`);
+    }
+}
+function splitLines(stdout) {
+    return stdout
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+}
+function resolveBaseRef(projectRoot, override) {
+    if (override && override.trim().length > 0)
+        return override.trim();
+    for (const candidate of ["origin/master", "origin/main", "master", "main", "HEAD~1"]) {
+        try {
+            runGit(["rev-parse", "--verify", "-q", candidate], projectRoot);
+            return candidate;
+        }
+        catch {
+            // try next
+        }
+    }
+    return "HEAD~1";
+}
+function diffPaths(projectRoot, baseRef) {
+    return splitLines(runGit(["diff", "--name-only", baseRef, "HEAD"], projectRoot));
+}
+function pct(covered, total) {
+    return total === 0 ? 100 : (covered / total) * 100;
+}
+function summarizeFileCoverage(relPath, file) {
+    let stmtTotal = 0;
+    let stmtCovered = 0;
+    let fnTotal = 0;
+    let fnCovered = 0;
+    let branchTotal = 0;
+    let branchCovered = 0;
+    if (file.s) {
+        for (const hits of Object.values(file.s)) {
+            stmtTotal += 1;
+            if (hits > 0)
+                stmtCovered += 1;
+        }
+    }
+    if (file.f) {
+        for (const hits of Object.values(file.f)) {
+            fnTotal += 1;
+            if (hits > 0)
+                fnCovered += 1;
+        }
+    }
+    if (file.b) {
+        for (const paths of Object.values(file.b)) {
+            for (const hits of paths) {
+                branchTotal += 1;
+                if (hits > 0)
+                    branchCovered += 1;
+            }
+        }
+    }
+    const statements = pct(stmtCovered, stmtTotal);
+    const functions = pct(fnCovered, fnTotal);
+    const branches = pct(branchCovered, branchTotal);
+    return {
+        path: relPath,
+        statements,
+        functions,
+        branches,
+        lines: statements,
+    };
+}
+function normalizeReportPath(projectRoot, rawKey, file) {
+    if (file.path && file.path.length > 0) {
+        const abs = file.path;
+        if (abs.startsWith(projectRoot)) {
+            return relative(projectRoot, abs).replace(/\\/g, "/");
+        }
+        return abs.replace(/\\/g, "/");
+    }
+    return rawKey.replace(/\\/g, "/");
+}
+function pathMatchesFilter(relPath, filters) {
+    if (filters.length === 0)
+        return true;
+    // Substring only — do not feed CLI/argv filters into RegExp (CodeQL js/regex-injection).
+    return filters.some((pattern) => relPath.includes(pattern));
+}
+function collectUncoveredBranches(relPath, file) {
+    if (!file.b)
+        return [];
+    const samples = [];
+    for (const [branchId, hits] of Object.entries(file.b)) {
+        if (!hits.some((count) => count === 0))
+            continue;
+        const meta = file.branchMap?.[branchId];
+        const line = meta?.line ?? meta?.loc?.start?.line ?? 0;
+        samples.push({
+            path: relPath,
+            line,
+            branchId,
+            type: meta?.type ?? "branch",
+        });
+    }
+    return samples;
+}
+function computeHeadroom(totals, thresholds) {
+    return {
+        lines: totals.lines - thresholds.lines,
+        functions: totals.functions - thresholds.functions,
+        branches: totals.branches - thresholds.branches,
+        statements: totals.statements - thresholds.statements,
+    };
+}
+function evaluatePassFail(totals, thresholds, headroomPp, minHeadroomPp) {
+    const reasons = [];
+    if (totals.branches + 1e-9 < thresholds.branches) {
+        reasons.push(`branches ${totals.branches.toFixed(2)}% below project floor ${thresholds.branches}%`);
+    }
+    if (headroomPp.branches + 1e-9 < minHeadroomPp) {
+        reasons.push(`branch headroom ${headroomPp.branches.toFixed(2)}pp below minimum ${minHeadroomPp}pp`);
+    }
+    return reasons;
+}
+function configError(message) {
+    return { exitCode: 2, report: null, message };
+}
+export function evaluateCoverageHotspots(options) {
+    const projectRoot = options.projectRoot;
+    const coverageDir = options.coverageDir ?? join(projectRoot, "coverage");
+    const minHeadroomPp = options.minHeadroomPp ?? DEFAULT_MIN_HEADROOM_PP;
+    const lowestModuleLimit = options.lowestModuleLimit ?? DEFAULT_LOWEST_MODULE_LIMIT;
+    const useDiffPaths = options.useDiffPaths ?? true;
+    const reportPath = join(coverageDir, "coverage-final.json");
+    if (!existsSync(reportPath)) {
+        return configError(`coverage-hotspots: coverage report missing at ${reportPath}\n` +
+            "  Run tests with coverage first (e.g. vitest run --coverage or task test:coverage).");
+    }
+    let rawReport;
+    try {
+        rawReport = JSON.parse(readFileSync(reportPath, "utf8"));
+    }
+    catch (err) {
+        return configError(`coverage-hotspots: unreadable coverage report at ${reportPath}: ${String(err.message)}`);
+    }
+    const totals = summarizeCoverageFinal(rawReport);
+    const thresholds = readProjectCoverageThresholds(projectRoot);
+    const headroomPp = computeHeadroom(totals, thresholds);
+    let pathFilter = options.pathFilter ?? [];
+    if (pathFilter.length === 0 && useDiffPaths) {
+        try {
+            const baseRef = resolveBaseRef(projectRoot, options.baseRef);
+            pathFilter = diffPaths(projectRoot, baseRef);
+        }
+        catch (err) {
+            const message = err instanceof GitCommandError
+                ? `${err.message}\n  Recovery: pass explicit --path filters or run inside a git repo.`
+                : `coverage-hotspots: ${String(err.message)}`;
+            return configError(message);
+        }
+    }
+    const modules = [];
+    const uncoveredBranches = [];
+    for (const [rawKey, file] of Object.entries(rawReport)) {
+        const relPath = normalizeReportPath(projectRoot, rawKey, file);
+        modules.push(summarizeFileCoverage(relPath, file));
+        if (pathMatchesFilter(relPath, pathFilter)) {
+            uncoveredBranches.push(...collectUncoveredBranches(relPath, file));
+        }
+    }
+    modules.sort((a, b) => a.branches - b.branches || a.path.localeCompare(b.path));
+    const lowestModules = modules.slice(0, lowestModuleLimit);
+    uncoveredBranches.sort((a, b) => a.path.localeCompare(b.path) || a.line - b.line || a.branchId.localeCompare(b.branchId));
+    const failReasons = evaluatePassFail(totals, thresholds, headroomPp, minHeadroomPp);
+    const report = {
+        ok: failReasons.length === 0,
+        global: totals,
+        thresholds,
+        headroomPp,
+        minHeadroomPp,
+        failReasons,
+        lowestModules,
+        uncoveredBranches,
+        pathFilter,
+        coverageReportPath: reportPath,
+    };
+    if (failReasons.length > 0) {
+        return {
+            exitCode: 1,
+            report,
+            message: formatTextReport(report, true),
+        };
+    }
+    return {
+        exitCode: 0,
+        report,
+        message: formatTextReport(report, false),
+    };
+}
+export function formatJsonReport(report) {
+    return `${JSON.stringify(report, null, 2)}\n`;
+}
+function metricLine(label, value, threshold, headroom) {
+    return `  ${label.padEnd(12)} ${value.toFixed(2)}%  (floor ${threshold}% | headroom ${headroom.toFixed(2)}pp)`;
+}
+export function formatTextReport(report, failed) {
+    const lines = [];
+    lines.push(failed ? "coverage-hotspots: FAIL" : "coverage-hotspots: OK");
+    lines.push(`report: ${report.coverageReportPath}`);
+    lines.push("global:");
+    lines.push(metricLine("branches", report.global.branches, report.thresholds.branches, report.headroomPp.branches));
+    lines.push(metricLine("lines", report.global.lines, report.thresholds.lines, report.headroomPp.lines));
+    lines.push(metricLine("functions", report.global.functions, report.thresholds.functions, report.headroomPp.functions));
+    lines.push(metricLine("statements", report.global.statements, report.thresholds.statements, report.headroomPp.statements));
+    lines.push(`min branch headroom: ${report.minHeadroomPp}pp`);
+    if (report.pathFilter.length > 0) {
+        lines.push(`path filter (${report.pathFilter.length}): ${report.pathFilter.slice(0, 8).join(", ")}${report.pathFilter.length > 8 ? ", ..." : ""}`);
+    }
+    if (report.failReasons.length > 0) {
+        lines.push("fail reasons:");
+        for (const reason of report.failReasons) {
+            lines.push(`  - ${reason}`);
+        }
+    }
+    if (report.lowestModules.length > 0) {
+        lines.push("lowest modules (branches):");
+        for (const mod of report.lowestModules.slice(0, 5)) {
+            lines.push(`  - ${mod.path}: branches ${mod.branches.toFixed(2)}%`);
+        }
+    }
+    if (report.uncoveredBranches.length > 0) {
+        lines.push("uncovered branch samples:");
+        for (const sample of report.uncoveredBranches.slice(0, 12)) {
+            lines.push(`  - ${sample.path}:${sample.line} (${sample.type} #${sample.branchId})`);
+        }
+        if (report.uncoveredBranches.length > 12) {
+            lines.push(`  ... ${report.uncoveredBranches.length - 12} more`);
+        }
+    }
+    return `${lines.join("\n")}\n`;
+}
+/** Re-export for tests that build synthetic reports. */
+export { summarizeCoverageFinal };
+//# sourceMappingURL=evaluate.js.map

package/dist/coverage-hotspots/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./evaluate.js";
+export * from "./thresholds.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/coverage-hotspots/index.js

@@ -0,0 +1,3 @@
+export * from "./evaluate.js";
+export * from "./thresholds.js";
+//# sourceMappingURL=index.js.map

package/dist/coverage-hotspots/thresholds.d.ts

@@ -0,0 +1,5 @@
+import { type CoverageMetric } from "../vitest-runner/coverage-debt.js";
+export type CoverageThresholds = Record<CoverageMetric, number>;
+/** Best-effort read of vitest coverage thresholds; falls back to framework 85% defaults. */
+export declare function readProjectCoverageThresholds(projectRoot: string): CoverageThresholds;
+//# sourceMappingURL=thresholds.d.ts.map

package/dist/coverage-hotspots/thresholds.js

@@ -0,0 +1,48 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { COVERAGE_GOAL } from "../vitest-runner/coverage-debt.js";
+const VITEST_CONFIG_CANDIDATES = [
+    "vitest.config.ts",
+    "vitest.config.mts",
+    "vitest.config.js",
+    "vitest.config.cjs",
+    "vitest.config.mjs",
+];
+const METRIC_PATTERN = /(?:^|[\n\r{,])\s*(branches|lines|functions|statements)\s*:\s*(\d+(?:\.\d+)?)/g;
+function parseMetricBlock(text, anchor) {
+    const match = anchor.exec(text);
+    if (match?.index === undefined)
+        return {};
+    const slice = text.slice(match.index, match.index + 800);
+    const out = {};
+    for (const metricMatch of slice.matchAll(METRIC_PATTERN)) {
+        const metric = metricMatch[1];
+        const value = metricMatch[2];
+        if (metric === undefined || value === undefined)
+            continue;
+        out[metric] = Number.parseFloat(value);
+    }
+    return out;
+}
+/** Best-effort read of vitest coverage thresholds; falls back to framework 85% defaults. */
+export function readProjectCoverageThresholds(projectRoot) {
+    for (const name of VITEST_CONFIG_CANDIDATES) {
+        const path = join(projectRoot, name);
+        if (!existsSync(path))
+            continue;
+        const text = readFileSync(path, "utf8");
+        const fromCoverageThresholds = parseMetricBlock(text, /coverageThresholds\s*=\s*\{/);
+        const fromNested = parseMetricBlock(text, /thresholds\s*:\s*\{/);
+        const merged = { ...fromNested, ...fromCoverageThresholds };
+        if (Object.keys(merged).length > 0) {
+            return {
+                lines: merged.lines ?? COVERAGE_GOAL.lines,
+                functions: merged.functions ?? COVERAGE_GOAL.functions,
+                branches: merged.branches ?? COVERAGE_GOAL.branches,
+                statements: merged.statements ?? COVERAGE_GOAL.statements,
+            };
+        }
+    }
+    return { ...COVERAGE_GOAL };
+}
+//# sourceMappingURL=thresholds.js.map

package/dist/hooks/dispatcher.d.ts

@@ -17,11 +17,17 @@ export interface HookDecision {
     readonly message: string;
     readonly scopePath: string | null;
 }
+/** Stdin parse metadata from hook-dispatch; absent when callers supply payload directly. */
+export interface HookPayloadContext {
+    readonly stdinEmpty?: boolean;
+    readonly parseFailed?: boolean;
+}
 export interface HookDispatchInput {
     readonly host: HookHost;
     readonly event: HookEvent;
     readonly projectRoot: string;
     readonly payload: unknown;
+    readonly payloadContext?: HookPayloadContext;
 }
 export interface HookPolicySeams {
     readonly inspectRitual?: (projectRoot: string) => VerifyResult;
@@ -32,6 +38,7 @@ export interface HookPolicySeams {
         stderr: string;
     };
 }
+export declare function hookPayloadTopLevelKeys(payload: unknown): string[];
 export declare function hookToolName(payload: unknown, host?: HookHost): string | null;
 /**
  * Best-effort write-target path from host PreToolUse payloads (#2625).

package/dist/hooks/dispatcher.js

@@ -29,7 +29,12 @@ function fieldString(input, key) {
     return null;
 }
 function toolInputRecord(payload) {
-    return record(payload.tool_input) ?? record(payload.toolInput) ?? record(payload.input);
+    const toolCall = record(payload.tool_call) ?? record(payload.toolCall);
+    return (record(payload.tool_input) ??
+        record(payload.toolInput) ??
+        record(payload.input) ??
+        record(payload.arguments) ??
+        (toolCall !== null ? record(toolCall.arguments) : null));
 }
 /**
  * Cursor preToolUse payloads sometimes omit `tool_name` even when the hook matcher
@@ -65,19 +70,50 @@ function inferCursorDirectWriteToolName(payload) {
         return "Write";
     return null;
 }
+export function hookPayloadTopLevelKeys(payload) {
+    const input = record(payload);
+    if (input === null)
+        return [];
+    return Object.keys(input).sort();
+}
 export function hookToolName(payload, host) {
     const input = record(payload);
     if (input === null)
         return null;
-    const direct = fieldString(input, "tool_name") ?? fieldString(input, "toolName") ?? fieldString(input, "tool");
+    const toolObject = record(input.tool);
+    const toolCall = record(input.tool_call) ?? record(input.toolCall);
+    // OpenAI-style nestings are host-agnostic; checked before Cursor-only inference.
+    const direct = fieldString(input, "tool_name") ??
+        fieldString(input, "toolName") ??
+        fieldString(input, "tool") ??
+        (toolObject !== null ? fieldString(toolObject, "name") : null) ??
+        (toolCall !== null ? fieldString(toolCall, "name") : null);
     if (direct !== null)
         return direct;
     if (host === "cursor")
         return inferCursorDirectWriteToolName(input);
     return null;
 }
-function missingToolNameMessage(host) {
+function missingToolNameMessage(input) {
+    const { host, payload, context } = input;
     if (host === "cursor") {
+        if (context?.stdinEmpty) {
+            return ("Directive denied this Cursor preToolUse event because the host sent an empty payload " +
+                "(stdin was empty — not a session ritual or scope failure). " +
+                "If write tools should pass, update Directive or report the payload shape from Cursor.");
+        }
+        if (context?.parseFailed) {
+            return ("Directive denied this Cursor preToolUse event because the host payload was not valid JSON " +
+                "(host-integration mismatch — not a session ritual or scope failure). " +
+                "If write tools should pass, update Directive or report the payload shape from Cursor.");
+        }
+        const keys = hookPayloadTopLevelKeys(payload);
+        if (keys.length > 0) {
+            return ("Directive denied this Cursor preToolUse event because the host payload omitted a " +
+                "recognizable tool name (host-integration mismatch — not a session ritual or scope failure). " +
+                `Top-level payload keys: ${keys.join(", ")}. ` +
+                "If write tools should pass, update Directive or report the payload shape from Cursor.");
+        }
         return ("Directive denied this Cursor preToolUse event because the host payload omitted a " +
             "recognizable tool name (host-integration mismatch — not a session ritual or scope failure). " +
             "If write tools should pass, update Directive or report the payload shape from Cursor.");
@@ -189,7 +225,11 @@ export function decideHook(input, seams = {}) {
     }
     const toolName = hookToolName(input.payload, input.host);
     if (toolName === null) {
-        return deny(input, "invalid-input", null, missingToolNameMessage(input.host));
+        return deny(input, "invalid-input", null, missingToolNameMessage({
+            host: input.host,
+            payload: input.payload,
+            context: input.payloadContext,
+        }));
     }
     if (!isDirectWriteTool(toolName)) {
         return {

package/dist/index.d.ts

@@ -13,6 +13,7 @@ export * as branch from "./branch/index.js";
 export * as cache from "./cache/index.js";
 export * as capacity from "./capacity/index.js";
 export * as codebase from "./codebase/index.js";
+export * from "./coverage-hotspots/index.js";
 export * as doctor from "./doctor/index.js";
 export * from "./encoding/index.js";
 export * as evalCrud from "./eval/crud-telemetry.js";

package/dist/index.js

@@ -13,6 +13,7 @@ export * as branch from "./branch/index.js";
 export * as cache from "./cache/index.js";
 export * as capacity from "./capacity/index.js";
 export * as codebase from "./codebase/index.js";
+export * from "./coverage-hotspots/index.js";
 export * as doctor from "./doctor/index.js";
 export * from "./encoding/index.js";
 export * as evalCrud from "./eval/crud-telemetry.js";

package/dist/init-deposit/xbrief-projections.d.ts

@@ -5,6 +5,13 @@
  * freshness. A current `.deft/core/VERSION` therefore cannot short-circuit
  * these repairs.
  */
+/** Rewrite legacy vbrief/.eval description paths for xbrief/schemas projection (#2670). */
+export declare function rewriteProjectedSchemaContent(content: string): string;
+/**
+ * Fail closed when a projected xbrief/schemas file still cites vbrief/.eval/.
+ * Upstream vbrief/schemas/ may keep legacy paths; consumer copies must not (#2670).
+ */
+export declare function assertProjectedSchemaDescriptionsRooted(projectDir: string, destinationDir: string): void;
 /**
  * Synchronize framework-owned xBRIEF schemas while preserving unknown consumer
  * files. The obsolete v0.6 root schema is the only destination-only file this

package/dist/init-deposit/xbrief-projections.js

@@ -13,6 +13,10 @@ import { DEV_FALLBACK } from "../platform/constants.js";
 import { MIGRATED_ARTIFACT_DIR } from "../xbrief-migrate/constants.js";
 const OBSOLETE_CORE_SCHEMA = "vbrief-core.schema.json";
 const CURRENT_CORE_SCHEMA = "xbrief-core-0.8.schema.json";
+/** Legacy lifecycle eval prefix in framework vbrief/schemas source copies. */
+const LEGACY_EVAL_PATH_PREFIX = "vbrief/.eval/";
+/** Consumer xbrief/schemas projection must root description paths here (#2670). */
+const XBRIEF_EVAL_PATH_PREFIX = "xbrief/.eval/";
 function normalizeVersion(version) {
     return version.trim().replace(/^v/, "");
 }
@@ -39,6 +43,28 @@ function collectSchemaFiles(root, dir = root, files = []) {
     }
     return files;
 }
+/** Rewrite legacy vbrief/.eval description paths for xbrief/schemas projection (#2670). */
+export function rewriteProjectedSchemaContent(content) {
+    return content.includes(LEGACY_EVAL_PATH_PREFIX)
+        ? content.replaceAll(LEGACY_EVAL_PATH_PREFIX, XBRIEF_EVAL_PATH_PREFIX)
+        : content;
+}
+/**
+ * Fail closed when a projected xbrief/schemas file still cites vbrief/.eval/.
+ * Upstream vbrief/schemas/ may keep legacy paths; consumer copies must not (#2670).
+ */
+export function assertProjectedSchemaDescriptionsRooted(projectDir, destinationDir) {
+    assertProjectionContained(projectDir, destinationDir);
+    if (!isDirectory(destinationDir))
+        return;
+    for (const rel of collectSchemaFiles(destinationDir)) {
+        const full = join(destinationDir, rel);
+        const text = readFileSync(full, "utf8");
+        if (text.includes(LEGACY_EVAL_PATH_PREFIX)) {
+            throw new Error(`projected xbrief schema still cites ${LEGACY_EVAL_PATH_PREFIX}: ${join(MIGRATED_ARTIFACT_DIR, "schemas", rel)}`);
+        }
+    }
+}
 function writeFileIfChanged(projectDir, target, content) {
     assertProjectionContained(projectDir, target);
     const desired = Buffer.isBuffer(content) ? content : Buffer.from(content, "utf8");
@@ -73,7 +99,8 @@ export function syncConsumerXbriefSchemas(projectDir, deftDir) {
             continue;
         const source = join(sourceDir, rel);
         const destination = join(destinationDir, rel);
-        changed = writeFileIfChanged(projectDir, destination, readFileSync(source)) || changed;
+        const projected = rewriteProjectedSchemaContent(readFileSync(source, "utf8"));
+        changed = writeFileIfChanged(projectDir, destination, projected) || changed;
     }
     const obsoleteDestination = join(destinationDir, OBSOLETE_CORE_SCHEMA);
     assertProjectionContained(projectDir, obsoleteDestination);
@@ -81,6 +108,7 @@ export function syncConsumerXbriefSchemas(projectDir, deftDir) {
         rmSync(obsoleteDestination, { force: true });
         changed = true;
     }
+    assertProjectedSchemaDescriptionsRooted(projectDir, destinationDir);
     return changed;
 }
 function syncBareVersionMarkerWithPolicy(projectDir, version, allowRootFallback) {

package/dist/integration-e2e/bootstrap-cache-module.d.ts

@@ -1,5 +1,3 @@
-import type { FetchAllReportImpl } from "../cache/fetch.js";
-import type { CacheModule } from "../triage/bootstrap/types.js";
-/** Adapt TS cache reports to the bootstrap `FetchAllReport` shape. */
-export declare function bootstrapCacheModule(cacheFetchAll: (options: Parameters<typeof import("../cache/fetch.js").cacheFetchAll>[0]) => FetchAllReportImpl): CacheModule;
+/** Re-export bootstrap TS cache adapter (canonical home: triage/bootstrap). */
+export { bootstrapCacheModule } from "../triage/bootstrap/cache-module.js";
 //# sourceMappingURL=bootstrap-cache-module.d.ts.map

package/dist/integration-e2e/bootstrap-cache-module.js

@@ -1,21 +1,3 @@
-/** Adapt TS cache reports to the bootstrap `FetchAllReport` shape. */
-export function bootstrapCacheModule(cacheFetchAll) {
-    return {
-        cacheFetchAll(kwargs) {
-            const report = cacheFetchAll({
-                source: kwargs.source,
-                repo: kwargs.repo,
-                batchSize: kwargs.batchSize,
-                delayMs: kwargs.delayMs,
-                cacheRoot: kwargs.cacheRoot,
-            });
-            return Promise.resolve({
-                succeeded: report.issuesWritten,
-                failed: report.issuesFailed,
-                skipped: report.alreadyFresh,
-                summaryLine: (source, repo) => report.summaryLine(source, repo),
-            });
-        },
-    };
-}
+/** Re-export bootstrap TS cache adapter (canonical home: triage/bootstrap). */
+export { bootstrapCacheModule } from "../triage/bootstrap/cache-module.js";
 //# sourceMappingURL=bootstrap-cache-module.js.map

package/dist/platform/resolve-version.d.ts

@@ -1,10 +1,6 @@
+import { isPublishable, NonPublishableVersionError, toPep440 } from "../release/version.js";
 import { DEV_FALLBACK, ENV_VAR } from "./constants.js";
-export { DEV_FALLBACK, ENV_VAR };
-export declare class NonPublishableVersionError extends Error {
-    constructor(message: string);
-}
-export declare function toPep440(version: string): string;
-export declare function isPublishable(version: string): boolean;
+export { DEV_FALLBACK, ENV_VAR, isPublishable, NonPublishableVersionError, toPep440 };
 export declare function tagNameFromRef(ref: string): string;
 export declare function latestPublishableTag(tags: Iterable<string>): string | null;
 export declare function payloadIsOwnGitRoot(payloadDir: string): boolean;