ast-mcp-server 0.13.0 → 0.13.1

package/CHANGELOG.md

@@ -6,7 +6,20 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 ## [Unreleased]
 
-## [0.13.0] — local release candidate, pending release (2026-08-27)
+## [0.13.1] - 2026-09-01
+
+### Fixed
+
+- The DeepSeek Harness adapter now opts into a bounded canonical-JSON text projection when a successful MCP result has structured data but no ordinary text, preserving lossless `structuredContent` while making native Agent/Session results useful and durable. The mandatory pinned-host smoke freezes the public 0.13.0 RED baseline and verifies the corrected candidate across the next model request, persisted `tool/result`, cold replay, guarded catalog, and cleanup readback.
+- `ast_explore` now publishes its complete object input schema while retaining all cross-field runtime rejection, and `ast_get_impact` no longer advertises one false output shape across JSON and TOON. The pinned Harness gate binds the public empty-schema RED to candidate registry/native parity and unchanged hashes for the other 14 model schemas.
+- Timeout ownership is now explicit across the Harness, queue, and AST worker: the shipped outer timeout exceeds the complete queue/execution/margin budget, deterministic slow work returns bounded AST-owned operational errors, queued work never starts after its deadline, cancellation remains correlated across worker generations, and cleanup proves zero active work, held requests, listeners, or owned processes.
+- Harness lifecycle handling now converges deterministically through MCP removal and reconnect, rejects retired-generation effects, preserves AST `REQUEST_CANCELLED` authority separately from bridge transport observations, and completes correlated shutdown without residual state. The pinned native and rendered-GUI gates verify the `15→0→15` catalog sequence, request/header identity, secret-safe diagnostics, and ordered cleanup that still runs every owner check after an earlier cleanup failure.
+
+### Release status
+
+- This is the reviewed `0.13.1` release candidate. Publication to npm `next`, public-registry verification, promotion to `latest`, tagging, and GitHub Release creation remain pending and are not claimed here.
+
+## [0.13.0] — published to `latest` and `next`, registry verified (2026-08-29)
 
 ### Added
 

package/README.md

@@ -329,30 +329,47 @@ A thin adapter ships inside this package: `cordis.patch.yml` mounts the packaged
 [`@deepseek-ai/dsh-mcp-client`](https://github.com/deepseek-ai/deepseek-harness/blob/cd5ef8148158c3a752a658978873241fdf8e2bbc/packages/mcp/mcp-client/README.md)
 bridge, declared through exactly `"dsh": { "bundle": { "patch": "./cordis.patch.yml" } }`.
 This is a Developer Preview against a pinned, **source-built** Harness revision
-(`dsh-v0.1.2-alpha.1` at `cd5ef8148158c3a752a658978873241fdf8e2bbc`); that revision
-is validated from source, and `ast-mcp-server@0.13.0` is not published yet. Install a
-locally packed tarball instead:
+(`dsh-v0.1.2-alpha.1` at `cd5ef8148158c3a752a658978873241fdf8e2bbc`). The published
+`ast-mcp-server@0.13.0` package is the compatibility baseline:
+
+```bash
+dsh plugin --profile web add ast-mcp-server@0.13.0
+```
+
+For a local candidate, pack and install its tarball instead:
 
 ```bash
 yarn pack --out ast-mcp-server-%v.tgz
-dsh plugin --profile web add ./ast-mcp-server-0.13.0.tgz
+dsh plugin --profile web add ./ast-mcp-server-0.13.1.tgz
 ```
 
 The first supported surface is **reads + prepare + preview**. Every apply path is
 denied by a fail-closed guard: `ast_apply_operation` is not registered unless
 `AST_MCP_APPLY_GUARD=allow` is set explicitly (the shipped patch instead pins `deny`,
-so the Harness surface stays deny-by-default; an unset or invalid value also denies). Known upstream
-gaps apply and are never safety authority: the official bridge drops MCP tool
-annotations (`readOnlyHint`/`destructiveHint`) and launches the stdio child outside
-the Harness sandbox.
-
-`yarn test:dsh-adapter` is the mandatory verification: it packs the exact tarball,
-installs it into an isolated profile on the pinned Harness, proves `--dump-config`
-composition including effective `tools.mode: native`, and — through the Harness registry
-itself — invokes the server-qualified read, dry-run rename prepare, and preview tools.
-It separately proves `mcp__ast__ast_apply_operation` is absent and that a bounded direct
-registry invocation is rejected. The smoke fails (never skips) if the pinned Harness
-revision, tag, CLI/client version, clean source identity, or a prerequisite is missing.
+so the Harness surface stays deny-by-default; an unset or invalid value also denies).
+The adapter also sets `AST_MCP_TEXT_PROJECTION=canonical_json`: successful structured
+results keep their lossless `structuredContent` and gain canonical JSON text only when
+ordinary MCP text is empty, because the pinned native presenter otherwise exposes only a
+non-useful empty-result marker. The projection is adapter-specific, never replaces existing
+text, and reports an explicit size-limit marker when the complete supervised frame has room.
+If even the unchanged structured-only result exceeds the existing worker frame, supervised mode
+fails closed rather than truncating or corrupting it. Known upstream gaps remain non-authoritative:
+the official bridge drops MCP tool annotations
+(`readOnlyHint`/`destructiveHint`) and launches the stdio child outside the Harness sandbox.
+
+`yarn test:dsh-adapter` is the mandatory verification. It binds the public 0.13.0 npm
+integrity, packs the candidate, builds the pinned Harness and bridge from source, and proves
+`tools.mode: native`, the 15-tool scoped catalog, complete executable input schemas,
+read/prepare/preview, all three invalid `ast_explore` combinations, apply absence, and rejected direct apply.
+The schema gate freezes the public empty `ast_explore` contract as RED, requires the candidate
+registry/native definitions to match, and hashes all 14 unaffected model schemas. A deterministic
+two-step model then invokes
+`mcp__ast__ast_get_project_status` through a real headless Agent/Session: the public baseline
+must reproduce the empty-result marker, while the corrected candidate must deliver lossless
+canonical JSON to the next model request, the durable `tool/result`, and a cold Agent
+resume/replay reconstructed from persistence. The smoke removes and read-backs its disposable
+profile/workspace state and fails
+(never skips) on an identity mismatch, missing prerequisite, lifecycle leak, or evidence gap.
 
 ## MCP tools
 

