@deftai/directive-core 0.55.0

package/dist/triage/welcome/summary.js

@@ -0,0 +1,303 @@
+import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { countVbriefWip, DEFAULT_WIP_CAP, resolveWipCap } from "../../policy/wip.js";
+import { countReconcilable } from "../reconcile/reconcile.js";
+import { computeDrift } from "../scope-drift/compute.js";
+import { CACHE_DIR_NAME, CACHE_SOURCE, EMPTY_CACHE_LINE, MAX_LINE_CHARS, SUMMARY_HISTORY_REL_PATH, SUMMARY_HISTORY_SCHEMA, WIP_WARN_GLYPH, } from "./constants.js";
+const CANDIDATES_LOG_REL_PATH = "vbrief/.eval/candidates.jsonl";
+const FILESYSTEM_IN_FLIGHT_STATUS = "running";
+const TRIAGED_DECISIONS = new Set([
+    "accept",
+    "reject",
+    "defer",
+    "needs-ac",
+    "mark-duplicate",
+    "resume-eligible",
+]);
+const IN_FLIGHT_DECISIONS = new Set(["accept"]);
+const STALE_DEFER_DECISIONS = new Set(["resume-eligible"]);
+function iterCachedIssues(cacheRoot) {
+    const base = join(cacheRoot, CACHE_SOURCE);
+    if (!existsSync(base))
+        return [];
+    const out = [];
+    for (const owner of readdirSync(base, { withFileTypes: true }).filter((d) => d.isDirectory())) {
+        const ownerPath = join(base, owner.name);
+        for (const repo of readdirSync(ownerPath, { withFileTypes: true }).filter((d) => d.isDirectory())) {
+            const repoPath = join(ownerPath, repo.name);
+            const repoSlug = `${owner.name}/${repo.name}`;
+            for (const issue of readdirSync(repoPath, { withFileTypes: true }).filter((d) => d.isDirectory() && /^\d+$/.test(d.name))) {
+                out.push([repoSlug, Number(issue.name)]);
+            }
+        }
+    }
+    return out.sort(([aR, aN], [bR, bN]) => aR.localeCompare(bR) || aN - bN);
+}
+function readAuditLog(logPath) {
+    if (!existsSync(logPath))
+        return [];
+    let text;
+    try {
+        text = readFileSync(logPath, "utf8");
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const raw of text.split("\n")) {
+        const stripped = raw.trim();
+        if (!stripped)
+            continue;
+        try {
+            const obj = JSON.parse(stripped);
+            if (typeof obj === "object" && obj !== null && !Array.isArray(obj)) {
+                out.push(obj);
+            }
+        }
+        catch { }
+    }
+    return out;
+}
+function latestDecisions(entries) {
+    const out = new Map();
+    for (const entry of entries) {
+        const repo = entry.repo;
+        const num = entry.issue_number;
+        const decision = entry.decision;
+        if (typeof repo === "string" && typeof num === "number" && typeof decision === "string") {
+            out.set(`${repo}:${num}`, decision);
+        }
+    }
+    return out;
+}
+function countFilesystemInFlight(projectRoot) {
+    const activeDir = join(resolve(projectRoot), "vbrief", "active");
+    if (!existsSync(activeDir))
+        return 0;
+    let count = 0;
+    for (const name of readdirSync(activeDir)) {
+        if (!name.endsWith(".vbrief.json"))
+            continue;
+        try {
+            const data = JSON.parse(readFileSync(join(activeDir, name), "utf8"));
+            const plan = data.plan;
+            if (typeof plan === "object" && plan !== null && !Array.isArray(plan)) {
+                if (plan.status === FILESYSTEM_IN_FLIGHT_STATUS)
+                    count += 1;
+            }
+        }
+        catch { }
+    }
+    return count;
+}
+function isTriageScopeConfigured(projectRoot) {
+    const path = join(resolve(projectRoot), "vbrief", "PROJECT-DEFINITION.vbrief.json");
+    if (!existsSync(path))
+        return false;
+    try {
+        const data = JSON.parse(readFileSync(path, "utf8"));
+        const plan = data.plan;
+        if (typeof plan !== "object" || plan === null || Array.isArray(plan))
+            return false;
+        const scope = plan.policy;
+        if (typeof scope !== "object" || scope === null || Array.isArray(scope))
+            return false;
+        const triageScope = scope.triageScope;
+        return (Array.isArray(triageScope) &&
+            triageScope.length > 0 &&
+            triageScope.every((r) => typeof r === "object" && r !== null));
+    }
+    catch {
+        return false;
+    }
+}
+function utcIso() {
+    return new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
+}
+export function computeSummary(projectRoot) {
+    const root = resolve(projectRoot);
+    const cacheRoot = join(root, CACHE_DIR_NAME);
+    const logPath = join(root, CANDIDATES_LOG_REL_PATH);
+    const cached = iterCachedIssues(cacheRoot);
+    const repos = [...new Set(cached.map(([r]) => r))].sort().slice(0, 8);
+    const wipCapResult = resolveWipCap(root);
+    const wipCap = wipCapResult.cap;
+    const wipCount = countVbriefWip(root);
+    const inFlightFilesystem = countFilesystemInFlight(root);
+    const triageScopeConfigured = isTriageScopeConfigured(root);
+    if (cached.length === 0) {
+        return {
+            cacheEmpty: true,
+            untriaged: 0,
+            staleDefer: 0,
+            inFlight: inFlightFilesystem,
+            wipCount,
+            wipCap,
+            repos,
+            scopeDrift: 0,
+            inFlightFilesystem,
+            inFlightCacheScoped: 0,
+            triageScopeConfigured,
+            reconcilable: 0,
+        };
+    }
+    const decisions = latestDecisions(readAuditLog(logPath));
+    let untriaged = 0;
+    let inFlightCacheScoped = 0;
+    let staleDefer = 0;
+    const noDecisionKeys = [];
+    for (const [repo, issueNumber] of cached) {
+        const key = `${repo}:${issueNumber}`;
+        const decision = decisions.get(key);
+        if (decision === undefined || decision === "reset" || !TRIAGED_DECISIONS.has(decision)) {
+            untriaged += 1;
+        }
+        if (decision === undefined)
+            noDecisionKeys.push([repo, issueNumber]);
+        else if (IN_FLIGHT_DECISIONS.has(decision))
+            inFlightCacheScoped += 1;
+        if (decision !== undefined && STALE_DEFER_DECISIONS.has(decision))
+            staleDefer += 1;
+    }
+    let scopeDrift = 0;
+    try {
+        scopeDrift = computeDrift(root, { cacheRoot }).total;
+    }
+    catch {
+        scopeDrift = 0;
+    }
+    let reconcilable = 0;
+    try {
+        const repoSet = new Set(noDecisionKeys.map(([r]) => r));
+        const defaultRepo = repoSet.size === 1 ? ([...repoSet][0] ?? null) : null;
+        reconcilable = countReconcilable(root, {
+            defaultRepo,
+            auditLogPath: logPath,
+            restrictTo: noDecisionKeys,
+        });
+    }
+    catch {
+        reconcilable = 0;
+    }
+    return {
+        cacheEmpty: false,
+        untriaged,
+        staleDefer,
+        inFlight: inFlightFilesystem,
+        wipCount,
+        wipCap,
+        repos,
+        scopeDrift,
+        inFlightFilesystem,
+        inFlightCacheScoped,
+        triageScopeConfigured,
+        reconcilable,
+    };
+}
+function truncate(text, maxChars) {
+    if (text.length <= maxChars)
+        return text;
+    if (maxChars <= 3)
+        return text.slice(0, maxChars);
+    return `${text.slice(0, maxChars - 3)}...`;
+}
+export function formatOneLiner(result, maxChars = MAX_LINE_CHARS) {
+    if (result.cacheEmpty)
+        return truncate(EMPTY_CACHE_LINE, maxChars);
+    const parts = [`[triage] ${result.untriaged} untriaged`];
+    if (result.staleDefer >= 1) {
+        parts.push(`${result.staleDefer} stale-defer (resume condition met)`);
+    }
+    parts.push(`${result.inFlight} in-flight`);
+    let wipField = `WIP ${result.wipCount}/${result.wipCap}`;
+    if (result.wipCount >= result.wipCap)
+        wipField = `${wipField} ${WIP_WARN_GLYPH}`;
+    parts.push(wipField);
+    if (result.scopeDrift > 0)
+        parts.push(`[scope-drift] ${result.scopeDrift}`);
+    let candidate = parts.join(" \u00b7 ");
+    if (candidate.length <= maxChars)
+        return candidate;
+    if (wipField.includes(WIP_WARN_GLYPH)) {
+        const rebuilt = [...parts.slice(0, -1), `WIP ${result.wipCount}/${result.wipCap}`];
+        candidate = rebuilt.join(" \u00b7 ");
+        if (candidate.length <= maxChars)
+            return candidate;
+    }
+    if (result.staleDefer >= 1) {
+        candidate = [
+            `[triage] ${result.untriaged} untriaged`,
+            `${result.inFlight} in-flight`,
+            `WIP ${result.wipCount}/${result.wipCap}`,
+        ].join(" \u00b7 ");
+        if (candidate.length <= maxChars)
+            return candidate;
+    }
+    return truncate(candidate, maxChars);
+}
+function formatScopeDiscrepancyLine(result) {
+    if (result.cacheEmpty)
+        return null;
+    const delta = Math.abs(result.inFlightFilesystem - result.inFlightCacheScoped);
+    if (delta === 0)
+        return null;
+    if (result.triageScopeConfigured) {
+        return `[triage:scope] ${delta} in-flight outside plan.policy.triageScope[] (uncounted in queue ranking)`;
+    }
+    return `[triage:scope] ${delta} in-flight; plan.policy.triageScope[] not configured (uncounted in queue ranking)`;
+}
+function formatReconcileHintLine(result) {
+    if (result.cacheEmpty || result.reconcilable <= 0)
+        return null;
+    return (`[triage:reconcile] ${result.reconcilable} accepted on disk but missing from the audit log -- ` +
+        "run `task triage:reconcile` to restore");
+}
+export function formatSummary(result, maxChars = MAX_LINE_CHARS) {
+    const lines = [formatOneLiner(result, maxChars)];
+    const scopeLine = formatScopeDiscrepancyLine(result);
+    if (scopeLine)
+        lines.push(scopeLine);
+    const reconcileLine = formatReconcileHintLine(result);
+    if (reconcileLine)
+        lines.push(reconcileLine);
+    return lines.join("\n");
+}
+export function appendHistory(historyPath, result, line) {
+    const record = {
+        schema: SUMMARY_HISTORY_SCHEMA,
+        emitted_at: utcIso(),
+        line,
+        cache_empty: result.cacheEmpty,
+        untriaged: result.untriaged,
+        stale_defer: result.staleDefer,
+        in_flight: result.inFlight,
+        in_flight_filesystem: result.inFlightFilesystem,
+        in_flight_cache_scoped: result.inFlightCacheScoped,
+        triage_scope_configured: result.triageScopeConfigured,
+        wip_count: result.wipCount,
+        wip_cap: result.wipCap,
+        repos: [...result.repos],
+        scope_drift: result.scopeDrift,
+        reconcilable: result.reconcilable,
+    };
+    try {
+        mkdirSync(join(historyPath, ".."), { recursive: true });
+        appendFileSync(historyPath, `${JSON.stringify(record)}\n`, "utf8");
+    }
+    catch {
+        // observability only
+    }
+}
+export function emitOneliner(projectRoot, options = {}) {
+    const result = computeSummary(projectRoot);
+    const line = formatSummary(result);
+    const out = options.output ?? ((l) => process.stdout.write(`${l}\n`));
+    for (const physicalLine of line.split("\n")) {
+        out(physicalLine);
+    }
+    if (options.writeHistory !== false) {
+        appendHistory(join(resolve(projectRoot), SUMMARY_HISTORY_REL_PATH), result, line);
+    }
+    return line;
+}
+//# sourceMappingURL=summary.js.map

