@herbertgao/pi-extensions 2026.10.1 → 2026.10.2

package/node_modules/pi-lens/dist/clients/mcp/review.js

@@ -1,197 +0,0 @@
-/**
- * Review-loop helpers for the MCP path: forking a `fresh` worker (so an analysis
- * reflects the latest build, not the long-lived server's stale image) and
- * rebuilding the dist/in-place output so `fresh` picks the change up.
- *
- * Together these close the "stale-process trap": commit → `pilens_rebuild` →
- * `pilens_analyze mode=fresh` measures the just-built code first-hand.
- */
-import { spawn } from "node:child_process";
-import { existsSync } from "node:fs";
-import { join } from "node:path";
-import { pmBinary, resolveNodePackageManager, runScriptArgs, } from "../package-manager.js";
-import { incrementDegradationCount } from "../degradation-ledger.js";
-import { safeSpawnAsync } from "../safe-spawn.js";
-import { createBoundedOutputSink, DEFAULT_MAX_OUTPUT_BYTES, } from "../spawn-output-cap.js";
-/**
- * Which npm script rebuilds the layout the server is running from. A server at
- * `…/dist/mcp/server.js` is the precompiled dist (`build:dist` recreates it); a
- * server at `…/mcp/server.js` is the in-place dev build (`build` emits beside the
- * sources). The forked worker is always resolved relative to the server, so it
- * shares the server's layout — rebuilding that layout updates the worker.
- */
-export function resolveRebuildScript(serverFilePath) {
-    return serverFilePath.replace(/\\/g, "/").includes("/dist/")
-        ? "build:dist"
-        : "build";
-}
-/**
- * Fork `node <workerPath>` to analyze a file in a fresh process. We spawn node
- * directly (no shell) so an interpreter path containing spaces is safe on
- * Windows — `safeSpawnAsync`'s shell mode does not escape the command itself.
- *
- * #3383: both pipes accumulate through {@link createBoundedOutputSink} rather
- * than `+=`. The worker writes one JSON document to stdout, so an unbounded
- * accumulation here could reach the same ending #3375 fixed at the shared spawn
- * seam — V8 refusing the next concatenation with `RangeError: Invalid string
- * length` inside a `data` handler, uncatchable by this promise. The only thing
- * bounding it before was the `timeoutMs` kill, and a worker can emit hundreds
- * of MiB long before 120 s elapse.
- */
-export function analyzeFileFresh(workerPath, file, cwd, options = {}, timeoutMs = 120_000) {
-    return new Promise((resolve) => {
-        const args = [workerPath, `--file=${file}`, `--cwd=${cwd}`];
-        if (options.flags)
-            args.push(`--flags=${JSON.stringify(options.flags)}`);
-        let child;
-        try {
-            child = spawn(process.execPath, args, {
-                stdio: ["ignore", "pipe", "pipe"],
-            });
-        }
-        catch (err) {
-            // SYNCHRONOUS spawn throw (Windows `spawn UNKNOWN`/EINVAL, the pidusage
-            // bug class, #533) — resolve the failure rather than reject/crash the
-            // host; every caller inspects the outcome's `error` field.
-            resolve({
-                error: `failed to fork worker: ${err instanceof Error ? err.message : String(err)}`,
-            });
-            return;
-        }
-        const stdout = createBoundedOutputSink();
-        const stderr = createBoundedOutputSink();
-        let settled = false;
-        const finish = (outcome) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timer);
-            resolve(outcome);
-        };
-        const timer = setTimeout(() => {
-            child.kill();
-            finish({ error: `fresh analyze timed out after ${timeoutMs}ms` });
-        }, timeoutMs);
-        child.stdout.setEncoding("utf8");
-        child.stdout.on("data", (chunk) => {
-            // Settled already means timed out or failed: keep accumulating and the
-            // retained output outlives the promise nobody is awaiting any more.
-            if (settled)
-                return;
-            stdout.append(chunk);
-            // Truncated stdout is never parseable JSON, so the run is over. Report
-            // the cap as the ending instead of letting `JSON.parse` blame the
-            // worker's output shape, and terminate the producer.
-            if (!stdout.truncated)
-                return;
-            incrementDegradationCount({
-                kind: "spawn-output-cap-truncated",
-                subject: "mcp-fresh-analyze",
-                reason: `worker stdout reached the ${DEFAULT_MAX_OUTPUT_BYTES}-byte default cap after ${stdout.observedBytes} bytes; worker terminated`,
-                metadata: {
-                    capBytes: DEFAULT_MAX_OUTPUT_BYTES,
-                    capSource: "default",
-                    observedBytes: stdout.observedBytes,
-                    killed: true,
-                },
-            });
-            try {
-                child.kill();
-            }
-            catch {
-                // Best-effort: the worker may already be gone, and this runs inside a
-                // `data` handler where a throw would be uncatchable.
-            }
-            finish({
-                error: `worker output exceeded ${DEFAULT_MAX_OUTPUT_BYTES} bytes`,
-            });
-        });
-        child.stderr.setEncoding("utf8");
-        child.stderr.on("data", (chunk) => {
-            if (settled)
-                return;
-            stderr.append(chunk);
-        });
-        child.on("error", (err) => finish({ error: `failed to fork worker: ${err.message}` }));
-        child.on("close", (code) => {
-            if (code !== 0) {
-                finish({
-                    error: `worker exited ${code}: ${stderr.text.trim() || "(no stderr)"}`,
-                });
-                return;
-            }
-            try {
-                finish({ result: JSON.parse(stdout.text) });
-            }
-            catch {
-                finish({
-                    error: `worker produced invalid JSON (${stderr.text.trim() || stdout.text.slice(0, 200)})`,
-                });
-            }
-        });
-    });
-}
-/**
- * Rebuilds are safe only from a source checkout. Published packages contain
- * `dist/` but not tsconfig.dist.json, and build:dist deletes dist before tsc.
- * The node_modules check also refuses unusual installs that happen to carry a
- * stray tsconfig.
- */
-export function canRebuildPiLens(repoRoot) {
-    const inNodeModules = /(^|[\\/])node_modules([\\/]|$)/i.test(repoRoot);
-    return !inNodeModules && existsSync(join(repoRoot, "tsconfig.dist.json"));
-}
-export const REBUILD_UNAVAILABLE_MESSAGE = "pilens_rebuild is unavailable in an installed pi-lens package. Rebuilding is only safe from a source checkout containing tsconfig.dist.json; reinstall or update pi-lens through your package manager instead.";
-/**
- * Run `<pm> run <script>` in the pi-lens repo, where `<pm>` is resolved from the
- * repo's lockfile / installed managers. Uses `safeSpawnAsync` (Windows
- * `.cmd`/shell-aware). `ignoreAmbientSignal` — a rebuild must run to completion.
- */
-export async function runRebuild(repoRoot, script, timeoutMs = 300_000) {
-    const start = Date.now();
-    if (!canRebuildPiLens(repoRoot)) {
-        return {
-            ok: false,
-            script,
-            durationMs: Date.now() - start,
-            output: REBUILD_UNAVAILABLE_MESSAGE,
-        };
-    }
-    const packageManager = await resolveNodePackageManager(repoRoot);
-    const res = await safeSpawnAsync(pmBinary(packageManager), runScriptArgs(script), {
-        cwd: repoRoot,
-        timeout: timeoutMs,
-        ignoreAmbientSignal: true,
-    });
-    const output = `${res.stdout}\n${res.stderr}`.trim();
-    return {
-        ok: !res.error && res.status === 0,
-        script,
-        packageManager,
-        durationMs: Date.now() - start,
-        output: output.slice(-2000),
-    };
-}
-/**
- * Dedupe project-scan diagnostics (the cheap scanners can emit the same
- * file:line:rule twice) and aggregate counts by rule and file — so the
- * `pilens_project_scan` tool returns a compact, scannable summary instead of
- * dumping ~100 raw objects into the agent's context.
- */
-export function summarizeScan(diagnostics) {
-    const seen = new Set();
-    const deduped = [];
-    const byRule = {};
-    const byFile = {};
-    for (const diagnostic of diagnostics) {
-        const ruleId = diagnostic.rule ?? diagnostic.runner ?? diagnostic.tool ?? "unknown";
-        const key = `${diagnostic.filePath}|${diagnostic.line ?? "?"}|${diagnostic.column ?? "?"}|${ruleId}`;
-        if (seen.has(key))
-            continue;
-        seen.add(key);
-        deduped.push(diagnostic);
-        byRule[ruleId] = (byRule[ruleId] ?? 0) + 1;
-        byFile[diagnostic.filePath] = (byFile[diagnostic.filePath] ?? 0) + 1;
-    }
-    return { deduped, byRule, byFile };
-}

