@deftai/directive-core 0.77.0 → 0.79.0

package/dist/vbrief-reconcile/repo-guard.js

@@ -0,0 +1,33 @@
+import { resolveRepo } from "../triage/queue/repo.js";
+/** Normalize owner/name slugs for case-insensitive comparison. */
+export function normalizeRepoSlug(repo) {
+    return repo.trim().toLowerCase();
+}
+/**
+ * Fail-closed gate before SCM label/comment mutations (#2601).
+ * Cross-repo targets are refused unless explicitly opted in or allowlisted.
+ */
+export function isRepoMutationAllowed(targetRepo, projectRoot, options = {}) {
+    const projectRepo = resolveRepo(options.explicitRepo ?? null, projectRoot);
+    if (options.allowCrossRepo) {
+        return { allowed: true, projectRepo };
+    }
+    const normalizedTarget = normalizeRepoSlug(targetRepo);
+    for (const entry of options.allowlist ?? []) {
+        if (normalizeRepoSlug(entry) === normalizedTarget) {
+            return { allowed: true, projectRepo };
+        }
+    }
+    if (projectRepo !== null && normalizeRepoSlug(projectRepo) === normalizedTarget) {
+        return { allowed: true, projectRepo };
+    }
+    const hint = projectRepo !== null
+        ? `(project repo: ${projectRepo})`
+        : "(project repo unknown — set --repo or git remote origin)";
+    return {
+        allowed: false,
+        projectRepo,
+        reason: `refusing cross-repo mutation on ${targetRepo} ${hint}`,
+    };
+}
+//# sourceMappingURL=repo-guard.js.map

package/dist/vbrief-reconcile/umbrellas.d.ts

@@ -41,6 +41,9 @@ export interface ReconcileUmbrellasOptions {
     readonly dryRun?: boolean;
     readonly client?: UmbrellaClient;
     readonly now?: string;
+    /** Opt in to mutating comments on issues outside the resolved project repo (#2601). */
+    readonly allowCrossRepo?: boolean;
+    readonly repoAllowlist?: readonly string[];
 }
 export declare function reconcileUmbrellas(projectRoot: string, options?: ReconcileUmbrellasOptions): [number, ReconcileUmbrellasOutcome];
 export declare function renderUmbrellasReport(outcome: ReconcileUmbrellasOutcome): string;

package/dist/vbrief-reconcile/umbrellas.js

@@ -5,6 +5,7 @@ import { createIssueComment, editIssueCommentBody, GitHubBodyError, } from "../i
 import { hasArtifactSuffix, resolveLifecycleRoot, stripArtifactSuffix } from "../layout/resolve.js";
 import { call } from "../scm/call.js";
 import { extractIssueRef } from "../triage/reconcile/parse-uri.js";
+import { isRepoMutationAllowed } from "./repo-guard.js";
 export const OPEN_FOLDERS = ["proposed", "pending", "active"];
 export const CLOSED_FOLDERS = ["completed", "cancelled"];
 export const LIFECYCLE_FOLDERS = [...OPEN_FOLDERS, ...CLOSED_FOLDERS];
@@ -261,6 +262,14 @@ function planShape(epicData, index) {
     return [openChildren, closedChildren, waves];
 }
 function reconcileOneEpic(epicData, index, options) {
+    const mutateGate = isRepoMutationAllowed(options.repo, options.projectRoot, {
+        allowCrossRepo: options.allowCrossRepo,
+        allowlist: options.repoAllowlist,
+        explicitRepo: options.explicitRepo ?? null,
+    });
+    if (!mutateGate.allowed) {
+        throw new Error(mutateGate.reason ?? `refusing cross-repo mutation on ${options.repo}`);
+    }
     const [openChildren, closedChildren, waves] = planShape(epicData, index);
     const total = openChildren.length + closedChildren.length;
     const comments = options.client.fetchComments(options.repo, options.number);
@@ -412,6 +421,10 @@ export function reconcileUmbrellas(projectRoot, options = {}) {
                     client,
                     dryRun: options.dryRun ?? false,
                     now,
+                    projectRoot: root,
+                    allowCrossRepo: options.allowCrossRepo ?? false,
+                    repoAllowlist: options.repoAllowlist,
+                    explicitRepo: options.repo ?? null,
                 });
                 if (change.action === "unchanged")
                     outcome.unchanged.push(change);