package/dist/triage/welcome/writers.d.ts

@@ -0,0 +1,17 @@
+export declare function appendAuditEntry(projectRoot: string, entry: string): string;
+export declare function writeTriageScope(projectRoot: string, rules: Array<Record<string, unknown>>, options?: {
+    presetLabel: string;
+    actor?: string;
+}): [boolean, string];
+export declare function writeWipCap(projectRoot: string, wipCap: number, options?: {
+    actor?: string;
+}): [boolean, string];
+export interface ReliefPreview {
+    readonly olderThanDays: number;
+    readonly eligibleCount: number;
+    readonly eligibleFiles: readonly string[];
+    readonly skippedCount: number;
+}
+export declare function previewWipRelief(projectRoot: string, olderThanDays?: number): ReliefPreview;
+export declare function subscriptionPreset(key: string): Array<Record<string, unknown>>;
+//# sourceMappingURL=writers.d.ts.map

package/dist/triage/welcome/writers.js

@@ -0,0 +1,157 @@
+import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync, renameSync, statSync, writeFileSync, } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { AUDIT_LOG_REL_PATH, DEFAULT_RELIEF_AGE_DAYS, DEFAULT_WIP_CAP, PROJECT_DEFINITION_REL_PATH, SUBSCRIPTION_PRESETS, WELCOME_AUDIT_TAG, } from "./constants.js";
+function projectDefinitionPath(projectRoot) {
+    return join(resolve(projectRoot), PROJECT_DEFINITION_REL_PATH);
+}
+function utcIso() {
+    return new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
+}
+export function appendAuditEntry(projectRoot, entry) {
+    const logPath = join(resolve(projectRoot), AUDIT_LOG_REL_PATH);
+    mkdirSync(dirname(logPath), { recursive: true });
+    const line = `${utcIso()} ${entry}\n`;
+    if (!existsSync(logPath)) {
+        writeFileSync(logPath, "# meta/policy-changes.log -- audit trail for PROJECT-DEFINITION plan.policy.* mutations (#746 / #1143)\n", "utf8");
+    }
+    appendFileSync(logPath, line, "utf8");
+    return logPath;
+}
+function atomicWrite(path, data) {
+    mkdirSync(dirname(path), { recursive: true });
+    const payload = `${JSON.stringify(data, null, 2)}\n`;
+    const tmp = join(dirname(path), `.${Date.now()}.tmp`);
+    writeFileSync(tmp, payload, "utf8");
+    renameSync(tmp, path);
+}
+export function writeTriageScope(projectRoot, rules, options = { presetLabel: "custom" }) {
+    const path = projectDefinitionPath(projectRoot);
+    if (!existsSync(path))
+        throw new Error(`PROJECT-DEFINITION not found at ${path}`);
+    const data = JSON.parse(readFileSync(path, "utf8"));
+    const plan = data.plan;
+    if (typeof plan !== "object" || plan === null || Array.isArray(plan)) {
+        throw new Error("PROJECT-DEFINITION 'plan' is not an object");
+    }
+    const planRec = plan;
+    let policy = planRec.policy;
+    if (typeof policy !== "object" || policy === null || Array.isArray(policy)) {
+        policy = {};
+        planRec.policy = policy;
+    }
+    const policyRec = policy;
+    const previous = policyRec.triageScope;
+    policyRec.triageScope = rules;
+    atomicWrite(path, data);
+    const changed = JSON.stringify(previous) !== JSON.stringify(rules);
+    const actor = options.actor ?? WELCOME_AUDIT_TAG;
+    const auditEntry = [
+        `actor=${actor}`,
+        "field=plan.policy.triageScope",
+        `preset=${options.presetLabel}`,
+        `rule_count=${rules.length}`,
+        `changed=${changed ? "true" : "false"}`,
+    ].join(" ");
+    appendAuditEntry(projectRoot, auditEntry);
+    return [changed, auditEntry];
+}
+export function writeWipCap(projectRoot, wipCap, options = {}) {
+    if (!Number.isInteger(wipCap) || wipCap < 1) {
+        throw new Error(`wipCap must be a positive int, got ${JSON.stringify(wipCap)}`);
+    }
+    const path = projectDefinitionPath(projectRoot);
+    if (!existsSync(path))
+        throw new Error(`PROJECT-DEFINITION not found at ${path}`);
+    const data = JSON.parse(readFileSync(path, "utf8"));
+    const plan = data.plan;
+    if (typeof plan !== "object" || plan === null || Array.isArray(plan)) {
+        throw new Error("PROJECT-DEFINITION 'plan' is not an object");
+    }
+    const planRec = plan;
+    let policy = planRec.policy;
+    if (typeof policy !== "object" || policy === null || Array.isArray(policy)) {
+        policy = {};
+        planRec.policy = policy;
+    }
+    const policyRec = policy;
+    const previous = policyRec.wipCap;
+    const actor = options.actor ?? WELCOME_AUDIT_TAG;
+    if (previous === undefined && wipCap === DEFAULT_WIP_CAP) {
+        return [false, ""];
+    }
+    if (previous !== undefined && wipCap === DEFAULT_WIP_CAP) {
+        delete policyRec.wipCap;
+        atomicWrite(path, data);
+        const auditEntry = `actor=${actor} field=plan.policy.wipCap action=cleared-to-default value=${wipCap} ` +
+            `previous=${JSON.stringify(previous)} changed=true`;
+        appendAuditEntry(projectRoot, auditEntry);
+        return [true, auditEntry];
+    }
+    policyRec.wipCap = wipCap;
+    atomicWrite(path, data);
+    const changed = previous !== wipCap;
+    const auditEntry = `actor=${actor} field=plan.policy.wipCap value=${wipCap} previous=${JSON.stringify(previous)} ` +
+        `changed=${changed ? "true" : "false"}`;
+    appendAuditEntry(projectRoot, auditEntry);
+    return [changed, auditEntry];
+}
+function daysInPending(path, now) {
+    try {
+        const data = JSON.parse(readFileSync(path, "utf8"));
+        const plan = data.plan;
+        if (typeof plan === "object" && plan !== null && !Array.isArray(plan)) {
+            const raw = plan.updated;
+            if (typeof raw === "string") {
+                let text = raw.trim();
+                if (text.endsWith("Z"))
+                    text = `${text.slice(0, -1)}+00:00`;
+                const stamp = new Date(text);
+                if (!Number.isNaN(stamp.getTime())) {
+                    return Math.max(0, Math.floor((now.getTime() - stamp.getTime()) / 86400000));
+                }
+            }
+        }
+    }
+    catch {
+        // fall through
+    }
+    try {
+        const mtime = statSync(path).mtime;
+        return Math.max(0, Math.floor((now.getTime() - mtime.getTime()) / 86400000));
+    }
+    catch {
+        return 0;
+    }
+}
+export function previewWipRelief(projectRoot, olderThanDays = DEFAULT_RELIEF_AGE_DAYS) {
+    const pendingDir = join(resolve(projectRoot), "vbrief", "pending");
+    if (!existsSync(pendingDir)) {
+        return { olderThanDays, eligibleCount: 0, eligibleFiles: [], skippedCount: 0 };
+    }
+    const now = new Date();
+    const eligible = [];
+    let skipped = 0;
+    for (const name of [...readdirSync(pendingDir)]
+        .filter((n) => n.endsWith(".vbrief.json"))
+        .sort()) {
+        const path = join(pendingDir, name);
+        const days = daysInPending(path, now);
+        if (days >= olderThanDays)
+            eligible.push(name);
+        else
+            skipped += 1;
+    }
+    return {
+        olderThanDays,
+        eligibleCount: eligible.length,
+        eligibleFiles: eligible,
+        skippedCount: skipped,
+    };
+}
+export function subscriptionPreset(key) {
+    const preset = SUBSCRIPTION_PRESETS[key];
+    if (!preset)
+        throw new Error(`unknown preset ${key}`);
+    return preset.map((r) => ({ ...r }));
+}
+//# sourceMappingURL=writers.js.map