package/node_modules/pi-lens/dist/clients/mcp/session.js

@@ -1,412 +0,0 @@
-/**
- * Tier 2 of the MCP path: drive pi-lens's *real* lifecycle handlers
- * (`handleSessionStart`, `handleTurnEnd`) instead of re-implementing the runners
- * they orchestrate. This is what exposes the layers the per-edit dispatch slice
- * doesn't — session-start warms the dominant-language LSP (so warm `analyze` is
- * LSP-complete), establishes the error-debt baseline + complexity baselines, and
- * kicks off knip/jscpd/type-coverage/dep/secrets scans; turn-end runs
- * knip incrementally, dep-circular, tests, cascade, and the
- * actionable/code-quality aggregation.
- *
- * The handlers don't return findings — they emit them through the same
- * cache/context bridge pi consumes (`consume*` from runtime-context). We drive
- * the handler, then consume that bridge and hand the text back as the tool result.
- *
- * The host coupling stays thin: a `getFlag` shim, no-op notify/dbg/log, a
- * persistent RuntimeCoordinator + CacheManager (so baselines/turn-state survive
- * across calls, like a real session), and the bootstrap client bundle.
- */
-import * as crypto from "node:crypto";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { AstGrepClient } from "../ast-grep-client.js";
-import { loadBootstrapClients, residentBootstrapAccess, } from "../bootstrap.js";
-import { CacheManager, MCP_TURN_STATE_OWNER_ID, } from "../cache-manager.js";
-import { resetDispatchBaselines } from "../dispatch/integration.js";
-import { resetFormatService } from "../format-service.js";
-import { getLSPService, resetLSPService } from "../lsp/index.js";
-import { acknowledgeTestFindings, acknowledgeTurnEndFindings, consumeSessionStartGuidance, consumeTestFindings, consumeTurnEndFindings, peekTestFindings, peekTurnEndFindings, } from "../runtime-context.js";
-import { RuntimeCoordinator } from "../runtime-coordinator.js";
-import { handleSessionStart } from "../runtime-session.js";
-import { handleTurnEnd } from "../runtime-turn.js";
-import { createMcpHost } from "./host-shim.js";
-import { startSituationalToolTelemetrySession } from "../situational-tool-telemetry.js";
-import { bounded } from "../deadline-utils.js";
-import { HOOK_WALL_BUDGET_MS } from "../hook-budgets.js";
-let contextPromise;
-let resolvedRuntime;
-/**
- * Lazily build (once) the persistent session context shared across MCP
- * calls. A rejected build (e.g. `loadBootstrapClients` hitting a transient
- * fs error) must not poison every later MCP call for the rest of the
- * process — evict the memo on rejection so the next call retries (#1570).
- */
-export function getMcpSessionContext() {
-    contextPromise ??= (async () => {
-        const context = {
-            runtime: new RuntimeCoordinator(),
-            cacheManager: new CacheManager(),
-            astGrepClient: new AstGrepClient(),
-            clients: await loadBootstrapClients(),
-        };
-        resolvedRuntime = context.runtime;
-        return context;
-    })().catch((err) => {
-        contextPromise = undefined;
-        throw err;
-    });
-    return contextPromise;
-}
-/** Synchronous peek at the session runtime, for construction sites that cannot
- * await (e.g. the MCP server's tool wiring). Returns undefined until a session
- * context has actually been built — advisory validation then honestly skips
- * the session-identity check instead of comparing against a phantom session. */
-export function peekMcpSessionRuntime() {
-    return resolvedRuntime;
-}
-/** Test hook — drop the cached context so a fresh one is built next call. */
-export function _resetMcpSessionContext() {
-    contextPromise = undefined;
-    resolvedRuntime = undefined;
-}
-const noop = () => { };
-function joinMessages(consumed) {
-    if (!consumed?.messages?.length)
-        return undefined;
-    return consumed.messages.map((message) => message.content).join("\n\n");
-}
-const degradedSessionStart = {
-    aliveLspClients: 0,
-};
-/**
- * Run pi-lens's real session_start. Much of the work (scans, baseline, LSP warm)
- * runs in the background, so the immediate return carries the synchronous
- * guidance + whatever baseline/LSP state is ready; query `pilens_diagnostics` /
- * `pilens_health` afterwards for the scan results as they land.
- */
-async function runSessionStartImpl(cwd) {
-    startSituationalToolTelemetrySession("mcp");
-    const ctx = await getMcpSessionContext();
-    const host = createMcpHost(undefined, cwd);
-    await bounded(handleSessionStart({
-        ctxCwd: cwd,
-        // The MCP server has no TUI keystroke latency to protect, so the
-        // first-call-quick heuristic must not apply. Force "full" mode so
-        // the dominant-language LSP pre-warm, scans, and error-debt baseline
-        // all run on the first (and only) session_start of the process.
-        // An explicit PI_LENS_STARTUP_MODE env var still wins (handled in
-        // handleSessionStart — the override is only checked when the env var
-        // is unset).
-        startupModeOverride: "full",
-        getFlag: host.getFlag,
-        notify: noop,
-        dbg: noop,
-        log: noop,
-        runtime: ctx.runtime,
-        cacheManager: ctx.cacheManager,
-        astGrepClient: ctx.astGrepClient,
-        // The MCP server has already loaded the analyzer graph (an MCP call has
-        // nothing to defer to), so it hands the handler the same one-shape seam
-        // every other caller uses rather than a second, field-by-field shape.
-        bootstrap: residentBootstrapAccess(ctx.clients),
-        ensureTool: async (name) => (await import("../installer/index.js")).ensureTool(name),
-        cleanStaleTsBuildInfo: () => [],
-        resetDispatchBaselines: (cwdArg) => resetDispatchBaselines(cwdArg ?? cwd),
-        resetLSPService,
-    }), {
-        ms: HOOK_WALL_BUDGET_MS.session_start,
-        signal: undefined,
-        hook: "session_start",
-        label: "handleSessionStart",
-    });
-    const baseline = ctx.runtime.errorDebtBaseline;
-    return {
-        guidance: joinMessages(consumeSessionStartGuidance(ctx.cacheManager, cwd, "mcp")),
-        errorDebtBaseline: baseline
-            ? { testsPassed: baseline.testsPassed, buildPassed: baseline.buildPassed }
-            : undefined,
-        aliveLspClients: getLSPService().getAliveClientCount(),
-    };
-}
-export function runSessionStart(cwd) {
-    return bounded(runSessionStartImpl(cwd), {
-        ms: HOOK_WALL_BUDGET_MS.session_start,
-        signal: undefined,
-        hook: "session_start",
-        label: "mcp-session-start",
-    }).then((outcome) => outcome ?? degradedSessionStart);
-}
-const degradedTurnEnd = {
-    outcome: { filesRegistered: 0 },
-    commit: () => { },
-};
-/**
- * #1274: the delivery map used to be unbounded — every timed-out client and
- * every distinct raw-cwd alias left an entry for the life of the process.
- * Both bounds drop entries WITHOUT committing, which re-arms the findings in
- * the cache: the safe direction, since an un-consumed finding is re-reported on
- * a later Stop while a wrongly-consumed one is gone for good. The TTL is
- * generous next to Claude Code's 60 s hook budget — it exists to bound the map,
- * not to police clients.
- */
-const TURN_END_DELIVERY_TTL_MS = 10 * 60_000;
-const TURN_END_DELIVERY_MAX = 8;
-const TURN_END_QUEUE_WAIT_MS = 5_000;
-/**
- * A bounded, cancellable serial queue. A turn_end mutates shared runtime and
- * cache state, so concurrent passes are unsafe; a disconnected/hung pass must
- * nevertheless not accumulate an unbounded tail of Stop requests.
- */
-class TurnEndQueue {
-    running = false;
-    pending = [];
-    enqueue(work, waitMs = TURN_END_QUEUE_WAIT_MS) {
-        if (this.pending.length >= 1) {
-            return Promise.reject(new Error("turn_end queue is busy"));
-        }
-        return new Promise((resolve, reject) => {
-            const item = {
-                work,
-                resolve,
-                reject,
-                timer: setTimeout(() => {
-                    const index = this.pending.indexOf(item);
-                    if (index === -1)
-                        return;
-                    this.pending.splice(index, 1);
-                    reject(new Error("turn_end queue wait timed out"));
-                }, waitMs),
-            };
-            item.timer.unref();
-            this.pending.push(item);
-            this.drain();
-        });
-    }
-    drain() {
-        if (this.running)
-            return;
-        const item = this.pending.shift();
-        if (!item)
-            return;
-        clearTimeout(item.timer);
-        this.running = true;
-        void item
-            .work()
-            .then(item.resolve, item.reject)
-            .finally(() => {
-            this.running = false;
-            this.drain();
-        });
-    }
-    reset() {
-        for (const item of this.pending.splice(0)) {
-            clearTimeout(item.timer);
-            item.reject(new Error("turn_end queue reset"));
-        }
-        this.running = false;
-    }
-}
-const turnEndQueue = new TurnEndQueue();
-const pendingTurnEndDeliveries = new Map();
-/** In-flight Stop-hook passes, keyed by cwd — see `runTurnEndForIpc` (#1274). */
-const inFlightIpcTurnEnds = new Map();
-/**
- * Run pi-lens's real turn_end over the files edited this "turn". The handler
- * reads edited files from turn-state, so we register the caller-supplied files
- * first (a full-file range, importsChanged=true so dep/knip re-check broadly).
- */
-async function runTurnEndNowImpl(cwd, files = [], deferredDelivery = false) {
-    const ctx = await getMcpSessionContext();
-    const host = createMcpHost(undefined, cwd);
-    let registered = 0;
-    for (const file of files) {
-        const abs = path.isAbsolute(file) ? file : path.resolve(cwd, file);
-        let lineCount = 1;
-        try {
-            lineCount = fs.readFileSync(abs, "utf8").split("\n").length;
-        }
-        catch {
-            continue; // unreadable / deleted — skip
-        }
-        ctx.cacheManager.addModifiedRange(abs, { start: 1, end: lineCount }, true, cwd, MCP_TURN_STATE_OWNER_ID, "mcp");
-        registered++;
-    }
-    const owner = {
-        kind: "mcp",
-        id: MCP_TURN_STATE_OWNER_ID,
-        pid: process.pid,
-        lastSeen: new Date().toISOString(),
-    };
-    await handleTurnEnd({
-        signal: undefined,
-        ctxCwd: cwd,
-        getFlag: host.getFlag,
-        dbg: noop,
-        runtime: ctx.runtime,
-        cacheManager: ctx.cacheManager,
-        knipClient: ctx.clients.knipClient,
-        deadCodeClients: ctx.clients.deadCodeClients,
-        depChecker: ctx.clients.depChecker,
-        testRunnerClient: ctx.clients.testRunnerClient,
-        host: "mcp",
-        owner,
-        resetLSPService,
-        resetFormatService,
-    });
-    const outcome = deferredDelivery
-        ? {
-            turnEnd: joinMessages(peekTurnEndFindings(ctx.cacheManager, cwd, ctx.runtime, true)),
-            tests: joinMessages(peekTestFindings(ctx.cacheManager, cwd, ctx.runtime, true)),
-            filesRegistered: registered,
-        }
-        : {
-            turnEnd: joinMessages(consumeTurnEndFindings(ctx.cacheManager, cwd, ctx.runtime)),
-            tests: joinMessages(consumeTestFindings(ctx.cacheManager, cwd, ctx.runtime)),
-            filesRegistered: registered,
-        };
-    return {
-        outcome,
-        commit: () => {
-            if (!deferredDelivery)
-                return;
-            acknowledgeTurnEndFindings(ctx.cacheManager, cwd);
-            acknowledgeTestFindings(ctx.cacheManager, cwd);
-        },
-    };
-}
-function runTurnEndNow(cwd, files = [], deferredDelivery = false) {
-    return bounded(runTurnEndNowImpl(cwd, files, deferredDelivery), {
-        ms: HOOK_WALL_BUDGET_MS.turn_end,
-        signal: undefined,
-        hook: "turn_end",
-        label: "mcp-turn-end",
-    }).then((transaction) => transaction ?? degradedTurnEnd);
-}
-/**
- * Run a normal MCP turn_end. Its caller owns the tool response, so the
- * historical consume-on-return behavior remains unchanged.
- */
-export function runTurnEnd(cwd, files = []) {
-    return turnEndQueue.enqueue(async () => (await runTurnEndNow(cwd, files)).outcome);
-}
-/** A result with no findings needs no durable delivery transaction. */
-function hasTurnEndFindings(outcome) {
-    return Boolean(outcome.turnEnd || outcome.tests);
-}
-/** Drop expired deliveries, then the oldest ones over the cap. Never commits. */
-function prunePendingTurnEndDeliveries(now = Date.now()) {
-    for (const [deliveryId, delivery] of pendingTurnEndDeliveries) {
-        if (now - delivery.createdAt >= TURN_END_DELIVERY_TTL_MS) {
-            pendingTurnEndDeliveries.delete(deliveryId);
-        }
-    }
-    // Map iteration is insertion-ordered, so the head is the oldest entry.
-    while (pendingTurnEndDeliveries.size > TURN_END_DELIVERY_MAX) {
-        const oldest = pendingTurnEndDeliveries.keys().next();
-        if (oldest.done)
-            break;
-        pendingTurnEndDeliveries.delete(oldest.value);
-    }
-}
-function pendingForCwd(cwd) {
-    for (const [deliveryId, delivery] of pendingTurnEndDeliveries) {
-        if (delivery.cwd === cwd)
-            return [deliveryId, delivery];
-    }
-    return undefined;
-}
-/**
- * Run the Stop-hook pass as a durable delivery transaction. The result is
- * acknowledged through a separate one-shot IPC request. Until that request
- * arrives, the findings cache is deliberately left unconsumed; a client
- * timeout, socket close, or server restart therefore leaves the result for a
- * later Stop request instead of losing it between execution and reply.
- */
-export function runTurnEndForIpc(cwd) {
-    // #1274: the Stop-hook request carries no files and no sessionId, so two
-    // overlapping ones are byte-identical and a second pass would be pure waste
-    // — worse, the queue only holds ONE waiter, so a third Stop is rejected
-    // outright. Identical in-flight requests share the one pass and one
-    // deliveryId; the ack is idempotent-by-capability, so the loser of the race
-    // simply finds the delivery already committed.
-    const inFlight = inFlightIpcTurnEnds.get(cwd);
-    if (inFlight)
-        return inFlight;
-    // Identity-guarded release (#1968's pattern): delete only if THIS run is
-    // still the registered one. A bare delete-by-key lets a late-settling run
-    // evict a live successor a second writer registered under the same cwd
-    // mid-flight, after which the next caller starts a duplicate Stop-hook pass.
-    const run = runTurnEndForIpcNow(cwd).finally(() => {
-        if (inFlightIpcTurnEnds.get(cwd) === run)
-            inFlightIpcTurnEnds.delete(cwd);
-    });
-    inFlightIpcTurnEnds.set(cwd, run);
-    return run;
-}
-function runTurnEndForIpcNow(cwd) {
-    return turnEndQueue.enqueue(async () => {
-        prunePendingTurnEndDeliveries();
-        const pending = pendingForCwd(cwd);
-        if (pending) {
-            return {
-                outcome: pending[1].transaction.outcome,
-                deliveryId: pending[0],
-            };
-        }
-        const ctx = await getMcpSessionContext();
-        const cachedOutcome = {
-            turnEnd: joinMessages(peekTurnEndFindings(ctx.cacheManager, cwd, ctx.runtime, true)),
-            tests: joinMessages(peekTestFindings(ctx.cacheManager, cwd, ctx.runtime, true)),
-            filesRegistered: 0,
-        };
-        const transaction = hasTurnEndFindings(cachedOutcome)
-            ? {
-                outcome: cachedOutcome,
-                commit: () => {
-                    acknowledgeTurnEndFindings(ctx.cacheManager, cwd);
-                    acknowledgeTestFindings(ctx.cacheManager, cwd);
-                },
-            }
-            : await runTurnEndNow(cwd, [], true);
-        if (!hasTurnEndFindings(transaction.outcome)) {
-            return { outcome: transaction.outcome };
-        }
-        const deliveryId = crypto.randomUUID();
-        pendingTurnEndDeliveries.set(deliveryId, {
-            cwd,
-            transaction,
-            createdAt: Date.now(),
-        });
-        prunePendingTurnEndDeliveries();
-        return { outcome: transaction.outcome, deliveryId };
-    });
-}
-/** Commit exactly one admitted delivery capability. */
-export function acknowledgeTurnEnd(cwd, deliveryId) {
-    prunePendingTurnEndDeliveries();
-    const delivery = pendingTurnEndDeliveries.get(deliveryId);
-    if (!delivery || delivery.cwd !== cwd)
-        return false;
-    // #1274: commit BEFORE dropping the capability. Deleting first meant a
-    // throwing consume destroyed the only handle to the findings — precisely the
-    // loss this two-phase protocol exists to prevent, reintroduced on the error
-    // path. Leaving the entry in place on a throw keeps the delivery re-fetchable
-    // by a later Stop.
-    delivery.transaction.commit();
-    pendingTurnEndDeliveries.delete(deliveryId);
-    return true;
-}
-/** Test hook — drop pending requests so one failed test cannot wedge the rest. */
-export function _resetTurnEndChain() {
-    turnEndQueue.reset();
-    pendingTurnEndDeliveries.clear();
-    inFlightIpcTurnEnds.clear();
-}
-/**
- * Test hook — read the `runTurnEndForIpc` in-flight map directly (#1968's
- * ABA regression: a second writer replacing an entry mid-flight, then a
- * late-settling first run evicting it with a bare delete-by-key).
- */
-export function _peekInFlightIpcTurnEnds() {
-    return inFlightIpcTurnEnds;
-}