@@ -419,7 +432,10 @@ export function reconcileUmbrellas(projectRoot, options = {}) {
                     outcome.changed.push(change);
             }
             catch (exc) {
-                outcome.errors.push({ story_id: storyId, message: String(exc) });
+                outcome.errors.push({
+                    story_id: storyId,
+                    message: exc instanceof Error ? exc.message : String(exc),
+                });
             }
         }
     }

package/dist/verify-env/agent-hooks.d.ts

@@ -0,0 +1,11 @@
+import { type AgentHookInspection } from "../init-deposit/agent-hooks.js";
+import type { OutputStream } from "./verify-hooks-installed.js";
+export interface AgentHookHealthResult {
+    readonly code: 0 | 1 | 2;
+    readonly message: string;
+    readonly stream: OutputStream;
+    readonly registrations: readonly AgentHookInspection[];
+}
+/** Read-only P0 agent-host registration health, independent of git hooks. */
+export declare function evaluateAgentHooks(projectRoot: string): AgentHookHealthResult;
+//# sourceMappingURL=agent-hooks.d.ts.map

package/dist/verify-env/agent-hooks.js

@@ -0,0 +1,46 @@
+import { statSync } from "node:fs";
+import { resolve } from "node:path";
+import { inspectAgentHookDeposit } from "../init-deposit/agent-hooks.js";
+function isDirectory(path) {
+    try {
+        return statSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/** Read-only P0 agent-host registration health, independent of git hooks. */
+export function evaluateAgentHooks(projectRoot) {
+    const root = resolve(projectRoot);
+    if (!isDirectory(root)) {
+        return {
+            code: 2,
+            message: `❌ deft agent hooks: project root ${root} does not exist (config error).`,
+            stream: "stderr",
+            registrations: [],
+        };
+    }
+    const registrations = inspectAgentHookDeposit(root);
+    const unhealthy = registrations.filter((entry) => entry.status !== "healthy");
+    if (unhealthy.length > 0) {
+        return {
+            code: 1,
+            message: "❌ deft agent hook registration INCOMPLETE:\n" +
+                unhealthy
+                    .map((entry) => `  - ${entry.host}: ${entry.status} at ${entry.path} — ${entry.detail}`)
+                    .join("\n") +
+                "\n  Recovery: run `deft update` (or `directive init`) to refresh project hooks.",
+            stream: "stderr",
+            registrations,
+        };
+    }
+    return {
+        code: 0,
+        message: "✓ deft agent hooks registered and structurally valid for Claude, Grok, Cursor, Codex " +
+            "(SessionStart + PreToolUse direct-write tools only; Codex runtime trust is " +
+            "user-controlled and must be reviewed with `/hooks`; shell/MCP policy is deferred).",
+        stream: "stdout",
+        registrations,
+    };
+}
+//# sourceMappingURL=agent-hooks.js.map

package/dist/verify-env/command-spawn.d.ts

@@ -6,6 +6,11 @@ export interface ResolveCommandOnPathOptions {
 }
 /** Windows command shims (.cmd/.bat) need a shell; native executables do not. */
 export declare function shouldUseShellForCommand(command: string, platform?: NodeJS.Platform): boolean;
+/**
+ * Quote a win32 executable path for `shell: true` spawns when it contains spaces.
+ * Without quoting, cmd.exe treats `C:\Program` as the command (#2555).
+ */
+export declare function quoteWin32CommandForShell(command: string, platform?: NodeJS.Platform): string;
 /**
  * Resolve an executable on PATH with PATHEXT / Path awareness (#2467 / #2548).
  * Mirrors ts-check-lane `resolvePnpm` and verify-tools `defaultProbe`.

package/dist/verify-env/command-spawn.js

@@ -6,6 +6,20 @@ import { SUBPROCESS_MAX_BUFFER } from "../subprocess/max-buffer.js";
 export function shouldUseShellForCommand(command, platform = process.platform) {
     return platform === "win32" && /\.(?:cmd|bat)$/i.test(command);
 }
+/**
+ * Quote a win32 executable path for `shell: true` spawns when it contains spaces.
+ * Without quoting, cmd.exe treats `C:\Program` as the command (#2555).
+ */
+export function quoteWin32CommandForShell(command, platform = process.platform) {
+    if (platform !== "win32" || !command.includes(" ")) {
+        return command;
+    }
+    if ((command.startsWith('"') && command.endsWith('"')) ||
+        (command.startsWith("'") && command.endsWith("'"))) {
+        return command;
+    }
+    return `"${command}"`;
+}
 /**
  * Resolve an executable on PATH with PATHEXT / Path awareness (#2467 / #2548).
  * Mirrors ts-check-lane `resolvePnpm` and verify-tools `defaultProbe`.
@@ -39,15 +53,20 @@ export function resolveCommandOnPath(command, options = {}) {
  * Retries with `shell: true` on win32 ENOENT (npm global `.cmd` shims).
  */
 export function spawnCommandText(cmd, args, options = {}) {
-    const trySpawn = (shell) => spawnSync(cmd, [...args], {
-        cwd: options.cwd,
-        env: options.env ?? process.env,
-        encoding: "utf8",
-        timeout: options.timeoutMs,
-        maxBuffer: SUBPROCESS_MAX_BUFFER,
-        stdio: ["ignore", "pipe", "pipe"],
-        shell,
-    });
+    const trySpawn = (shell) => {
+        const spawnCmd = shell && process.platform === "win32" ? quoteWin32CommandForShell(cmd) : cmd;
+        return spawnSync(spawnCmd, [...args], {
+            cwd: options.cwd,
+            env: options.env ?? process.env,
+            encoding: "utf8",
+            timeout: options.timeoutMs,
+            maxBuffer: SUBPROCESS_MAX_BUFFER,
+            stdio: ["ignore", "pipe", "pipe"],
+            shell,
+            // CREATE_NO_WINDOW on win32; harmless elsewhere (#2563).
+            windowsHide: true,
+        });
+    };
     let result = trySpawn(shouldUseShellForCommand(cmd));
     const spawnErr = result.error;
     if (spawnErr?.code === "ENOENT" && process.platform === "win32") {

package/dist/verify-env/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./agent-hooks.js";
 export * from "./command-spawn.js";
 export * from "./node-runtime.js";
 export * from "./toolchain-check.js";

package/dist/verify-env/index.js

@@ -1,3 +1,4 @@
+export * from "./agent-hooks.js";
 export * from "./command-spawn.js";
 export * from "./node-runtime.js";
 export * from "./toolchain-check.js";

package/dist/verify-env/verify-hooks-installed.js

@@ -134,7 +134,7 @@ export function evaluate(projectRoot, options = {}) {
         return {
             code: 1,
             message: "❌ deft hooks not installed: core.hooksPath is unset.\n" +
-                "  Recovery: run `task setup` (or re-run the deft installer).",
+                "  Recovery: run `deft update` to deposit project-root `.githooks/`, then `task setup` to wire core.hooksPath.",
             stream: "stderr",
         };
     }
@@ -147,7 +147,7 @@ export function evaluate(projectRoot, options = {}) {
             code: 1,
             message: `❌ deft hooks wired but NON-FUNCTIONAL: core.hooksPath=${hooksPath} ` +
                 `but the directory ${hooksDir} does not exist (#1463 false-green).\n` +
-                "  Recovery: re-run the deft installer / `task setup` to deposit the hooks.",
+                "  Recovery: run `deft update` to deposit project-root `.githooks/`, then `task setup` to wire core.hooksPath.",
             stream: "stderr",
         };
     }
@@ -157,7 +157,7 @@ export function evaluate(projectRoot, options = {}) {
             code: 1,
             message: `❌ deft hooks wired but NON-FUNCTIONAL: ${hooksDir} is missing ` +
                 `${missingHooks.join(", ")} (#1463 false-green).\n` +
-                "  Recovery: re-run the deft installer / `task setup`.",
+                "  Recovery: run `deft update` to deposit project-root `.githooks/`, then `task setup` to wire core.hooksPath.",
             stream: "stderr",
         };
     }
@@ -169,7 +169,7 @@ export function evaluate(projectRoot, options = {}) {
                 message: `❌ deft hooks wired but NON-FUNCTIONAL: ${hooksDir} hook(s) ` +
                     `${nonExec.join(", ")} are not executable (git mode is not ` +
                     "100755); git silently skips non-executable hooks on Unix (#1477).\n" +
-                    "  Recovery: re-run the deft installer / `task setup`, or " +
+                    "  Recovery: run `deft update` to refresh `.githooks/`, or " +
                     "`chmod +x .githooks/pre-commit .githooks/pre-push`.",
                 stream: "stderr",
             };
@@ -198,7 +198,7 @@ export function evaluate(projectRoot, options = {}) {
             message: "❌ deft hooks wired but NON-FUNCTIONAL:\n" +
                 contentIssues.map((issue) => `  - ${issue.replace(/\r?\n/g, " ")}`).join("\n") +
                 "\n" +
-                "  Recovery: re-run the deft installer / `task setup` to refresh .githooks/.",
+                "  Recovery: run `deft update` to refresh project-root `.githooks/`.",
             stream: "stderr",
         };
     }

package/dist/vitest-runner/coverage-debt-teardown.d.ts

@@ -0,0 +1,3 @@
+/** Vitest globalTeardown: enforce coverage goal or debt soft-pass (#2573). */
+export default function coverageDebtTeardown(): Promise<void>;
+//# sourceMappingURL=coverage-debt-teardown.d.ts.map

package/dist/vitest-runner/coverage-debt-teardown.js

@@ -0,0 +1,33 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { COVERAGE_GOAL, countRecentCoverageDebtMentions, formatCoverageAttribution, formatOveruseWarning, metricsBelowGoal, readCoverageTotalsFromReport, resolveCoverageDebtIssue, } from "./coverage-debt.js";
+/** Vitest globalTeardown: enforce coverage goal or debt soft-pass (#2573). */
+export default async function coverageDebtTeardown() {
+    const resolution = resolveCoverageDebtIssue(process.argv, process.env);
+    if (resolution.kind === "none")
+        return;
+    if (resolution.kind === "invalid") {
+        throw new Error(`coverage-debt: ${resolution.reason}`);
+    }
+    const repoRoot = join(import.meta.dirname, "..", "..", "..", "..");
+    const totals = readCoverageTotalsFromReport(join(repoRoot, "coverage"));
+    if (totals === null) {
+        throw new Error("coverage-debt: could not read coverage/coverage-final.json");
+    }
+    const missed = metricsBelowGoal(totals);
+    if (missed.length === 0) {
+        process.stderr.write(`coverage-debt: note — --allow-coverage-debt=#${resolution.issue} set but all metrics meet the ${COVERAGE_GOAL.branches}% goal\n`);
+        return;
+    }
+    process.stderr.write(`${formatCoverageAttribution(resolution.issue, totals)}\n`);
+    try {
+        const changelog = readFileSync(join(repoRoot, "CHANGELOG.md"), "utf8");
+        const overuse = formatOveruseWarning(countRecentCoverageDebtMentions(changelog));
+        if (overuse)
+            process.stderr.write(`${overuse}\n`);
+    }
+    catch {
+        // CHANGELOG unreadable — debt attribution still stands.
+    }
+}
+//# sourceMappingURL=coverage-debt-teardown.js.map

package/dist/vitest-runner/coverage-debt.d.ts

@@ -0,0 +1,50 @@
+/** Shared coverage goal (vitest thresholds). */
+export declare const COVERAGE_GOAL: {
+    readonly lines: 85;
+    readonly functions: 85;
+    readonly branches: 85;
+    readonly statements: 85;
+};
+export type CoverageMetric = keyof typeof COVERAGE_GOAL;
+export interface CoverageTotals {
+    readonly lines: number;
+    readonly functions: number;
+    readonly branches: number;
+    readonly statements: number;
+}
+export type CoverageDebtResolution = {
+    readonly kind: "none";
+} | {
+    readonly kind: "valid";
+    readonly issue: number;
+} | {
+    readonly kind: "invalid";
+    readonly reason: string;
+};
+/** Parse `#2573`, `2573`, or bare numeric strings. */
+export declare function parseCoverageDebtIssueNumber(raw: string): number | null;
+/** Parse `--allow-coverage-debt=#N` tokens from argv. */
+export declare function parseCoverageDebtArgv(argv: readonly string[]): CoverageDebtResolution;
+/**
+ * Resolve coverage-debt issue from argv or release-scoped env (#2573 / #1553).
+ * Raw env bypass is accepted only during release Step-5 preflight.
+ */
+export declare function resolveCoverageDebtIssue(argv: readonly string[], env?: NodeJS.ProcessEnv): CoverageDebtResolution;
+interface IstanbulBranchHits {
+    readonly [branchId: string]: readonly number[];
+}
+interface IstanbulFileCoverage {
+    readonly s?: Readonly<Record<string, number>>;
+    readonly f?: Readonly<Record<string, number>>;
+    readonly b?: IstanbulBranchHits;
+}
+/** Aggregate global coverage percentages from istanbul coverage-final.json. */
+export declare function summarizeCoverageFinal(coverageFinal: Readonly<Record<string, IstanbulFileCoverage>>): CoverageTotals;
+export declare function readCoverageTotalsFromReport(coverageDir: string): CoverageTotals | null;
+export declare function metricsBelowGoal(totals: CoverageTotals): CoverageMetric[];
+export declare function formatCoverageAttribution(issue: number, totals: CoverageTotals): string;
+/** Count recent release sections citing coverage-debt (CHANGELOG scan). */
+export declare function countRecentCoverageDebtMentions(changelog: string, maxSections?: number): number;
+export declare function formatOveruseWarning(recentCount: number): string | null;
+export {};
+//# sourceMappingURL=coverage-debt.d.ts.map

package/dist/vitest-runner/coverage-debt.js

@@ -0,0 +1,155 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+/** Shared coverage goal (vitest thresholds). */
+export const COVERAGE_GOAL = {
+    lines: 85,
+    functions: 85,
+    branches: 85,
+    statements: 85,
+};
+const DEBT_FLAG = "--allow-coverage-debt";
+const DEBT_ENV = "DEFT_ALLOW_COVERAGE_DEBT";
+const RELEASE_PREFLIGHT_ENV = "DEFT_RELEASE_PREFLIGHT";
+/** Parse `#2573`, `2573`, or bare numeric strings. */
+export function parseCoverageDebtIssueNumber(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return null;
+    const normalized = trimmed.startsWith("#") ? trimmed.slice(1) : trimmed;
+    if (!/^\d+$/.test(normalized))
+        return null;
+    const issue = Number.parseInt(normalized, 10);
+    return Number.isFinite(issue) && issue > 0 ? issue : null;
+}
+/** Parse `--allow-coverage-debt=#N` tokens from argv. */
+export function parseCoverageDebtArgv(argv) {
+    for (let i = 0; i < argv.length; i += 1) {
+        const token = argv[i] ?? "";
+        if (token === DEBT_FLAG) {
+            const next = argv[i + 1];
+            if (next === undefined || next.startsWith("-")) {
+                return { kind: "invalid", reason: `${DEBT_FLAG} requires an issue number (#N)` };
+            }
+            const issue = parseCoverageDebtIssueNumber(next);
+            return issue === null
+                ? { kind: "invalid", reason: `${DEBT_FLAG} value must be #N or N` }
+                : { kind: "valid", issue };
+        }
+        if (token.startsWith(`${DEBT_FLAG}=`)) {
+            const value = token.slice(DEBT_FLAG.length + 1);
+            const issue = parseCoverageDebtIssueNumber(value);
+            return issue === null
+                ? { kind: "invalid", reason: `${DEBT_FLAG}= value must be #N or N` }
+                : { kind: "valid", issue };
+        }
+    }
+    return { kind: "none" };
+}
+/**
+ * Resolve coverage-debt issue from argv or release-scoped env (#2573 / #1553).
+ * Raw env bypass is accepted only during release Step-5 preflight.
+ */
+export function resolveCoverageDebtIssue(argv, env = process.env) {
+    const fromArgv = parseCoverageDebtArgv(argv);
+    if (fromArgv.kind !== "none")
+        return fromArgv;
+    const rawEnv = env[DEBT_ENV];
+    if (rawEnv && env[RELEASE_PREFLIGHT_ENV] === "1") {
+        const issue = parseCoverageDebtIssueNumber(rawEnv);
+        return issue === null
+            ? { kind: "invalid", reason: `${DEBT_ENV} must be a positive integer` }
+            : { kind: "valid", issue };
+    }
+    return { kind: "none" };
+}
+/** Aggregate global coverage percentages from istanbul coverage-final.json. */
+export function summarizeCoverageFinal(coverageFinal) {
+    let stmtTotal = 0;
+    let stmtCovered = 0;
+    let fnTotal = 0;
+    let fnCovered = 0;
+    let branchTotal = 0;
+    let branchCovered = 0;
+    for (const file of Object.values(coverageFinal)) {
+        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 pct = (covered, total) => total === 0 ? 100 : (covered / total) * 100;
+    const statements = pct(stmtCovered, stmtTotal);
+    const functions = pct(fnCovered, fnTotal);
+    const branches = pct(branchCovered, branchTotal);
+    // Istanbul coverage-final.json does not carry pre-aggregated line hit counts —
+    // `l` (line map) is optional and its format differs from `s`/`f`/`b`. Using
+    // statements as a proxy may overstate line coverage when multiple statements
+    // share a single uncovered line.
+    return {
+        statements,
+        functions,
+        branches,
+        lines: statements, // approximation: actual line coverage may differ
+    };
+}
+export function readCoverageTotalsFromReport(coverageDir) {
+    const finalPath = join(coverageDir, "coverage-final.json");
+    try {
+        const raw = readFileSync(finalPath, "utf8");
+        const parsed = JSON.parse(raw);
+        return summarizeCoverageFinal(parsed);
+    }
+    catch {
+        return null;
+    }
+}
+export function metricsBelowGoal(totals) {
+    const missed = [];
+    for (const metric of Object.keys(COVERAGE_GOAL)) {
+        if (totals[metric] + 1e-9 < COVERAGE_GOAL[metric]) {
+            missed.push(metric);
+        }
+    }
+    return missed;
+}
+const sanitizeMetric = (value) => String(value).replace(/\r?\n/g, " ");
+export function formatCoverageAttribution(issue, totals) {
+    const lines = [
+        `coverage-debt: soft-pass acknowledged for issue #${issue}`,
+        `  measured: branches ${sanitizeMetric(totals.branches.toFixed(2))}% | lines ${sanitizeMetric(totals.lines.toFixed(2))}% | functions ${sanitizeMetric(totals.functions.toFixed(2))}% | statements ${sanitizeMetric(totals.statements.toFixed(2))}%`,
+        `  goal:     branches ${sanitizeMetric(COVERAGE_GOAL.branches)}% | lines ${sanitizeMetric(COVERAGE_GOAL.lines)}% | functions ${sanitizeMetric(COVERAGE_GOAL.functions)}% | statements ${sanitizeMetric(COVERAGE_GOAL.statements)}%`,
+    ];
+    return lines.join("\n");
+}
+/** Count recent release sections citing coverage-debt (CHANGELOG scan). */
+export function countRecentCoverageDebtMentions(changelog, maxSections = 5) {
+    const versionHeader = /^## \[(?!Unreleased)/m;
+    const sections = changelog.split(versionHeader).slice(1, maxSections + 1);
+    const pattern = /coverage[- ]debt soft[- ]pass|allow-coverage-debt=#?\d/i;
+    return sections.filter((section) => pattern.test(section)).length;
+}
+export function formatOveruseWarning(recentCount) {
+    if (recentCount < 2)
+        return null;
+    return (`coverage-debt WARN: ${recentCount} of the last release sections already cite coverage debt — ` +
+        "consider restoring real coverage instead of reusing the escape hatch.");
+}
+//# sourceMappingURL=coverage-debt.js.map

package/dist/vitest-runner/win32-coverage-tmp-setup.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Win32 globalSetup for coverage runs (#2580).
+ *
+ * Vitest's v8 provider writes per-suite JSON under coverage/.tmp without always
+ * re-mkdir'ing before writeFile. Under parallel fork load the directory can
+ * disappear mid-suite, surfacing as ENOENT after an otherwise green run.
+ * Keep the directory present for the coordinator process; late ENOENT flakes
+ * are tolerated via vitest dangerouslyIgnoreUnhandledErrors (#2546) without
+ * soft-failing real coverage threshold failures.
+ */
+export default function setup(): void;
+//# sourceMappingURL=win32-coverage-tmp-setup.d.ts.map

package/dist/vitest-runner/win32-coverage-tmp-setup.js

@@ -0,0 +1,24 @@
+import { mkdirSync } from "node:fs";
+import { resolve } from "node:path";
+const COVERAGE_TMP = resolve(process.cwd(), "coverage", ".tmp");
+function ensureCoverageTmpDir() {
+    mkdirSync(COVERAGE_TMP, { recursive: true });
+}
+/**
+ * Win32 globalSetup for coverage runs (#2580).
+ *
+ * Vitest's v8 provider writes per-suite JSON under coverage/.tmp without always
+ * re-mkdir'ing before writeFile. Under parallel fork load the directory can
+ * disappear mid-suite, surfacing as ENOENT after an otherwise green run.
+ * Keep the directory present for the coordinator process; late ENOENT flakes
+ * are tolerated via vitest dangerouslyIgnoreUnhandledErrors (#2546) without
+ * soft-failing real coverage threshold failures.
+ */
+export default function setup() {
+    if (process.platform !== "win32")
+        return;
+    ensureCoverageTmpDir();
+    const keepalive = setInterval(ensureCoverageTmpDir, 100);
+    keepalive.unref?.();
+}
+//# sourceMappingURL=win32-coverage-tmp-setup.js.map

package/dist/xbrief-migrate/detect.js

@@ -33,6 +33,51 @@ function walkJsonFiles(root, acc = []) {
     }
     return acc;
 }
+/** Cache support state may contain only ordinary files/directories, never links or special files. */
+function containsUnsupportedCacheEntry(root) {
+    if (!isDirectory(root))
+        return false;
+    for (const entry of readdirSync(root, { withFileTypes: true })) {
+        if (entry.isSymbolicLink())
+            return true;
+        if (entry.isDirectory()) {
+            if (containsUnsupportedCacheEntry(join(root, entry.name)))
+                return true;
+            continue;
+        }
+        if (!entry.isFile())
+            return true;
+    }
+    return false;
+}
+/**
+ * A top-level `.triage-cache/` is operational support state, not evidence that
+ * project artifacts have already migrated. Everything else keeps the generic
+ * empty-tree semantics; unknown files and symlinks remain real content.
+ */
+function xbriefHasProjectContent(root) {
+    if (!isDirectory(root))
+        return false;
+    for (const entry of readdirSync(root, { withFileTypes: true })) {
+        const full = join(root, entry.name);
+        if (entry.name === ".triage-cache" && entry.isDirectory()) {
+            if (containsUnsupportedCacheEntry(full))
+                return true;
+            continue;
+        }
+        if (entry.isSymbolicLink())
+            return true;
+        if (entry.isDirectory()) {
+            if (!isEffectivelyEmptyDir(full))
+                return true;
+            continue;
+        }
+        if (entry.isFile() && (entry.name === ".gitkeep" || entry.name === ".keep"))
+            continue;
+        return true;
+    }
+    return false;
+}
 function scanFileContent(path, content, reasons) {
     if (path.endsWith(LEGACY_ARTIFACT_SUFFIX)) {
         reasons.add(`legacy artifact filename: ${path}`);
@@ -94,7 +139,7 @@ export function detectXbriefConvergence(projectRoot) {
     const vbriefHasMarker = vbriefPresent && hasVbriefDeprecationMarker(legacyDir);
     const vbriefEmpty = vbriefPresent && !vbriefHasMarker && isEffectivelyEmptyDir(legacyDir);
     const xbriefPresent = isDirectory(migratedDir);
-    const xbriefHasContent = xbriefPresent && !isEffectivelyEmptyDir(migratedDir);
+    const xbriefHasContent = xbriefPresent && xbriefHasProjectContent(migratedDir);
     let state;
     if (vbriefHasMarker) {
         state = "xbrief-marker";