package/dist/ts-check-lane/index.d.ts

@@ -0,0 +1,3 @@
+export type { LaneRunner, ResolvePnpmOptions, RunnerResult, RunTsLaneOptions } from "./run-lane.js";
+export { LANE_COMMANDS, resolvePnpm, runTsLane, SKIP_NOTICE } from "./run-lane.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/ts-check-lane/index.js

@@ -0,0 +1,2 @@
+export { LANE_COMMANDS, resolvePnpm, runTsLane, SKIP_NOTICE } from "./run-lane.js";
+//# sourceMappingURL=index.js.map

package/dist/ts-check-lane/run-lane.d.ts

@@ -0,0 +1,53 @@
+/**
+ * ts-check-lane/run-lane.ts -- Node-toolchain-aware TypeScript lane for
+ * `task check` (#1530, #1790).
+ *
+ * TypeScript port of scripts/ts_check_lane.py (#1731 Wave 9 Python-delete).
+ *
+ * `task check` -> `check:framework-source` historically ran only the Python
+ * suite + gates; the TypeScript engine (biome lint, tsc build, vitest) ran only
+ * in the dedicated CI job. That split let a TS lint/format/test failure pass a
+ * contributor's local `task check` and redden CI after push.
+ *
+ * This helper closes the gap WITHOUT regressing the documented invariant that
+ * `check:framework-source` must not hard-require a Node toolchain in Node-less
+ * environments (the vendored-consumer guard pattern). When `pnpm` is on PATH it
+ * runs `pnpm run lint`, `pnpm run build`, and `pnpm run test` in order, failing
+ * fast on the first non-zero exit. When `pnpm` is absent it prints a clear
+ * notice and exits 0 -- the TS lane stays validated by the CI job in that case.
+ */
+/**
+ * Run order is deliberate: lint (cheapest, catches the biome class first),
+ * then build, then the test suite.
+ */
+export declare const LANE_COMMANDS: ReadonlyArray<readonly [string, string]>;
+export declare const SKIP_NOTICE: string;
+/** Result of a single lane command invocation. Mirrors a subset of SpawnSyncReturns. */
+export interface RunnerResult {
+    readonly status: number | null;
+}
+export type LaneRunner = (argv: readonly string[], cwd: string) => RunnerResult;
+export interface RunTsLaneOptions {
+    /** Resolved pnpm executable path, or null when not installed. */
+    readonly pnpm: string | null;
+    /** Injected command runner (defaults to a real spawnSync). */
+    readonly runner?: LaneRunner;
+    /** Injected sink for human-facing notices (defaults to stdout). */
+    readonly out?: (message: string) => void;
+}
+export interface ResolvePnpmOptions {
+    readonly env?: NodeJS.ProcessEnv;
+    readonly platform?: NodeJS.Platform;
+    /** Injected existence probe (defaults to node:fs existsSync). */
+    readonly exists?: (path: string) => boolean;
+}
+/** Resolve the pnpm executable path, or null when it is not installed. */
+export declare function resolvePnpm(options?: ResolvePnpmOptions): string | null;
+/**
+ * Run the TS lane when pnpm is available; skip (exit 0) when it is not.
+ *
+ * `runner` and `out` are injected so the guard logic is unit-testable without a
+ * real Node toolchain or real subprocess execution.
+ */
+export declare function runTsLane(projectRoot: string, options: RunTsLaneOptions): number;
+//# sourceMappingURL=run-lane.d.ts.map