package/cordis.patch.yml

@@ -3,7 +3,7 @@
 # Mounts the packaged `ast-mcp-server` stdio command through the official
 # `@deepseek-ai/dsh-mcp-client` bridge. Harness does not resolve MCP binaries
 # from PATH, so the entrypoint is resolved relative to the profile directory
-# (`baseUrl`), where `dsh plugin --profile <name> add ./ast-mcp-server-0.13.0.tgz`
+# (`baseUrl`), where `dsh plugin --profile <name> add ./ast-mcp-server-0.13.1.tgz`
 # installs a locally packed package as a dependency.
 #
 # First-slice surface: reads + prepare + preview. Every apply path is denied
@@ -13,6 +13,8 @@
 # - the official bridge drops MCP tool.annotations, incl. readOnlyHint and
 #   destructiveHint, so the guard enumerates tool names instead of hints;
 # - the stdio child runs outside the Harness sandbox.
+# Harness native presentation reads text content, so this adapter explicitly
+# requests a lossless canonical JSON projection while preserving structuredContent.
 - insert:
     - id: mcp-ast
       name: "@deepseek-ai/dsh-mcp-client"
@@ -27,5 +29,10 @@
             )
         env:
           AST_MCP_APPLY_GUARD: "deny"
+          AST_MCP_TEXT_PROJECTION: "canonical_json"
         cwd: !!js process.cwd()
+        toolCallTimeoutMs: !!js >-
+          JSON.parse(process.getBuiltinModule('node:fs').readFileSync(
+            new URL('node_modules/ast-mcp-server/package.json', baseUrl), 'utf8'
+          )).deepseekHarness.timeoutBudget.outerToolCallMs
         failOnStartupError: true

package/dist/server.js

@@ -2,9 +2,20 @@ import { createRequire } from "node:module";
 import { McpServer, } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { PublicOperationalError } from "./services/public-errors.js";
 import { toolCatalog } from "./tools/catalog.js";
-import { createToolErrorContext, errorResult } from "./tools/result.js";
+import { createToolErrorContext, errorResult, projectStructuredContentAsText, } from "./tools/result.js";
 const packageMetadata = createRequire(import.meta.url)("../package.json");
 export const PACKAGE_VERSION = packageMetadata.version;
