rea-agents 6.1.0 → 6.3.0

package/dist/inspector/V8InspectorCaptureProjection.js

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { authorizeRuntimeLocation, inspectorExclusionKey, throwIfRuntimeObservationCancelled, } from "./JavaScriptRuntimeScope.js";
+import { authorizeRuntimeLocation, inspectorExclusionKey, projectReportedRuntimeUrl, throwIfRuntimeObservationCancelled, } from "./JavaScriptRuntimeScope.js";
 /** Empty durable-location exclusion counters. */
 export const createInspectorExclusionCounts = () => ({
     unsupported_location: 0,
@@ -15,26 +15,29 @@ export const describeInspectorTargetLimitations = () => [
 ];
 const LOCATION_AUTHORIZATION_WORKERS = 8;
 /** Canonically authorize, deduplicate, and sort one bounded raw capture. */
-export const finalizeInspectorCapture = async ({ input, runtime, target, state, authorizeLocation = authorizeRuntimeLocation, signal, }) => {
-    throwIfRuntimeObservationCancelled(signal);
+export const finalizeInspectorCapture = async ({ input, runtime, target, state, authorizeLocation = authorizeRuntimeLocation, locationMode = "verify", signal, }) => {
+    if (locationMode === "verify")
+        throwIfRuntimeObservationCancelled(signal);
     const exclusions = createInspectorExclusionCounts();
     const scripts = new Map();
     const draftsByUrl = new Map();
-    for (const draft of state.scripts) {
-        const drafts = draftsByUrl.get(draft.rawUrl) ?? [];
-        drafts.push(draft);
-        draftsByUrl.set(draft.rawUrl, drafts);
-    }
+    if (locationMode === "verify")
+        for (const draft of state.scripts) {
+            const drafts = draftsByUrl.get(draft.rawUrl) ?? [];
+            drafts.push(draft);
+            draftsByUrl.set(draft.rawUrl, drafts);
+        }
     const groups = [...draftsByUrl];
     const authorizedGroups = new Array(groups.length);
     let nextGroup = 0;
     let stopScheduling = false;
+    let unresolvedScripts = 0;
     const worker = async () => {
         try {
             for (;;) {
-                throwIfRuntimeObservationCancelled(signal);
                 if (stopScheduling)
                     return;
+                throwIfRuntimeObservationCancelled(signal);
                 const index = nextGroup;
                 nextGroup += 1;
                 const group = groups[index];
@@ -53,12 +56,18 @@ export const finalizeInspectorCapture = async ({ input, runtime, target, state,
             throw cause;
         }
     };
-    const workerResults = await Promise.allSettled(Array.from({ length: Math.min(LOCATION_AUTHORIZATION_WORKERS, groups.length) }, worker));
+    const workerResults = locationMode === "verify"
+        ? await Promise.allSettled(Array.from({ length: Math.min(LOCATION_AUTHORIZATION_WORKERS, groups.length) }, worker))
+        : [];
     const failedWorker = workerResults.find((result) => result.status === "rejected");
-    throwIfRuntimeObservationCancelled(signal);
+    if (locationMode === "verify")
+        throwIfRuntimeObservationCancelled(signal);
     if (failedWorker?.status === "rejected")
         throw failedWorker.reason;
-    for (const { drafts, decision } of authorizedGroups) {
+    for (const group of authorizedGroups) {
+        if (group === undefined)
+            continue;
+        const { drafts, decision } = group;
         for (const draft of drafts) {
             if (!decision.allowed) {
                 exclusions[inspectorExclusionKey(decision.reason)] += 1;
@@ -68,6 +77,14 @@ export const finalizeInspectorCapture = async ({ input, runtime, target, state,
             scripts.set(script.script_key, script);
         }
     }
+    if (locationMode === "reported")
+        for (const draft of state.scripts) {
+            const location = partialScriptLocation(draft.rawUrl);
+            if (location.kind === "unresolved")
+                unresolvedScripts += 1;
+            const script = scriptFromDraft(draft, location);
+            scripts.set(script.script_key, script);
+        }
     const items = [...scripts.values()].sort((left, right) => left.script_key < right.script_key
         ? -1
         : left.script_key > right.script_key
@@ -77,7 +94,7 @@ export const finalizeInspectorCapture = async ({ input, runtime, target, state,
         .map((context) => ({
         context_key: context.contextKey,
         state: context.state,
-        name: null,
+        name: context.name,
         origin: context.origin,
     }))
         .sort((left, right) => left.context_key < right.context_key
@@ -85,7 +102,8 @@ export const finalizeInspectorCapture = async ({ input, runtime, target, state,
         : left.context_key > right.context_key
             ? 1
             : 0);
-    throwIfRuntimeObservationCancelled(signal);
+    if (locationMode === "verify")
+        throwIfRuntimeObservationCancelled(signal);
     return {
         runtime,
         target: {
@@ -132,6 +150,11 @@ export const finalizeInspectorCapture = async ({ input, runtime, target, state,
                     "The discovery-reported file location cannot be verified; loaded script locations are resolved independently from Debugger.scriptParsed.",
                 ]
                 : []),
+            ...(unresolvedScripts === 0
+                ? []
+                : [
+                    `${String(unresolvedScripts)} observed script location${unresolvedScripts === 1 ? " remains" : "s remain"} unverified; raw URLs and script metadata are retained.`,
+                ]),
             "Scripts collected before attachment may have been garbage-collected and therefore omitted.",
             "A bounded observation window cannot establish that an unobserved script or behavior never occurs.",
             "The declared Node/Electron process role is not authenticated by the Inspector protocol.",
@@ -157,3 +180,13 @@ const scriptFromDraft = (draft, location) => {
         status: "observed-loaded",
     };
 };
+const partialScriptLocation = (reportedUrl) => {
+    const projection = projectReportedRuntimeUrl(reportedUrl);
+    if (projection.allowed)
+        return projection.location;
+    return {
+        kind: "unresolved",
+        reported_url: reportedUrl,
+        reason: "location-authorization-not-attempted",
+    };
+};

package/dist/inspector/V8InspectorProvider.js

@@ -4,13 +4,11 @@ import { BrowserObservationError } from "../domain/browserObservationError.js";
 import { ProviderAdapterError } from "../domain/providerAdapterError.js";
 import {} from "../domain/browserObservationErrors.js";
 import { err, ok } from "../domain/result.js";
-import { numberValue, recordValue, cdpStringValue, delayWithCancellation, } from "../browser/CdpCaptureValues.js";
+import { numberValue, recordValue, cdpStringValue, scriptMetadataValues, delayWithCancellation, } from "../browser/CdpCaptureValues.js";
 import { CdpConnection } from "../browser/CdpConnection.js";
 import { authorizeRuntimeTargetLocation, inspectorExclusionKey, } from "./JavaScriptRuntimeScope.js";
 import { createInspectorExclusionCounts, describeInspectorTargetLimitations, finalizeInspectorCapture, } from "./V8InspectorCaptureProjection.js";
 import { discoverV8Inspector, } from "./V8InspectorEndpoint.js";
-/** Public identity committed by passive V8 Inspector observations. */
-export { V8_INSPECTOR_PROVIDER_IDENTITY } from "./providerIdentity.js";
 import { V8_INSPECTOR_PROVIDER_IDENTITY } from "./providerIdentity.js";
 /** Maximum decoded CDP message accepted while observing one Inspector target. */
 export const INSPECTOR_MAX_PAYLOAD_BYTES = 16 * 1024 * 1024;
@@ -56,19 +54,30 @@ export class V8InspectorProvider {
     }
     async observe(input, options = {}) {
         let connection;
+        let discovery;
+        let target;
+        let state;
         let primaryFailure;
         let failed = false;
         let cleanupFailure;
         let cleanupFailed = false;
+        let connectionClosePromise;
         let outcome;
+        const closeConnection = () => {
+            if (connection === undefined)
+                return Promise.resolve();
+            connectionClosePromise ??= closeInspectorConnection(connection, options.signal);
+            return connectionClosePromise;
+        };
         try {
-            const discovery = await discoverV8Inspector(input.inspector_endpoint, "observe_javascript_runtime", options.signal);
-            const target = await authorizedTarget(discovery.targets, input, discovery.runtime.product);
+            discovery = await discoverV8Inspector(input.inspector_endpoint, "observe_javascript_runtime", options.signal);
+            target = await authorizedTarget(discovery.targets, input, discovery.runtime.product);
             if (input.runtime_kind !== undefined)
                 assertRuntimeKind(target, input.runtime_kind);
             connection = await CdpConnection.connect(target.webSocketUrl, "observe_javascript_runtime", options.signal, { maxPayloadBytes: INSPECTOR_MAX_PAYLOAD_BYTES });
-            const state = emptyCaptureState();
-            const removeListener = connection.onEvent((event) => ingestEvent(event, input, state));
+            const captureState = emptyCaptureState();
+            state = captureState;
+            const removeListener = connection.onEvent((event) => ingestEvent(event, captureState));
             try {
                 await connection.send("Runtime.enable", {}, undefined, options.signal);
                 await connection.send("Debugger.enable", {}, undefined, options.signal);
@@ -81,7 +90,7 @@ export class V8InspectorProvider {
                 input,
                 runtime: discovery.runtime,
                 target,
-                state,
+                state: captureState,
                 ...(options.signal === undefined ? {} : { signal: options.signal }),
             });
             outcome = ok(javascriptRuntimeObservationSchema.parse(result));
@@ -89,12 +98,53 @@ export class V8InspectorProvider {
         catch (cause) {
             failed = true;
             primaryFailure = cause;
-            outcome = err(providerError(cause, "observe_javascript_runtime"));
+            let error = providerError(cause, "observe_javascript_runtime");
+            if (state !== undefined &&
+                discovery !== undefined &&
+                target !== undefined &&
+                (cause instanceof BrowserObservationError ||
+                    options.signal?.aborted === true)) {
+                const reason = options.signal?.aborted === true
+                    ? "cancelled"
+                    : cause instanceof BrowserObservationError
+                        ? cause.reason
+                        : "protocol_error";
+                try {
+                    await closeConnection();
+                }
+                catch (cause) {
+                    cleanupFailed = true;
+                    cleanupFailure = cause;
+                }
+                try {
+                    const partialObservation = await finalizeInspectorCapture({
+                        input,
+                        runtime: discovery.runtime,
+                        target,
+                        state,
+                        locationMode: "reported",
+                    });
+                    error = new BrowserObservationError("observe_javascript_runtime", reason, {
+                        cause: error,
+                        ...(error.userMessage === undefined
+                            ? {}
+                            : { detail: error.userMessage }),
+                        partialObservation,
+                    });
+                }
+                catch (projectionFailure) {
+                    error = new BrowserObservationError("observe_javascript_runtime", reason, {
+                        cause: new AggregateError([error, projectionFailure], "Inspector failure and partial-observation projection both failed"),
+                        detail: `${error.message} Partial observations could not be projected.`,
+                    });
+                }
+            }
+            outcome = err(error);
         }
         finally {
             if (connection !== undefined)
                 try {
-                    await closeInspectorConnection(connection, options.signal);
+                    await closeConnection();
                 }
                 catch (cause) {
                     cleanupFailed = true;
@@ -102,7 +152,11 @@ export class V8InspectorProvider {
                 }
         }
         if (cleanupFailed) {
-            return err(inspectorCleanupError(primaryFailure, cleanupFailure, failed));
+            return err(inspectorCleanupError(primaryFailure, cleanupFailure, failed, outcome?.ok === true
+                ? outcome.value
+                : outcome?.ok === false
+                    ? outcome.error.partialObservation
+                    : undefined));
         }
         return (outcome ??
             err(new BrowserObservationError("observe_javascript_runtime", "protocol_error")));
@@ -132,11 +186,21 @@ export const closeInspectorConnection = async (connection, signal) => {
             signal.removeEventListener("abort", onAbort);
     }
 };
-export const inspectorCleanupError = (primaryFailure, cleanupFailure, hasPrimaryFailure) => {
+export const inspectorCleanupError = (primaryFailure, cleanupFailure, hasPrimaryFailure, partialObservation) => {
     const cause = hasPrimaryFailure
         ? new AggregateError([primaryFailure, cleanupFailure], "Inspector observation and cleanup both failed")
         : cleanupFailure;
-    return new BrowserObservationError("observe_javascript_runtime", "cleanup_failed", { cause });
+    const cleanupReason = cleanupFailure instanceof Error
+        ? cleanupFailure.message
+        : String(cleanupFailure);
+    return new BrowserObservationError("observe_javascript_runtime", "cleanup_failed", {
+        cause,
+        cleanup: {
+            reason: cleanupReason,
+            resources: ["browser_transport"],
+        },
+        ...(partialObservation === undefined ? {} : { partialObservation }),
+    });
 };
 const projectTarget = (target) => ({
     target_id: target.id,
@@ -177,7 +241,7 @@ const emptyCaptureState = () => ({
     truncated: false,
     truncationReasons: new Set(),
 });
-const ingestEvent = (event, input, state) => {
+const ingestEvent = (event, state) => {
     if (event.method !== "Debugger.scriptParsed" &&
         event.method !== "Debugger.scriptFailedToParse" &&
         event.method !== "Runtime.executionContextCreated" &&
@@ -186,7 +250,7 @@ const ingestEvent = (event, input, state) => {
         return;
     state.eventsObserved += 1;
     if (event.method === "Debugger.scriptParsed") {
-        ingestScript(event, input, state);
+        ingestScript(event, state);
         return;
     }
     if (event.method === "Debugger.scriptFailedToParse") {
@@ -194,30 +258,31 @@ const ingestEvent = (event, input, state) => {
         retainEvent(state, 0);
         return;
     }
-    ingestContext(event, input, state);
+    ingestContext(event, state);
 };
-const ingestScript = (event, input, state) => {
+const ingestScript = (event, state) => {
     state.scriptsObserved += 1;
     const value = recordValue(event.params);
     const rawUrl = cdpStringValue(value?.url);
-    if (rawUrl === undefined || rawUrl === "") {
+    if (rawUrl === undefined) {
         state.invalidScripts += 1;
         retainEvent(state, 0);
         return;
     }
+    const metadata = scriptMetadataValues(value);
     const draft = {
         rawUrl,
         executionContextKey: contextKey(value?.executionContextId),
-        cdpHash: cdpStringValue(value?.hash) ?? null,
-        length: nonnegativeInteger(value?.length),
-        isModule: value?.isModule === true,
+        cdpHash: metadata.hash,
+        length: metadata.length,
+        isModule: metadata.isModule,
     };
     const bytes = retainedMetadataBytes(draft);
     if (!retainEvent(state, bytes))
         return;
     state.scripts.push(draft);
 };
-const ingestContext = (event, input, state) => {
+const ingestContext = (event, state) => {
     if (event.method === "Runtime.executionContextsCleared") {
         let byteDelta = 0;
         for (const context of state.contexts.values()) {
@@ -243,17 +308,18 @@ const ingestContext = (event, input, state) => {
         retainEvent(state, 0);
         return;
     }
-    const origin = event.method === "Runtime.executionContextCreated"
-        ? (cdpStringValue(runtimeContext?.origin) ?? null)
-        : null;
+    const previous = state.contexts.get(key);
+    const created = event.method === "Runtime.executionContextCreated";
     const draft = {
         contextKey: key,
-        state: event.method === "Runtime.executionContextCreated"
-            ? "created"
-            : "destroyed",
-        origin: origin === "" ? null : origin,
+        state: created ? "created" : "destroyed",
+        name: created
+            ? (cdpStringValue(runtimeContext?.name) ?? null)
+            : (previous?.name ?? null),
+        origin: created
+            ? (cdpStringValue(runtimeContext?.origin) ?? null)
+            : (previous?.origin ?? null),
     };
-    const previous = state.contexts.get(key);
     const bytes = retainedMetadataBytes(draft) -
         (previous === undefined ? 0 : retainedMetadataBytes(previous));
     if (!retainEvent(state, bytes))
@@ -294,14 +360,10 @@ const waitForCapture = async (connection, observationMs, signal) => {
 const retainedMetadataBytes = (value) => {
     const strings = "rawUrl" in value
         ? [value.rawUrl, value.rawUrl, value.executionContextKey, value.cdpHash]
-        : [value.contextKey, value.origin];
+        : [value.contextKey, value.name, value.origin];
     return (RETAINED_OBJECT_OVERHEAD_BYTES +
         strings.reduce((total, text) => total + (text?.length ?? 0) * 2, 0));
 };
-const nonnegativeInteger = (value) => {
-    const parsed = numberValue(value);
-    return parsed === undefined ? 0 : Math.max(0, Math.trunc(parsed));
-};
 const contextKey = (value) => {
     const identifier = numberValue(value);
     return identifier !== undefined && Number.isSafeInteger(identifier)

package/dist/javascript/recovery/WakaruCommand.js

@@ -10,6 +10,7 @@ import { ProviderProcessSupervisor, spawnOwnedProviderProcess, } from "../../pro
 import { checkRecoveryDeadline, inventoryRecoveryFiles, fingerprintRecoveryFile, recoveryFailureMessage, } from "./RecoveryFiles.js";
 import { RECOVERY_LIMITS } from "./WakaruRelease.js";
 const OPERATION = "recover_javascript_sources";
+const WAKARU_REQUIREMENT = "Provide an absolute REA_WAKARU_COMMAND pointing to Wakaru 1.13.0 on Linux x64; no tool is installed by REA";
 /** Resolve and fingerprint explicitly configured tools; acquire nothing at startup. */
 export const resolveWakaruCommand = async (environment) => {
     const configured = environment.REA_WAKARU_COMMAND;
@@ -17,7 +18,7 @@ export const resolveWakaruCommand = async (environment) => {
         process.arch !== "x64" ||
         configured === undefined ||
         !isAbsolute(configured))
-        throw new AnalysisCapabilityUnavailableError("wakaru", OPERATION, "Provide an absolute REA_WAKARU_COMMAND pointing to Wakaru 1.13.0 on Linux x64; no tool is installed by REA");
+        throw new AnalysisCapabilityUnavailableError("wakaru", OPERATION, WAKARU_REQUIREMENT, { userMessage: WAKARU_REQUIREMENT });
     try {
         const command = await realpath(configured);
         await access(command, constants.R_OK | constants.X_OK);
@@ -29,7 +30,11 @@ export const resolveWakaruCommand = async (environment) => {
         return { command, limiter, ...fingerprint };
     }
     catch (cause) {
-        throw new AnalysisCapabilityUnavailableError("wakaru", OPERATION, `Configured Wakaru or util-linux prlimit is unavailable: ${recoveryFailureMessage(cause)}`, { cause });
+        const reason = `Configured Wakaru or util-linux prlimit is unavailable: ${recoveryFailureMessage(cause)}`;
+        throw new AnalysisCapabilityUnavailableError("wakaru", OPERATION, reason, {
+            cause,
+            userMessage: reason,
+        });
     }
 };
 /** Run one bounded command and verify cleanup before consuming its output. */

package/dist/javascript/recovery/WakaruExecution.js

@@ -30,8 +30,11 @@ const executeWakaruRecovery = async (context) => {
         arguments: ["--version"],
     });
     if (version.exit_code !== 0 ||
-        version.stdout.trim() !== `wakaru ${WAKARU_RELEASE.version}`)
-        throw new AnalysisCapabilityUnavailableError("wakaru", OPERATION, `This adapter requires Wakaru ${WAKARU_RELEASE.version}; reported version: ${version.stdout.trim()}; exit: ${String(version.exit_code)}; stderr: ${version.stderr}`);
+        version.stdout.trim() !== `wakaru ${WAKARU_RELEASE.version}`) {
+        // The message names the mismatch; the reason also keeps the tool's stderr.
+        const mismatch = `This adapter requires Wakaru ${WAKARU_RELEASE.version}; reported version: ${version.stdout.trim()}; exit: ${String(version.exit_code)}`;
+        throw new AnalysisCapabilityUnavailableError("wakaru", OPERATION, `${mismatch}; stderr: ${version.stderr}`, { userMessage: `${mismatch}.` });
+    }
     const run = await runWakaruCommand({
         ...commandContext,
         staging,

package/dist/main/shutdown.js

@@ -1,22 +1,53 @@
+import { AnalysisError } from "../domain/analysisErrorBase.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
 import { MCP_SHUTDOWN_FAILED } from "./messages.js";
 export const createShutdown = (input) => {
-    const { handle, session, unregisterReload, dependencies, serverLogger } = input;
-    let shutdownPromise;
+    const { handle, session, dependencies, serverLogger } = input;
+    let shutdownAttempt;
+    const cleanupOwners = [
+        { close: () => handle.close(), closed: false },
+        ...(input.closeAndroid === undefined
+            ? []
+            : [{ close: input.closeAndroid, closed: false }]),
+        {
+            close: async () => {
+                const closed = await session.close({ retainProviderDocuments: true });
+                if (!closed.ok)
+                    throw closed.error;
+            },
+            closed: false,
+        },
+    ];
+    let shutdownUnregistered = false;
     let unregisterShutdown = () => undefined;
     const shutdown = async () => {
-        shutdownPromise ??= (async () => {
-            unregisterReload();
-            unregisterShutdown();
-            const results = await Promise.allSettled([
-                handle.close(),
-                input.closeAndroid?.(),
-                session.close({ retainProviderDocuments: true }),
-            ]);
+        if (shutdownAttempt !== undefined)
+            return shutdownAttempt;
+        const pending = cleanupOwners.filter(({ closed }) => !closed);
+        const attempt = (async () => {
+            const results = await Promise.allSettled(pending.map(async (owner) => {
+                await owner.close();
+                owner.closed = true;
+            }));
+            const failures = [];
             for (const result of results)
                 if (result.status === "rejected")
-                    throw result.reason;
+                    failures.push(result.reason);
+            if (failures.length === 1)
+                throw failures[0];
+            if (failures.length > 1)
+                throw new AggregateError(failures, "Multiple MCP cleanup operations failed");
+            if (!shutdownUnregistered) {
+                unregisterShutdown();
+                shutdownUnregistered = true;
+            }
         })();
-        return shutdownPromise;
+        shutdownAttempt = attempt;
+        void attempt.catch(() => {
+            if (shutdownAttempt === attempt)
+                shutdownAttempt = undefined;
+        });
+        return attempt;
     };
     const requestShutdown = () => {
         shutdown().catch((cause) => {
@@ -24,27 +55,48 @@ export const createShutdown = (input) => {
             dependencies.setExitCode(1);
             serverLogger.error(MCP_SHUTDOWN_FAILED);
             dependencies.writeStderr(`${MCP_SHUTDOWN_FAILED}\n`);
+            if (cause instanceof AnalysisError)
+                dependencies.writeStderr(`${projectAnalysisError(cause).message}\n`);
         });
     };
     unregisterShutdown = dependencies.registerShutdown(requestShutdown);
     return { shutdown, request: requestShutdown };
 };
-const describeShutdownFailure = (cause) => {
-    if (cause instanceof Error) {
-        const code = "code" in cause ? cause.code : undefined;
-        return {
-            name: cause.name,
-            message: cause.message,
-            ...(typeof code === "string" ||
-                (typeof code === "number" && Number.isFinite(code))
-                ? { code }
-                : {}),
-        };
+const describeShutdownFailure = (cause) => describeShutdownFailureNode(cause, new WeakSet());
+const describeShutdownFailureNode = (cause, active) => {
+    if (typeof cause === "object" && cause !== null) {
+        if (active.has(cause))
+            return { type: "cyclic_error" };
+        active.add(cause);
+    }
+    try {
+        if (cause instanceof AnalysisError)
+            return { analysis_error: projectAnalysisError(cause) };
+        if (cause instanceof Error) {
+            const code = "code" in cause ? cause.code : undefined;
+            return {
+                name: cause.name,
+                message: cause.message,
+                ...(typeof code === "string" ||
+                    (typeof code === "number" && Number.isFinite(code))
+                    ? { code }
+                    : {}),
+                ...(cause instanceof AggregateError
+                    ? {
+                        errors: cause.errors.map((error) => describeShutdownFailureNode(error, active)),
+                    }
+                    : {}),
+            };
+        }
+        if (cause === null ||
+            typeof cause === "string" ||
+            typeof cause === "boolean" ||
+            (typeof cause === "number" && Number.isFinite(cause)))
+            return { type: cause === null ? "null" : typeof cause, value: cause };
+        return { type: typeof cause };
+    }
+    finally {
+        if (typeof cause === "object" && cause !== null)
+            active.delete(cause);
     }
-    if (cause === null ||
-        typeof cause === "string" ||
-        typeof cause === "boolean" ||
-        (typeof cause === "number" && Number.isFinite(cause)))
-        return { type: cause === null ? "null" : typeof cause, value: cause };
-    return { type: typeof cause };
 };

package/dist/main/startup.js

@@ -7,8 +7,15 @@ export const openInitialTarget = async (session, config, serverLogger, writeStde
     });
     if (opened.ok)
         return { ok: true };
-    await session.close();
-    serverLogger.error({ errorTag: opened.error._tag }, "Initial target failed to open");
+    const closed = await session.close();
+    serverLogger.error({
+        error: projectAnalysisError(opened.error),
+        ...(closed.ok
+            ? {}
+            : { cleanup_error: projectAnalysisError(closed.error) }),
+    }, "Initial target failed to open");
     writeStderr(`${projectAnalysisError(opened.error).message}\n`);
+    if (!closed.ok)
+        writeStderr(`${projectAnalysisError(closed.error).message}\n`);
     return { ok: false, exitCode: 1 };
 };

package/dist/main/transport.js

@@ -1,5 +1,6 @@
 import { createAndroidAnalysisProvider } from "../composition/android.js";
 import { createServer } from "../server/createServer.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
 import { MCP_CONNECTION_LOST, MCP_CONNECTION_START_FAILED, } from "./messages.js";
 export const startMcpTransport = async (dependencies, session, serverContext) => {
     const { serverLogger } = serverContext;
@@ -26,10 +27,12 @@ export const startMcpTransport = async (dependencies, session, serverContext) =>
     try {
         handle = dependencies.serve(() => {
             // The SDK can discard a discovery probe and construct a replacement server.
-            const android = createAndroidAnalysisProvider(dependencies.env);
+            const android = createAndroidAnalysisProvider(serverContext.environment);
             androidProviders.push(android);
-            return (dependencies.createServer ?? createServer)(session, session, {
+            return (dependencies.createServer ?? createServer)({ kind: "session", session }, {
                 logger: serverContext.logger,
+                environment: serverContext.environment,
+                delivery: serverContext.delivery,
                 ...optionalProviders,
                 androidAnalysis: android,
             });
@@ -41,11 +44,28 @@ export const startMcpTransport = async (dependencies, session, serverContext) =>
         });
     }
     catch (cause) {
-        await Promise.allSettled([session.close(), closeAndroid()]);
+        const [binaryCleanup, androidCleanup] = await Promise.allSettled([
+            session.close(),
+            closeAndroid(),
+        ]);
         serverLogger.error({
             error: cause instanceof Error ? cause.message : String(cause),
         }, MCP_CONNECTION_START_FAILED);
         dependencies.writeStderr(`${MCP_CONNECTION_START_FAILED}\n`);
+        if (binaryCleanup.status === "fulfilled" && !binaryCleanup.value.ok) {
+            const cleanupError = projectAnalysisError(binaryCleanup.value.error);
+            serverLogger.error({ cleanup_error: cleanupError }, "Binary provider cleanup failed after MCP startup");
+            dependencies.writeStderr(`${cleanupError.message}\n`);
+        }
+        for (const cleanup of [binaryCleanup, androidCleanup]) {
+            if (cleanup.status === "rejected") {
+                const reason = cleanup.reason instanceof Error
+                    ? cleanup.reason.message
+                    : String(cleanup.reason);
+                serverLogger.error({ cleanup_error: reason }, "Provider cleanup rejected after MCP startup");
+                dependencies.writeStderr(`Provider cleanup failed: ${reason}\n`);
+            }
+        }
         return { ok: false };
     }
     return { ok: true, handle, closeAndroid };