package/dist/ts-check-lane/run-lane.js

@@ -0,0 +1,98 @@
+/**
+ * ts-check-lane/run-lane.ts -- Node-toolchain-aware TypeScript lane for
+ * `task check` (#1530, #1790).
+ *
+ * TypeScript port of scripts/ts_check_lane.py (#1731 Wave 9 Python-delete).
+ *
+ * `task check` -> `check:framework-source` historically ran only the Python
+ * suite + gates; the TypeScript engine (biome lint, tsc build, vitest) ran only
+ * in the dedicated CI job. That split let a TS lint/format/test failure pass a
+ * contributor's local `task check` and redden CI after push.
+ *
+ * This helper closes the gap WITHOUT regressing the documented invariant that
+ * `check:framework-source` must not hard-require a Node toolchain in Node-less
+ * environments (the vendored-consumer guard pattern). When `pnpm` is on PATH it
+ * runs `pnpm run lint`, `pnpm run build`, and `pnpm run test` in order, failing
+ * fast on the first non-zero exit. When `pnpm` is absent it prints a clear
+ * notice and exits 0 -- the TS lane stays validated by the CI job in that case.
+ */
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+/**
+ * Run order is deliberate: lint (cheapest, catches the biome class first),
+ * then build, then the test suite.
+ */
+export const LANE_COMMANDS = [
+    ["run", "lint"],
+    ["run", "build"],
+    ["run", "test"],
+];
+export const SKIP_NOTICE = "[ts:check-lane] pnpm not found on PATH -- skipping the TypeScript lane " +
+    "(build/lint/test). The TS engine stays validated by the dedicated CI job. " +
+    "Install the Node toolchain (pnpm) to run the TS lane locally.";
+/** Default runner: a non-shell, inherited-stdio pnpm invocation. */
+function defaultRunner(argv, cwd) {
+    const [command, ...rest] = argv;
+    const result = spawnSync(command ?? "", rest, { cwd, stdio: "inherit" });
+    return { status: result.status };
+}
+/** Resolve the pnpm executable path, or null when it is not installed. */
+export function resolvePnpm(options = {}) {
+    const env = options.env ?? process.env;
+    const platform = options.platform ?? process.platform;
+    const exists = options.exists ?? existsSync;
+    const pathValue = env.PATH ?? env.Path ?? "";
+    if (pathValue === "") {
+        return null;
+    }
+    const isWindows = platform === "win32";
+    const exts = isWindows ? (env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";") : [""];
+    const sep = isWindows ? ";" : ":";
+    for (const dir of pathValue.split(sep)) {
+        if (dir === "")
+            continue;
+        for (const ext of exts) {
+            const candidate = join(dir, `pnpm${ext}`);
+            if (exists(candidate)) {
+                return candidate;
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Run the TS lane when pnpm is available; skip (exit 0) when it is not.
+ *
+ * `runner` and `out` are injected so the guard logic is unit-testable without a
+ * real Node toolchain or real subprocess execution.
+ */
+export function runTsLane(projectRoot, options) {
+    const { pnpm } = options;
+    const runner = options.runner ?? defaultRunner;
+    const out = options.out ?? ((message) => process.stdout.write(`${message}\n`));
+    if (!pnpm) {
+        out(SKIP_NOTICE);
+        return 0;
+    }
+    for (const command of LANE_COMMANDS) {
+        const argv = [pnpm, ...command];
+        const result = runner(argv, projectRoot);
+        const code = result.status;
+        // A null status means the child was terminated by a signal (SIGKILL / OOM /
+        // SIGTERM) before it could exit. Mapping that to 0 would silently pass a
+        // half-run lint/test on a memory-constrained machine, so treat it as a hard
+        // failure -- this mirrors the Python oracle, whose returncode is negative
+        // (non-zero) for a signal-killed process.
+        if (code === null) {
+            out(`[ts:check-lane] \`pnpm ${command.join(" ")}\` was killed by a signal before exit -- treating as failure.`);
+            return 1;
+        }
+        if (code !== 0) {
+            out(`[ts:check-lane] \`pnpm ${command.join(" ")}\` failed (exit ${code}).`);
+            return code;
+        }
+    }
+    return 0;
+}
+//# sourceMappingURL=run-lane.js.map