ast-mcp-server 0.12.0 → 0.13.1

package/dist/services/h03-timeout-fixture.js

@@ -0,0 +1,335 @@
+import { Buffer } from "node:buffer";
+import { appendFileSync, readFileSync, statSync } from "node:fs";
+import path from "node:path";
+import { PUBLIC_ERROR_CODES, sanitizePublicText } from "./public-errors.js";
+import { parseH03FixtureDescriptor, parseH05FixtureDescriptor, } from "./runtime-policy.js";
+const FIXTURE_ID = /^[A-Za-z0-9_-]{1,64}$/;
+export class H03TimeoutFixtureError extends Error {
+    name = "H03TimeoutFixtureError";
+    code = "STALE_GENERATION";
+}
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+/** Closed test-only lifecycle controller used by H-05 through ast_get_project_status. */
+export class H05LifecycleFixtureController {
+    #descriptor;
+    #generationAbort = new AbortController();
+    #gates = new Map();
+    #events = [];
+    #active = 0;
+    #abortListeners = 0;
+    #staleSettlements = 0;
+    // prettier-ignore
+    constructor(descriptor) { if (!statSync(descriptor.controlDirectory, { throwIfNoEntry: false })?.isDirectory())
+        throw new Error("H-05 fixture control path must be an existing directory."); this.#descriptor = Object.freeze({ ...descriptor }); }
+    // prettier-ignore
+    capture(command) { if (Object.keys(command).sort().join(",") !== "callId,correlationId,fixtureId" || !FIXTURE_ID.test(command.callId) || !FIXTURE_ID.test(command.fixtureId) || !UUID.test(command.correlationId))
+        throw new Error("Invalid H-05 fixture command."); return Object.freeze({ ...command, generation: this.#descriptor.generation, ownerToken: this.#descriptor.ownerToken }); }
+    // prettier-ignore
+    hold(identity) { this.#assertCurrent(identity); const key = this.#key(identity); if (this.#gates.has(key))
+        throw new Error("Invalid or duplicate H-05 fixture id."); let release; const promise = new Promise((resolve) => (release = resolve)); this.#gates.set(key, { promise, release }); }
+    // prettier-ignore
+    advance(descriptor) { if (descriptor.generation <= this.#descriptor.generation)
+        throw new Error("H-05 fixture generation must increase."); this.#descriptor = Object.freeze({ ...descriptor }); this.#generationAbort.abort(); this.#generationAbort = new AbortController(); for (const gate of this.#gates.values())
+        gate.release(); this.#gates.clear(); }
+    // prettier-ignore
+    async run(identity, context, operation) {
+        this.#assertIdentity(identity);
+        const eventIdentity = { callId: identity.callId, correlationId: identity.correlationId, fixtureId: identity.fixtureId, generation: identity.generation, ownerToken: identity.ownerToken };
+        const generationSignal = this.#generationAbort.signal, signal = AbortSignal.any([context.signal, generationSignal]);
+        const checkpoint = () => { if (!this.accepts(identity) || generationSignal.aborted)
+            throw new H03TimeoutFixtureError(); context.checkpoint(); };
+        const hooked = Object.freeze({ get sequence() { return context.sequence; }, get phase() { return context.phase; }, signal, checkpoint, markExecuting: () => context.markExecuting(), enterCompletionCritical: () => { checkpoint(); context.enterCompletionCritical(); } });
+        this.#active += 1;
+        this.#emit({ ...eventIdentity, phase: "started" });
+        try {
+            const gate = this.#gates.get(this.#key(identity));
+            if (gate)
+                await this.#awaitGate(identity, gate, hooked);
+            checkpoint();
+            const result = await operation(hooked);
+            checkpoint();
+            this.#emit({ ...eventIdentity, phase: "terminal", outcome: "succeeded" });
+            return result;
+        }
+        catch (error) {
+            const code = error?.code, stale = !this.accepts(identity) || generationSignal.aborted, deadline = code === "OPERATION_DEADLINE_EXCEEDED", cancelled = code === "REQUEST_CANCELLED" || context.signal.aborted;
+            if (stale)
+                this.#staleSettlements += 1;
+            this.#emit({ ...eventIdentity, phase: "terminal", outcome: stale ? "STALE_GENERATION" : deadline ? code : cancelled ? "REQUEST_CANCELLED" : "failed" });
+            if (stale)
+                this.#staleSettlements -= 1;
+            throw stale ? new H03TimeoutFixtureError() : error;
+        }
+        finally {
+            this.#active -= 1;
+        }
+    }
+    // prettier-ignore
+    drainEvents() { const events = Object.freeze(this.#events); this.#events = []; return events; }
+    // prettier-ignore
+    snapshot() { return Object.freeze({ active: this.#active, held: this.#gates.size, abortListeners: this.#abortListeners, timers: 0, staleSettlements: this.#staleSettlements }); }
+    // prettier-ignore
+    async #awaitGate(identity, gate, context) { let rejectAbort; const aborted = new Promise((_, reject) => (rejectAbort = reject)); const abort = () => { this.#gates.delete(this.#key(identity)); try {
+        context.checkpoint();
+    }
+    catch (error) {
+        rejectAbort(error);
+    } }; context.signal.addEventListener("abort", abort, { once: true }); this.#abortListeners += 1; try {
+        if (context.signal.aborted)
+            abort();
+        await Promise.race([gate.promise, aborted]);
+    }
+    finally {
+        context.signal.removeEventListener("abort", abort);
+        this.#abortListeners -= 1;
+    } }
+    // prettier-ignore
+    #emit(event) { const normalized = Object.freeze(Object.fromEntries(Object.entries(event).filter(([, value]) => value !== undefined))); this.#events.push(normalized); appendFileSync(path.join(this.#descriptor.controlDirectory, "events.jsonl"), `${JSON.stringify(normalized)}\n`, { encoding: "utf8", flag: "a" }); }
+    // prettier-ignore
+    accepts(identity) { return identity.generation === this.#descriptor.generation && identity.ownerToken === this.#descriptor.ownerToken; }
+    // prettier-ignore
+    #assertCurrent(identity) { this.#assertIdentity(identity); if (!this.accepts(identity))
+        throw new H03TimeoutFixtureError(); }
+    // prettier-ignore
+    #assertIdentity(identity) { if (!Object.isFrozen(identity) || !FIXTURE_ID.test(identity.callId) || !FIXTURE_ID.test(identity.fixtureId) || !UUID.test(identity.correlationId))
+        throw new Error("Invalid H-05 lifecycle identity."); }
+    // prettier-ignore
+    #key(identity) { return `${identity.generation}:${identity.fixtureId}`; }
+}
+export class H03TimeoutFixtureController {
+    #descriptor;
+    #gates = new Map();
+    #events = [];
+    #generation;
+    #generationAbort = new AbortController();
+    #active = 0;
+    #abortListeners = 0;
+    #staleSettlements = 0;
+    constructor(descriptor) {
+        const directory = statSync(descriptor.controlDirectory, { throwIfNoEntry: false });
+        if (!directory?.isDirectory())
+            throw new Error("H-03 fixture control path must be an existing directory.");
+        this.#descriptor = descriptor;
+        this.#generation = descriptor.generation;
+    }
+    hold(fixtureId) {
+        this.#assertId(fixtureId);
+        const key = this.#key(fixtureId, this.#generation);
+        if (this.#gates.has(key))
+            throw new Error("Invalid or duplicate H-03 fixture id.");
+        let release;
+        const promise = new Promise((resolve) => (release = resolve));
+        this.#gates.set(key, { promise, release });
+    }
+    release(fixtureId, generation) {
+        if (!FIXTURE_ID.test(fixtureId) || generation !== this.#generation)
+            return false;
+        const key = this.#key(fixtureId, generation);
+        const gate = this.#gates.get(key);
+        if (!gate)
+            return false;
+        this.#gates.delete(key);
+        gate.release();
+        return true;
+    }
+    advanceGeneration(generation) {
+        if (!Number.isSafeInteger(generation) || generation <= this.#generation)
+            throw new Error("H-03 fixture generation must increase.");
+        this.#generation = generation;
+        this.#generationAbort.abort();
+        this.#generationAbort = new AbortController();
+        for (const gate of this.#gates.values())
+            gate.release();
+        this.#gates.clear();
+    }
+    async run(fixtureId, generation, context, operation, callId = fixtureId) {
+        this.#assertId(fixtureId);
+        this.#assertId(callId);
+        if (generation !== this.#generation)
+            return this.#stale(fixtureId, generation, callId);
+        const generationSignal = this.#generationAbort.signal;
+        const signal = AbortSignal.any([context.signal, generationSignal]);
+        const hooked = this.#context(context, signal, generationSignal, fixtureId, generation, callId);
+        this.#active += 1;
+        this.#emit({ callId, fixtureId, generation, nonce: this.#descriptor.nonce, phase: "started" });
+        try {
+            const gate = this.#gates.get(this.#key(fixtureId, generation));
+            if (gate)
+                await this.#awaitGate(this.#key(fixtureId, generation), gate, hooked);
+            hooked.checkpoint();
+            const result = await operation(hooked);
+            hooked.checkpoint();
+            return result;
+        }
+        finally {
+            this.#active -= 1;
+            this.#emit({
+                callId,
+                fixtureId,
+                generation,
+                nonce: this.#descriptor.nonce,
+                phase: "terminal",
+            });
+        }
+    }
+    drainEvents() {
+        const events = Object.freeze(this.#events);
+        this.#events = [];
+        return events;
+    }
+    snapshot() {
+        return Object.freeze({
+            active: this.#active,
+            held: this.#gates.size,
+            abortListeners: this.#abortListeners,
+            staleSettlements: this.#staleSettlements,
+        });
+    }
+    #context(context, signal, generationSignal, fixtureId, generation, callId) {
+        const checkpoint = () => {
+            if (generationSignal.aborted || generation !== this.#generation)
+                this.#stale(fixtureId, generation, callId);
+            context.checkpoint();
+        };
+        return {
+            get sequence() {
+                return context.sequence;
+            },
+            get phase() {
+                return context.phase;
+            },
+            signal,
+            checkpoint,
+            markExecuting: () => context.markExecuting(),
+            enterCompletionCritical: () => {
+                checkpoint();
+                context.enterCompletionCritical();
+            },
+        };
+    }
+    async #awaitGate(key, gate, context) {
+        let rejectAbort;
+        const aborted = new Promise((_, reject) => (rejectAbort = reject));
+        const abort = () => {
+            if (this.#gates.get(key) === gate)
+                this.#gates.delete(key);
+            try {
+                context.checkpoint();
+            }
+            catch (error) {
+                rejectAbort(error);
+            }
+        };
+        context.signal.addEventListener("abort", abort, { once: true });
+        this.#abortListeners += 1;
+        try {
+            if (context.signal.aborted)
+                abort();
+            await Promise.race([gate.promise, aborted]);
+        }
+        finally {
+            context.signal.removeEventListener("abort", abort);
+            this.#abortListeners -= 1;
+        }
+    }
+    #stale(fixtureId, generation, callId) {
+        this.#staleSettlements += 1;
+        this.#emit({ callId, fixtureId, generation, nonce: this.#descriptor.nonce, phase: "stale" });
+        throw new H03TimeoutFixtureError();
+    }
+    #emit(event) {
+        this.#events.push(Object.freeze(event));
+        appendFileSync(path.join(this.#descriptor.controlDirectory, "events.jsonl"), `${JSON.stringify(event)}\n`, { encoding: "utf8", flag: "a" });
+    }
+    #assertId(fixtureId) {
+        if (!FIXTURE_ID.test(fixtureId))
+            throw new Error("Invalid H-03 fixture id.");
+    }
+    #key(fixtureId, generation) {
+        return `${generation}:${fixtureId}`;
+    }
+}
+let configuredH05Controller;
+let configuredH05Descriptor;
+// Capture the closed command once before scheduler enqueue; mutable files cannot relabel it.
+// prettier-ignore
+export function captureConfiguredH05Command() { const raw = process.env.AST_H05_FIXTURE; if (raw === undefined)
+    return undefined; const descriptor = parseH05FixtureDescriptor(raw); if (!descriptor)
+    throw new Error("Invalid H-05 fixture descriptor."); if (configuredH05Descriptor) {
+    const sameGeneration = descriptor.generation === configuredH05Descriptor.generation, sameIdentity = descriptor.controlDirectory === configuredH05Descriptor.controlDirectory && descriptor.nonce === configuredH05Descriptor.nonce && descriptor.ownerToken === configuredH05Descriptor.ownerToken;
+    if (sameGeneration && !sameIdentity)
+        throw new Error("H-05 fixture descriptor drift.");
+    if (descriptor.generation < configuredH05Descriptor.generation)
+        throw new Error("H-05 fixture generation regressed.");
+    if (descriptor.generation > configuredH05Descriptor.generation) {
+        configuredH05Controller?.advance({ ...configuredH05Descriptor, generation: descriptor.generation });
+        configuredH05Controller = undefined;
+        configuredH05Descriptor = descriptor;
+        const replacement = new H05LifecycleFixtureController(descriptor);
+        configuredH05Controller = replacement;
+    }
+}
+else {
+    configuredH05Controller = new H05LifecycleFixtureController(descriptor);
+    configuredH05Descriptor = descriptor;
+} if (!configuredH05Controller)
+    throw new Error("H-05 fixture generation is retired."); const value = JSON.parse(readFileSync(path.join(descriptor.controlDirectory, "command.json"), "utf8")); if (Object.keys(value).sort().join(",") !== "callId,correlationId,fixtureId,mode,nonce,ownerToken" || value.nonce !== descriptor.nonce || value.ownerToken !== descriptor.ownerToken || !["hold", "pass", "readback"].includes(value.mode))
+    throw new Error("Invalid H-05 fixture command."); const command = Object.freeze({ ...value }); const captured = configuredH05Controller.capture({ callId: command.callId, correlationId: command.correlationId, fixtureId: command.fixtureId }); return Object.freeze({ controller: configuredH05Controller, descriptor, command, captured }); }
+// prettier-ignore
+export async function runConfiguredH05Fixture(context, operation, configured) { const { controller, descriptor, command, captured } = configured; if (!controller.accepts(captured))
+    throw new H03TimeoutFixtureError(); if (command.mode === "readback") {
+    const snapshot = controller.snapshot(), eventsDrained = controller.drainEvents().length;
+    appendFileSync(path.join(descriptor.controlDirectory, "events.jsonl"), `${JSON.stringify({ ...snapshot, callId: captured.callId, correlationId: captured.correlationId, eventsDrained, fixtureId: captured.fixtureId, generation: captured.generation, phase: "readback" })}\n`);
+    const result = await operation(context);
+    if (!controller.accepts(captured))
+        throw new H03TimeoutFixtureError();
+    context.checkpoint();
+    return result;
+} if (command.mode === "hold")
+    controller.hold(captured); return controller.run(captured, context, operation); }
+let configuredController;
+let configuredDescriptor;
+const errorCommands = new WeakMap();
+// Compact closed test-only wiring preserves PR3's hard review budget.
+// prettier-ignore
+function configuredFixture() { const descriptor = parseH03FixtureDescriptor(process.env.AST_H03_FIXTURE); if (!descriptor)
+    return undefined; if (!configuredController || configuredDescriptor?.generation !== descriptor.generation) {
+    configuredDescriptor = descriptor;
+    configuredController = new H03TimeoutFixtureController(descriptor);
+} return { controller: configuredController, descriptor }; }
+// prettier-ignore
+function readCommand(descriptor) { const value = JSON.parse(readFileSync(path.join(descriptor.controlDirectory, "command.json"), "utf8")); if (Object.keys(value).sort().join(",") !== "callId,fixtureId,mode,nonce" || typeof value.callId !== "string" || !FIXTURE_ID.test(value.callId) || typeof value.fixtureId !== "string" || !FIXTURE_ID.test(value.fixtureId) || value.nonce !== descriptor.nonce || !["hold", "pass", "readback"].includes(value.mode))
+    throw new Error("Invalid H-03 fixture command."); return value; }
+// Capture once before scheduler enqueue; later command.json writes cannot relabel this request.
+// prettier-ignore
+export function captureConfiguredH03Command() { const fixture = configuredFixture(); return fixture && Object.freeze({ ...fixture, command: readCommand(fixture.descriptor) }); }
+// prettier-ignore
+export function bindConfiguredH03Error(error, captured) { if (captured && typeof error === "object" && error !== null)
+    errorCommands.set(error, captured); }
+export function configuredH05CorrelationId(error) {
+    const configured = typeof error === "object" && error !== null ? errorCommands.get(error) : undefined;
+    return configured && "captured" in configured ? configured.captured.correlationId : undefined;
+}
+// prettier-ignore
+export async function runConfiguredH03Fixture(context, operation, captured) { const { controller, descriptor, command } = captured; if (command.mode === "readback") {
+    const snapshot = controller.snapshot(), eventsDrained = controller.drainEvents().length;
+    appendFileSync(path.join(descriptor.controlDirectory, "events.jsonl"), `${JSON.stringify({ ...snapshot, callId: command.callId, eventsDrained, fixtureId: command.fixtureId, generation: descriptor.generation, nonce: descriptor.nonce, phase: "readback" })}\n`);
+    return operation(context);
+} if (command.mode === "hold")
+    controller.hold(command.fixtureId); return controller.run(command.fixtureId, descriptor.generation, context, operation, command.callId); }
+// prettier-ignore
+export function emitConfiguredH03HostEvent(phase, generation) { const descriptor = parseH03FixtureDescriptor(process.env.AST_H03_FIXTURE); if (!descriptor)
+    return; appendFileSync(path.join(descriptor.controlDirectory, "events.jsonl"), `${JSON.stringify({ fixtureId: "host", generation, nonce: descriptor.nonce, phase })}\n`, { encoding: "utf8", flag: "a" }); }
+// prettier-ignore
+export function emitConfiguredH03ErrorEvidence(text, error) { const configured = typeof error === "object" && error !== null ? errorCommands.get(error) : undefined; if (!configured)
+    return; const { descriptor, command } = configured; if (!("captured" in configured)) {
+    appendFileSync(path.join(descriptor.controlDirectory, "events.jsonl"), `${JSON.stringify({ callId: command.callId, fixtureId: command.fixtureId, generation: descriptor.generation, nonce: descriptor.nonce, phase: "error", result: { isError: true, error: { info: { name: error instanceof Error ? error.name : "Error" }, message: text } } })}\n`);
+    return;
+} const { controller, captured } = configured; if (!controller.accepts(captured))
+    return; let publicError; try {
+    publicError = JSON.parse(text);
+}
+catch {
+    publicError = undefined;
+} const source = publicError?.error, code = typeof source?.code === "string" && PUBLIC_ERROR_CODES.some((value) => value === source.code) ? source.code : "INTERNAL_ERROR", correlation_id = typeof source?.correlation_id === "string" && UUID.test(source.correlation_id) ? source.correlation_id : captured.correlationId, name = error instanceof Error && /^[A-Za-z][A-Za-z0-9]{0,63}$/.test(error.name) ? error.name : "Error", message = typeof source?.message === "string" ? sanitizePublicText(source.message) : "An internal error occurred."; const identity = { callId: captured.callId, correlationId: captured.correlationId, fixtureId: captured.fixtureId, generation: captured.generation, ownerToken: captured.ownerToken, phase: "error", resources: controller.snapshot(), result: { isError: true, error: { code, message, correlation_id, info: { name } } } }; let serialized = JSON.stringify(identity); if (Buffer.byteLength(serialized) > 4096)
+    serialized = JSON.stringify({ ...identity, result: { ...identity.result, error: { ...identity.result.error, message: "Evidence message omitted: bounded record exceeded." } } }); appendFileSync(path.join(descriptor.controlDirectory, "events.jsonl"), `${serialized}\n`); }

package/dist/services/opencode-config.js

@@ -3,6 +3,49 @@ import { link, mkdir, mkdtemp, open, readFile, rename, rm, stat, writeFile, } fr
 import os from "node:os";
 import path from "node:path";
 import { applyEdits, modify, parse } from "jsonc-parser";
+export class OpenCodeConfigRecoveryError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = "OpenCodeConfigRecoveryError";
+    }
+}
+function desiredAst(nodeExecutable, serverEntryPath) {
+    return {
+        type: "local",
+        command: [nodeExecutable, serverEntryPath],
+        enabled: true,
+        environment: { AST_MCP_APPLY_GUARD: "allow" },
+    };
+}
+export function classifyOpenCodeAstRegistration(value, nodeExecutable, serverEntryPath) {
+    if (value === undefined)
+        return "missing";
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return "conflict";
+    const registration = value;
+    const command = registration.command;
+    const baseMatches = registration.type === "local" &&
+        registration.enabled === true &&
+        Array.isArray(command) &&
+        command.length === 2 &&
+        command[0] === nodeExecutable &&
+        command[1] === serverEntryPath;
+    if (!baseMatches)
+        return "conflict";
+    const keys = Object.keys(registration).sort().join(",");
+    if (keys === "command,enabled,type")
+        return "repairable";
+    if (keys !== "command,enabled,environment,type")
+        return "conflict";
+    const environment = registration.environment;
+    return environment !== null &&
+        typeof environment === "object" &&
+        !Array.isArray(environment) &&
+        Object.keys(environment).length === 1 &&
+        environment.AST_MCP_APPLY_GUARD === "allow"
+        ? "current"
+        : "conflict";
+}
 function hash(value) {
     return createHash("sha256").update(value).digest("hex");
 }
@@ -80,14 +123,11 @@ export async function planOpenCodeConfig(options) {
     }
     if (!parsed || typeof parsed !== "object")
         throw new Error("OpenCode configuration must contain an object.");
-    const desired = {
-        type: "local",
-        command: [options.nodeExecutable, options.serverEntryPath],
-        enabled: true,
-    };
-    if (parsed.mcp?.ast !== undefined && JSON.stringify(parsed.mcp.ast) !== JSON.stringify(desired))
+    const desired = desiredAst(options.nodeExecutable, options.serverEntryPath);
+    const registrationStatus = classifyOpenCodeAstRegistration(parsed.mcp?.ast, options.nodeExecutable, options.serverEntryPath);
+    if (registrationStatus === "conflict")
         throw new Error("OpenCode configuration conflict at mcp.ast.");
-    const content = parsed.mcp?.ast === undefined
+    const content = registrationStatus === "missing" || registrationStatus === "repairable"
         ? applyEdits(before, modify(before, ["mcp", "ast"], desired, {
             formattingOptions: { insertSpaces: true, tabSize: 2, eol: "\n" },
         }))
@@ -96,6 +136,7 @@ export async function planOpenCodeConfig(options) {
         filePath: options.filePath,
         beforeHash: hash(beforeExists ? before : ""),
         beforeExists,
+        beforeContent: beforeExists ? before : "",
         mode,
         content,
         status: content === before ? "unchanged" : "installed",
@@ -146,3 +187,39 @@ export async function applyOpenCodeConfigPlan(plan) {
         await rm(temporary, { force: true });
     }
 }
+async function inspectOpenCodeConfigPlanState(plan) {
+    let content = "";
+    let exists = true;
+    let mode;
+    try {
+        content = await readFile(plan.filePath, "utf8");
+        mode = (await stat(plan.filePath)).mode & 0o777;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            exists = false;
+        else
+            throw error;
+    }
+    if (!plan.beforeExists && !exists)
+        return "preimage";
+    if (plan.beforeExists && exists && content === plan.beforeContent && mode === plan.mode)
+        return "preimage";
+    if (exists && content === plan.content && mode === plan.mode)
+        return "postimage";
+    return "conflict";
+}
+export async function runOpenCodeConfigTransaction(plan, operation) {
+    try {
+        return await operation();
+    }
+    catch (error) {
+        const state = await inspectOpenCodeConfigPlanState(plan);
+        if (state === "postimage")
+            return undefined;
+        if (state === "conflict") {
+            throw new OpenCodeConfigRecoveryError("OpenCode configuration changed concurrently after an ambiguous write outcome; the concurrent bytes were preserved.", { cause: error });
+        }
+        throw error;
+    }
+}

package/dist/services/project.js

@@ -1,6 +1,8 @@
 import fs from "node:fs";
 import path from "node:path";
 import { Project } from "ts-morph";
+// prettier-ignore
+import { bindConfiguredH03Error, captureConfiguredH03Command, captureConfiguredH05Command, runConfiguredH03Fixture, runConfiguredH05Fixture } from "./h03-timeout-fixture.js";
 import { InMemorySymbolIndex, SYMBOL_INDEX_SCHEMA_VERSION, } from "./symbol-index.js";
 import { addSymbolIndexRuntimeCount, createInitialSymbolIndexRuntimeObservability, readSymbolIndexPersistencePolicy, symbolIndexCachePath, symbolIndexPolicyKey, } from "./symbol-index-policy.js";
 import { openSQLiteSymbolIndexStore, quarantineSQLiteSymbolIndexFile, } from "./symbol-index-sqlite.js";
@@ -650,22 +652,33 @@ async function synchronizeSession(session, requestContext) {
         throw error;
     }
 }
-async function runSessionWithSyncPolicy(session, operation, allowSynchronizationFailure, requestContext) {
+async function runSessionWithSyncPolicy(session, operation, allowSynchronizationFailure, requestContext, h03Fixture = false) {
     requestContext.checkpoint();
-    return session.scheduler.run(async (operationContext) => {
-        operationContext.checkpoint();
-        try {
-            await synchronizeSession(session, operationContext);
-        }
-        catch (error) {
-            if (!allowSynchronizationFailure || isCooperativeInterruption(error))
-                throw error;
-        }
-        operationContext.checkpoint();
-        operationContext.markExecuting();
-        session.lastAccessSequence = nextProjectSessionAccessSequence();
-        return operation(session.context, operationContext);
-    }, { signal: requestContext.signal });
+    const h05Command = h03Fixture ? captureConfiguredH05Command() : undefined;
+    // prettier-ignore
+    const h03Command = h05Command ? undefined : h03Fixture ? captureConfiguredH03Command() : undefined;
+    // prettier-ignore
+    try {
+        return await session.scheduler.run(async (operationContext) => {
+            operationContext.checkpoint();
+            try {
+                await synchronizeSession(session, operationContext);
+            }
+            catch (error) {
+                if (!allowSynchronizationFailure || isCooperativeInterruption(error))
+                    throw error;
+            }
+            operationContext.checkpoint();
+            operationContext.markExecuting();
+            session.lastAccessSequence = nextProjectSessionAccessSequence();
+            const execute = (context) => operation(session.context, context);
+            return h05Command ? runConfiguredH05Fixture(operationContext, execute, h05Command) : h03Command ? runConfiguredH03Fixture(operationContext, execute, h03Command) : execute(operationContext);
+        }, { signal: requestContext.signal });
+    }
+    catch (error) {
+        bindConfiguredH03Error(error, h05Command ?? h03Command);
+        throw error;
+    }
 }
 export async function withProject(projectRoot, operation, requestContext = NO_REQUEST_CONTEXT) {
     requestContext.checkpoint();
@@ -707,7 +720,7 @@ function readProjectStatus(session, requestContext) {
             index_observability: { ...effectiveContext.symbolIndexObservability },
             operation_queue: getQueueStatus(session),
         };
-    }, true, requestContext);
+    }, true, requestContext, true);
 }
 function peekSessionStatus(session) {
     const context = session.context;

package/dist/services/public-errors.js

@@ -1,6 +1,7 @@
 import { Buffer } from "node:buffer";
 import { randomUUID } from "node:crypto";
 import { types as utilTypes } from "node:util";
+import { configuredH05CorrelationId, emitConfiguredH03ErrorEvidence, } from "./h03-timeout-fixture.js";
 export const PUBLIC_ERROR_CODES = Object.freeze([
     "INVALID_INPUT",
     "PROJECT_NOT_FOUND",
@@ -240,12 +241,13 @@ function serializePublicError(code, message, correlationId) {
     };
     return { envelope, text: JSON.stringify(envelope) };
 }
-export function renderPublicError(error, correlationId = randomUUID()) {
+export function renderPublicError(error, correlationId = configuredH05CorrelationId(error) ?? randomUUID()) {
     const classified = classifyPublicError(error);
+    const emitted = (value) => (emitConfiguredH03ErrorEvidence(value.text, error),
+        value);
     const initial = serializePublicError(classified.code, classified.message, correlationId);
-    if (Buffer.byteLength(initial.text, "utf8") <= MAX_PUBLIC_ERROR_RESPONSE_BYTES) {
-        return initial;
-    }
+    if (Buffer.byteLength(initial.text, "utf8") <= MAX_PUBLIC_ERROR_RESPONSE_BYTES)
+        return emitted(initial);
     let lowerBudget = Buffer.byteLength(TRUNCATION_SUFFIX, "utf8");
     let upperBudget = Buffer.byteLength(classified.message, "utf8") - 1;
     let best = serializePublicError(classified.code, TRUNCATION_SUFFIX, correlationId);
@@ -260,5 +262,5 @@ export function renderPublicError(error, correlationId = randomUUID()) {
             upperBudget = candidateBudget - 1;
         }
     }
-    return best;
+    return emitted(best);
 }