+function installStructuredContentTextProjection(server) {
+    const registerTool = server.registerTool.bind(server);
+    function projectedRegisterTool(name, config, callback) {
+        const projectedCallback = (async (...args) => {
+            const result = await Reflect.apply(callback, undefined, args);
+            return projectStructuredContentAsText(result, true);
+        });
+        return registerTool(name, config, projectedCallback);
+    }
+    server.registerTool = projectedRegisterTool;
+}
 function installRuntimeActivityTracking(server, runtimeActivity) {
     const registerTool = server.registerTool.bind(server);
     function trackedRegisterTool(name, config, callback) {
@@ -25,6 +36,9 @@ export function createServer(options = {}) {
     });
     if (options.runtimeActivity)
         installRuntimeActivityTracking(server, options.runtimeActivity);
+    if (options.projectStructuredContentAsText === true) {
+        installStructuredContentTextProjection(server);
+    }
     if (options.denyApply === undefined) {
         toolCatalog.registerAll(server);
     }

package/dist/services/compiler-worker-host.js

@@ -4,8 +4,9 @@ import { randomUUID } from "node:crypto";
 import { createInterface } from "node:readline";
 import { setTimeout as delay } from "node:timers/promises";
 import { fileURLToPath } from "node:url";
-import { decodeCompilerWorkerEnvelope, startCompilerWorker } from "./compiler-worker-protocol.js";
-import { createCompilerWorkerSpawnSpec, readRuntimePolicy, } from "./runtime-policy.js";
+import { COMPILER_WORKER_MAX_FRAME_BYTES, decodeCompilerWorkerEnvelope, decodeCompilerWorkerResponse, isCompilerWorkerRequestIdWithinBudget, startCompilerWorker, } from "./compiler-worker-protocol.js";
+import { emitConfiguredH03HostEvent } from "./h03-timeout-fixture.js";
+import { createCompilerWorkerSpawnSpec, parseH03FixtureDescriptor, parseH05FixtureDescriptor, readRuntimePolicy, } from "./runtime-policy.js";
 import { emitCompilerWorkerEvent } from "./runtime-logger.js";
 import { PublicOperationalError, renderPublicError } from "./public-errors.js";
 export class CompilerWorkerHostError extends Error {
@@ -17,7 +18,7 @@ export class CompilerWorkerHostError extends Error {
         this.recovery = recovery;
     }
 }
-const bounded = (value) => Buffer.byteLength(JSON.stringify(value)) <= 256 * 1024;
+const bounded = (value) => Buffer.byteLength(JSON.stringify(value)) <= COMPILER_WORKER_MAX_FRAME_BYTES;
 const within = (promise, ms) => Promise.race([
     promise,
     delay(ms, undefined, { ref: false }).then(() => {
@@ -34,7 +35,11 @@ function deferred() {
     return { promise, resolve, reject };
 }
 export function spawnCompilerWorkerProcess(options) {
-    const spec = createCompilerWorkerSpawnSpec(options.workerEntryPath, options.environment);
+    const fixture = parseH03FixtureDescriptor(options.environment.AST_H03_FIXTURE);
+    const lifecycleFixture = parseH05FixtureDescriptor(options.environment.AST_H05_FIXTURE);
+    // prettier-ignore
+    const environment = fixture || lifecycleFixture ? { ...options.environment, ...(fixture ? { AST_H03_FIXTURE: JSON.stringify({ ...fixture, generation: options.generation }) } : {}), ...(lifecycleFixture ? { AST_H05_FIXTURE: JSON.stringify({ ...lifecycleFixture, generation: options.generation }) } : {}) } : options.environment;
+    const spec = createCompilerWorkerSpawnSpec(options.workerEntryPath, environment);
     if (!spec.ok || !spec.command)
         throw new CompilerWorkerHostError("startup");
     const child = spawn(spec.command, spec.args, {
@@ -86,17 +91,12 @@ export function spawnCompilerWorkerProcess(options) {
             snapshots.shift()?.resolve(decoded.value);
     });
     createInterface({ input: child.stdout }).on("line", (line) => {
-        if (Buffer.byteLength(line) > 256 * 1024)
+        const decoded = decodeCompilerWorkerResponse(line);
+        if (!decoded.ok)
             return fail(new CompilerWorkerHostError("protocol"));
-        let message;
-        try {
-            message = JSON.parse(line);
-        }
-        catch {
-            return fail(new CompilerWorkerHostError("protocol"));
-        }
-        if (!("id" in message) || message.id === undefined)
+        if (decoded.kind === "notification")
             return;
+        const message = decoded.value;
         const request = pending.get(message.id);
         if (!request)
             return;
@@ -108,7 +108,10 @@ export function spawnCompilerWorkerProcess(options) {
         });
     });
     const write = (message, acknowledge = false) => {
-        if (!bounded(message) || !child.stdin?.writable)
+        const requestIdWithinBudget = !("id" in message) ||
+            message.id === undefined ||
+            isCompilerWorkerRequestIdWithinBudget(message.id);
+        if (!requestIdWithinBudget || !bounded(message) || !child.stdin?.writable)
             return Promise.reject(new CompilerWorkerHostError("protocol"));
         options.beforeWrite?.(message);
         const writeSequence = ++writes, processed = acknowledge ? deferred() : undefined;
@@ -217,7 +220,7 @@ export class CompilerWorkerHost {
         return this.scheduleIdle(); this.parentAdmission = "closed"; const second = await child.snapshot(); if (child !== this.child || generation !== this.generation || sequence !== this.sequence || activity !== this.activity || !CompilerWorkerHost.quiescent(second)) {
         this.parentAdmission = "open";
         return this.scheduleIdle();
-    } await this.stopChild(child, "requested"); emitCompilerWorkerEvent({ kind: "idle", generation }); this.parentAdmission = "open"; }
+    } await this.stopChild(child, "requested"); emitCompilerWorkerEvent({ kind: "idle", generation }); emitConfiguredH03HostEvent("recycled", generation); this.parentAdmission = "open"; }
     // prettier-ignore
     async stopChild(child, trigger) { const completion = child.shutdown(trigger); try {
         await within(completion, this.timeoutMs);
@@ -412,7 +415,24 @@ export async function runSupervisedStdioServer() {
                 const rendered = ambiguous
                     ? renderPublicError(new PublicOperationalError("AMBIGUOUS_APPLY", "The apply outcome is ambiguous."), ambiguous.correlation_id).envelope.error
                     : undefined;
-                process.stdout.write(`${JSON.stringify({ jsonrpc: "2.0", id: message.id, error: { code: -32603, message: rendered?.message ?? "Compiler worker request failed.", ...(ambiguous ? { data: { code: "AMBIGUOUS_APPLY", ...ambiguous } } : {}) } })}\n`);
+                const responseId = isCompilerWorkerRequestIdWithinBudget(message.id) ? message.id : null;
+                const candidate = {
+                    jsonrpc: "2.0",
+                    id: responseId,
+                    error: {
+                        code: -32603,
+                        message: rendered?.message ?? "Compiler worker request failed.",
+                        ...(ambiguous ? { data: { code: "AMBIGUOUS_APPLY", ...ambiguous } } : {}),
+                    },
+                };
+                const response = bounded(candidate)
+                    ? candidate
+                    : {
+                        jsonrpc: "2.0",
+                        id: null,
+                        error: { code: -32603, message: "Compiler worker request failed." },
+                    };
+                process.stdout.write(`${JSON.stringify(response)}\n`);
             }
         }
     };

package/dist/services/compiler-worker-protocol.js

@@ -1,11 +1,79 @@
 import { Buffer } from "node:buffer";
+export const COMPILER_WORKER_MAX_FRAME_BYTES = 256 * 1024;
+export const COMPILER_WORKER_MAX_REQUEST_ID_BYTES = 8 * 1024;
+export const COMPILER_WORKER_JSONRPC_ENVELOPE_RESERVE_BYTES = 16 * 1024;
+export const COMPILER_WORKER_MAX_RESULT_BYTES = COMPILER_WORKER_MAX_FRAME_BYTES - COMPILER_WORKER_JSONRPC_ENVELOPE_RESERVE_BYTES;
 const FIELDS = new Set(["v", "generation", "sequence", "type", "payload"]);
 const TYPES = new Set(["handshake", "snapshot", "shutdown", "ready", "settled", "lease", "exit"]);
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+export function isCompilerWorkerRequestIdWithinBudget(id) {
+    try {
+        return Buffer.byteLength(JSON.stringify(id)) <= COMPILER_WORKER_MAX_REQUEST_ID_BYTES;
+    }
+    catch {
+        return false;
+    }
+}
+export function fitsCompilerWorkerResponseResult(result) {
+    try {
+        const frame = JSON.stringify({
+            jsonrpc: "2.0",
+            id: "x".repeat(COMPILER_WORKER_MAX_REQUEST_ID_BYTES - 2),
+            result,
+        });
+        return Buffer.byteLength(frame) <= COMPILER_WORKER_MAX_FRAME_BYTES;
+    }
+    catch {
+        return false;
+    }
+}
+export function decodeCompilerWorkerResponse(frame) {
+    if (Buffer.byteLength(frame) > COMPILER_WORKER_MAX_FRAME_BYTES) {
+        return { ok: false, reason: "oversized" };
+    }
+    let value;
+    try {
+        value = JSON.parse(frame);
+    }
+    catch {
+        return { ok: false, reason: "malformed" };
+    }
+    if (!isRecord(value) || value.jsonrpc !== "2.0") {
+        return { ok: false, reason: "invalid_response" };
+    }
+    if (Object.hasOwn(value, "method") && !Object.hasOwn(value, "id")) {
+        if (typeof value.method !== "string" ||
+            Object.keys(value).some((key) => !["jsonrpc", "method", "params"].includes(key))) {
+            return { ok: false, reason: "invalid_notification" };
+        }
+        return { ok: true, kind: "notification", value };
+    }
+    if (Object.keys(value).some((key) => !["jsonrpc", "id", "result", "error"].includes(key))) {
+        return { ok: false, reason: "unknown_field" };
+    }
+    if (!(typeof value.id === "string" || typeof value.id === "number") ||
+        !isCompilerWorkerRequestIdWithinBudget(value.id)) {
+        return { ok: false, reason: "invalid_id" };
+    }
+    const hasResult = Object.hasOwn(value, "result");
+    const hasError = Object.hasOwn(value, "error");
+    if (hasResult === hasError)
+        return { ok: false, reason: "invalid_response" };
+    if (hasError) {
+        const error = value.error;
+        if (!isRecord(error) ||
+            typeof error.code !== "number" ||
+            !Number.isSafeInteger(error.code) ||
+            typeof error.message !== "string") {
+            return { ok: false, reason: "invalid_error" };
+        }
+    }
+    return { ok: true, kind: "response", value };
+}
 export function decodeCompilerWorkerEnvelope(frame) {
-    if (Buffer.byteLength(frame) > 256 * 1024) {
+    if (Buffer.byteLength(frame) > COMPILER_WORKER_MAX_FRAME_BYTES) {
         return { ok: false, reason: "oversized" };
     }
     let value;
@@ -47,7 +115,7 @@ export function validateInitializationReplay(frames) {
         "id" in notification) {
         return { ok: false, reason: "missing_replay" };
     }
-    if (Buffer.byteLength(JSON.stringify(frames)) > 256 * 1024) {
+    if (Buffer.byteLength(JSON.stringify(frames)) > COMPILER_WORKER_MAX_FRAME_BYTES) {
         return { ok: false, reason: "oversized_replay" };
     }
     return { ok: true, frames: [request, notification] };

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/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);
 }

package/dist/services/runtime-policy.js

@@ -1,4 +1,5 @@
 import path from "node:path";
+import packageMetadata from "../../package.json" with { type: "json" };
 export const RUNTIME_POLICY_ENV_KEYS = Object.freeze([
     "AST_MAX_PROJECT_SESSIONS",
     "AST_MAX_QUEUED_OPERATIONS_PER_PROJECT",
@@ -8,6 +9,7 @@ export const RUNTIME_POLICY_ENV_KEYS = Object.freeze([
     "AST_COMPILER_WORKER_MODE",
     "AST_COMPILER_WORKER_IDLE_TTL_MS",
     "AST_MCP_APPLY_GUARD",
+    "AST_MCP_TEXT_PROJECTION",
 ]);
 function parseBoundedInteger(rawValue, defaultValue, minimum, maximum) {
     if (rawValue === undefined)
@@ -27,8 +29,8 @@ function parseBoundedInteger(rawValue, defaultValue, minimum, maximum) {
 export function parseRuntimePolicy(environment) {
     const maxProjectSessions = parseBoundedInteger(environment.AST_MAX_PROJECT_SESSIONS, 8, 1, 32);
     const maxQueuedOperationsPerProject = parseBoundedInteger(environment.AST_MAX_QUEUED_OPERATIONS_PER_PROJECT, 32, 1, 256);
-    const queueWaitTimeoutMs = parseBoundedInteger(environment.AST_QUEUE_WAIT_TIMEOUT_MS, 30_000, 100, 300_000);
-    const operationDeadlineMs = parseBoundedInteger(environment.AST_OPERATION_DEADLINE_MS, 120_000, 1_000, 900_000);
+    const queueWaitTimeoutMs = parseBoundedInteger(environment.AST_QUEUE_WAIT_TIMEOUT_MS, packageMetadata.deepseekHarness.timeoutBudget.queueWaitMs, 100, 300_000);
+    const operationDeadlineMs = parseBoundedInteger(environment.AST_OPERATION_DEADLINE_MS, packageMetadata.deepseekHarness.timeoutBudget.executionDeadlineMs, 1_000, 900_000);
     const shutdownDrainTimeoutMs = parseBoundedInteger(environment.AST_SHUTDOWN_DRAIN_TIMEOUT_MS, 10_000, 100, 60_000);
     const rawWorkerMode = environment.AST_COMPILER_WORKER_MODE;
     const compilerWorkerMode = rawWorkerMode === "supervised" ? "supervised" : "in_process";
@@ -47,6 +49,13 @@ export function parseRuntimePolicy(environment) {
         : rawApplyGuard === "allow" || rawApplyGuard === "deny"
             ? "configured"
             : "invalid_mode";
+    const rawTextProjection = environment.AST_MCP_TEXT_PROJECTION;
+    const projectStructuredContentAsText = rawTextProjection === "canonical_json";
+    const textProjectionReason = rawTextProjection === undefined
+        ? "default"
+        : projectStructuredContentAsText
+            ? "configured"
+            : "invalid_mode";
     const reasons = Object.freeze({
         AST_MAX_PROJECT_SESSIONS: maxProjectSessions.reason,
         AST_MAX_QUEUED_OPERATIONS_PER_PROJECT: maxQueuedOperationsPerProject.reason,
@@ -56,6 +65,7 @@ export function parseRuntimePolicy(environment) {
         AST_COMPILER_WORKER_MODE: compilerWorkerModeReason,
         AST_COMPILER_WORKER_IDLE_TTL_MS: compilerWorkerIdleTtlMs.reason,
         AST_MCP_APPLY_GUARD: applyGuardReason,
+        AST_MCP_TEXT_PROJECTION: textProjectionReason,
     });
     return Object.freeze({
         maxProjectSessions: maxProjectSessions.value,
@@ -66,6 +76,7 @@ export function parseRuntimePolicy(environment) {
         compilerWorkerMode,
         compilerWorkerIdleTtlMs: compilerWorkerIdleTtlMs.value,
         denyApply,
+        projectStructuredContentAsText,
         reasons,
     });
 }
@@ -76,6 +87,46 @@ const WORKER_ENV_KEYS = [
     "AST_SYMBOL_INDEX_BUSY_TIMEOUT_MS",
 ];
 const MAX_WORKER_ENV_VALUE_LENGTH = 4096;
+function parseClosedFixtureRecord(raw, expectedKeys) {
+    if (typeof raw !== "string" || raw.length > 1024 || raw.includes("\0"))
+        return undefined;
+    try {
+        const value = JSON.parse(raw);
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            return undefined;
+        const record = value;
+        return Object.keys(record).sort().join(",") === expectedKeys ? record : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function parseH03FixtureDescriptor(raw) {
+    const record = parseClosedFixtureRecord(raw, "controlDirectory,generation,nonce");
+    if (!record)
+        return undefined;
+    const { controlDirectory, nonce, generation } = record;
+    if (typeof controlDirectory !== "string" ||
+        controlDirectory.length > MAX_WORKER_ENV_VALUE_LENGTH ||
+        !path.isAbsolute(controlDirectory) ||
+        path.normalize(controlDirectory) !== controlDirectory ||
+        typeof nonce !== "string" ||
+        !/^[A-Za-z0-9_-]{16,64}$/.test(nonce) ||
+        !Number.isSafeInteger(generation) ||
+        generation < 1)
+        return undefined;
+    return Object.freeze({ controlDirectory, nonce, generation: generation });
+}
+export function parseH05FixtureDescriptor(raw) {
+    const record = parseClosedFixtureRecord(raw, "controlDirectory,generation,nonce,ownerToken");
+    if (!record)
+        return undefined;
+    const { ownerToken, ...baseValue } = record;
+    if (typeof ownerToken !== "string" || !/^[A-Za-z0-9_-]{16,64}$/.test(ownerToken))
+        return undefined;
+    const base = parseH03FixtureDescriptor(JSON.stringify(baseValue));
+    return base ? Object.freeze({ ...base, ownerToken }) : undefined;
+}
 function validEnvironmentString(value) {
     return (typeof value === "string" &&
         value.length <= MAX_WORKER_ENV_VALUE_LENGTH &&
@@ -100,6 +151,20 @@ export function createCompilerWorkerSpawnSpec(workerEntryPath, environment) {
         }
         projected[key] = value;
     }
+    const fixture = environment.AST_H03_FIXTURE;
+    if (fixture !== undefined) {
+        const descriptor = parseH03FixtureDescriptor(fixture);
+        if (!descriptor)
+            return { ok: false, reason: "invalid_environment" };
+        projected.AST_H03_FIXTURE = JSON.stringify(descriptor);
+    }
+    const lifecycleFixture = environment.AST_H05_FIXTURE;
+    if (lifecycleFixture !== undefined) {
+        const descriptor = parseH05FixtureDescriptor(lifecycleFixture);
+        if (!descriptor)
+            return { ok: false, reason: "invalid_environment" };
+        projected.AST_H05_FIXTURE = JSON.stringify(descriptor);
+    }
     const policy = parseRuntimePolicy(environment);
     Object.assign(projected, {
         AST_MAX_PROJECT_SESSIONS: String(policy.maxProjectSessions),
@@ -110,6 +175,7 @@ export function createCompilerWorkerSpawnSpec(workerEntryPath, environment) {
         // Forward the parent's resolved apply-guard policy so the supervised worker
         // registers the same tool surface (deny-by-default fail-closed, allow opt-in).
         AST_MCP_APPLY_GUARD: policy.denyApply ? "deny" : "allow",
+        ...(policy.projectStructuredContentAsText ? { AST_MCP_TEXT_PROJECTION: "canonical_json" } : {}),
     });
     return {
         ok: true,

package/dist/tools/explore.js

@@ -17,7 +17,7 @@ const CallSpinesInputSchema = z.object({
     max_nodes: z.number().int().min(1).max(MAX_IMPACT_NODES).default(DEFAULT_IMPACT_MAX_NODES),
     max_edges: z.number().int().min(1).max(MAX_IMPACT_EDGES).default(DEFAULT_IMPACT_MAX_EDGES),
 });
-const ExploreInputSchema = z
+const ExploreInputObjectSchema = z
     .object({
     project_root: z
         .string()
@@ -65,7 +65,8 @@ const ExploreInputSchema = z
         .default(EXPLORE_DEFAULT_OMISSION_DETAIL_LIMIT)
         .describe("Maximum deterministic omission detail records; exact counts are always retained."),
 })
-    .refine((input) => Boolean(input.query || input.file_path), {
+    .strip();
+const ExploreInputSchema = ExploreInputObjectSchema.refine((input) => Boolean(input.query || input.file_path), {
     message: "Provide query, file_path, or both file_path and symbol_path.",
     path: ["query"],
 })
@@ -204,7 +205,7 @@ export function registerExplore(server) {
     server.registerTool(TOOL_NAME, {
         title: "Explore project context",
         description: "Composes bounded structural search, exact selectors, source evidence and compiler references without weakening the primitive AST tools. Returns bounded session freshness metadata for fresh, pending, stale, rebuilding or degraded state.",
-        inputSchema: ExploreInputSchema,
+        inputSchema: ExploreInputObjectSchema,
         outputSchema: ExploreOutputSchema,
         annotations: {
             readOnlyHint: true,
@@ -215,6 +216,7 @@ export function registerExplore(server) {
     }, async ({ project_root, query, file_path, symbol_path, kinds, file_filter, detail, include_source, include_references, reference_detail, reference_limit, offset, limit, max_bytes, call_spines, omission_detail_limit, }, extra) => {
         const requestContext = createRequestContext(extra.signal);
         try {
+            ExploreInputSchema.parse({ project_root, query, file_path, symbol_path, call_spines });
             const output = await withProject(project_root, (context, operationContext) => buildExploreContext(context, {
                 query,
                 filePath: file_path,

package/dist/tools/get_impact.js

@@ -73,7 +73,6 @@ export function registerGetImpact(server) {
         title: "Get bounded compiler-backed impact",
         description: "Traverses exact compiler-backed relationships around a symbol with explicit direction, depth, node and edge budgets. Returns bounded session freshness metadata and fails closed when exact relationships are not fresh. Read-only evidence only; it never prepares or applies mutations.",
         inputSchema: AstGetImpactInputSchema,
-        outputSchema: ImpactOutputSchema,
         annotations: {
             readOnlyHint: true,
             destructiveHint: false,

package/dist/tools/result.js

@@ -2,10 +2,15 @@ import { Buffer } from "node:buffer";
 import { isDeepStrictEqual } from "node:util";
 import { decode, encode } from "@toon-format/toon";
 import { z } from "zod";
+import { COMPILER_WORKER_MAX_RESULT_BYTES, fitsCompilerWorkerResponseResult, } from "../services/compiler-worker-protocol.js";
 import { createProjectIdentity } from "../services/project-status.js";
 import { renderPublicError } from "../services/public-errors.js";
 import { emitToolFailureEvent } from "../services/runtime-logger.js";
 export const MAX_TOON_RESULT_BYTES = 10 * 1024 * 1024;
+// Leave room for the unchanged structured value plus JSON-RPC framing under
+// the supervised worker's 256 KiB line limit.
+export const MAX_TEXT_PROJECTION_BYTES = 112 * 1024;
+export const MAX_PROJECTED_RESULT_BYTES = COMPILER_WORKER_MAX_RESULT_BYTES;
 export const ToolOutputFormatSchema = z.enum(["json", "toon"]).default("json");
 export const ToolOutputFormatInputSchema = {
     output_format: ToolOutputFormatSchema.describe("Result representation. TOON wraps one compact encoded value in structuredContent."),
@@ -24,6 +29,49 @@ export function createToolErrorContext(toolName, projectRoot) {
         return { toolName };
     }
 }
+/**
+ * Add a deterministic model-visible JSON projection without replacing the
+ * canonical structured value. Existing content wins, and oversized values get
+ * an explicit bounded marker when the complete framed result has room for it;
+ * otherwise the unchanged structured-only result remains authoritative.
+ */
+export function projectStructuredContentAsText(result, enabled, maxBytes = MAX_TEXT_PROJECTION_BYTES) {
+    if (!enabled ||
+        result.isError === true ||
+        result.content.length > 0 ||
+        result.structuredContent === undefined) {
+        return result;
+    }
+    let text;
+    try {
+        text =
+            JSON.stringify(result.structuredContent) ??
+                "(structured result is not JSON-serializable for model-visible projection)";
+    }
+    catch {
+        text = "(structured result is not JSON-serializable for model-visible projection)";
+    }
+    const byteLength = Buffer.byteLength(text, "utf8");
+    if (byteLength > maxBytes) {
+        text = `(structured result exceeds the ${maxBytes}-byte model-visible projection limit; canonical structuredContent remains available)`;
+    }
+    let projected = {
+        ...result,
+        content: [{ type: "text", text }],
+    };
+    if (fitsCompilerWorkerResponseResult(projected))
+        return projected;
+    projected = {
+        ...result,
+        content: [
+            {
+                type: "text",
+                text: `(structured result exceeds the ${MAX_PROJECTED_RESULT_BYTES}-byte complete projection limit; canonical structuredContent remains available)`,
+            },
+        ],
+    };
+    return fitsCompilerWorkerResponseResult(projected) ? projected : result;
+}
 export function structuredResult(structuredContent) {
     return { content: [], structuredContent };
 }

package/dist/worker-runtime.js

@@ -15,7 +15,12 @@ export async function runStdioServer(options = {}) {
     const runtimeActivity = options.runtimeActivity ?? new RuntimeActivityTracker();
     runtimeActivity.prepareForStartup();
     const runtimePolicy = options.runtimePolicy ?? readRuntimePolicy();
-    const server = options.server ?? createServer({ runtimeActivity, denyApply: runtimePolicy.denyApply });
+    const server = options.server ??
+        createServer({
+            runtimeActivity,
+            denyApply: runtimePolicy.denyApply,
+            projectStructuredContentAsText: runtimePolicy.projectStructuredContentAsText,
+        });
     const transport = options.transport ?? new StdioServerTransport();
     const send = transport.send.bind(transport);
     transport.send = (message, sendOptions) => runtimeActivity.trackSend(() => send(message, sendOptions));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ast-mcp-server",
-  "version": "0.13.0",
+  "version": "0.13.1",
   "description": "Structural code MCP server and batch CLI for compact TypeScript/JavaScript reads and hash-bound AST edits.",
   "keywords": [
     "mcp",
@@ -34,7 +34,13 @@
   "deepseekHarness": {
     "revision": "cd5ef8148158c3a752a658978873241fdf8e2bbc",
     "tag": "dsh-v0.1.2-alpha.1",
-    "mcpClientVersion": "0.1.2-alpha.1"
+    "mcpClientVersion": "0.1.2-alpha.1",
+    "timeoutBudget": {
+      "queueWaitMs": 30000,
+      "executionDeadlineMs": 120000,
+      "marginMs": 15000,
+      "outerToolCallMs": 180000
+    }
   },
   "main": "dist/index.js",
   "bin": {
@@ -110,5 +116,5 @@
     "vitest": "^4.1.10",
     "yaml": "^2.9.0"
   },
-  "gitHead": "75302189733f40aba6a36a8379c5b1f65fc3bd84"
+  "gitHead": "27b80a3da169b473a3b5c5dfea69ed52903ed4c7"
 }