maka-agent 0.2.1-dev.91.20261018 → 0.2.2-dev.97.20261024

package/dist/run-turn-outcome.js

@@ -0,0 +1,174 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { failureClassFromCompleteStopReason } from '@maka/core/events';
+export class TurnOutcomeClassifier {
+    #outcomeId;
+    #unresolvedSandboxFailures = new Set();
+    #finalOutput;
+    #finalOutputFromLive = false;
+    #terminal;
+    constructor(outcomeId) {
+        this.#outcomeId = outcomeId;
+    }
+    accept(observation) {
+        switch (observation?.kind) {
+            case undefined:
+                return;
+            case 'output':
+                // A subscriber is delivered in Host order, so the stream's last answer
+                // is the Turn's last answer. A transcript read stops wherever the Host
+                // had committed, so it can supply an answer the stream never carried
+                // but can never overrule one it did.
+                if (observation.source === 'stored' && this.#finalOutputFromLive)
+                    return;
+                this.#finalOutput = observation.text;
+                this.#finalOutputFromLive = observation.source === 'live';
+                return;
+            case 'terminal':
+                if (observation.update === 'replace' || this.#terminal === undefined) {
+                    this.#terminal = observation;
+                }
+                return;
+            case 'tool_result': {
+                if (observation.outcome === 'sandbox_failure') {
+                    this.#unresolvedSandboxFailures.add(observation.toolUseId);
+                }
+                return;
+            }
+        }
+    }
+    outcome(incomplete) {
+        const terminal = this.#terminal;
+        if (!terminal && incomplete === 'pending')
+            return undefined;
+        const completed = terminal?.status === 'completed';
+        const sandboxBoundary = this.#unresolvedSandboxFailures.size > 0 ? 'unresolved' : 'none';
+        const failure = terminal?.status === 'failed'
+            ? terminal.failure
+            : {
+                class: 'missing_terminal_event',
+                message: 'Turn ended unexpectedly',
+            };
+        return {
+            outcomeId: this.#outcomeId,
+            status: completed ? 'completed' : 'failed',
+            ...(completed && this.#finalOutput !== undefined ? { finalOutput: this.#finalOutput } : {}),
+            ...(!completed ? { failure } : {}),
+            sandboxBoundary,
+        };
+    }
+}
+export function observationFromSessionEvent(event) {
+    if (event.type === 'text_complete' && event.text.trim().length > 0) {
+        return { kind: 'output', text: event.text, source: 'live' };
+    }
+    if (event.type === 'error') {
+        return {
+            kind: 'terminal',
+            update: 'replace',
+            status: 'failed',
+            failure: { class: event.reason ?? event.code ?? 'runtime_error', message: event.message },
+        };
+    }
+    if (event.type === 'abort') {
+        return {
+            kind: 'terminal',
+            update: 'replace',
+            status: 'failed',
+            failure: { class: 'aborted', message: 'Turn was cancelled' },
+        };
+    }
+    if (event.type === 'complete') {
+        return observationFromCompleteEvent(event);
+    }
+    return event.type === 'tool_result' ? observationFromToolResult(event) : undefined;
+}
+function observationFromStoredMessage(message) {
+    if (message.type === 'assistant' && message.text.trim().length > 0) {
+        return { kind: 'output', text: message.text, source: 'stored' };
+    }
+    if (message.type === 'turn_state' && message.status === 'completed') {
+        return { kind: 'terminal', update: 'replace', status: 'completed' };
+    }
+    if (message.type === 'turn_state' && message.status === 'aborted') {
+        return {
+            kind: 'terminal',
+            update: 'replace',
+            status: 'failed',
+            failure: { class: 'aborted', message: 'Turn was cancelled' },
+        };
+    }
+    if (message.type === 'turn_state' && message.status === 'failed') {
+        return {
+            kind: 'terminal',
+            update: 'replace',
+            status: 'failed',
+            failure: {
+                class: message.errorClass ?? 'runtime_error',
+                message: message.failureMessage ?? message.errorClass ?? 'Turn failed',
+            },
+        };
+    }
+    return message.type === 'tool_result' ? observationFromToolResult(message) : undefined;
+}
+function observationFromCompleteEvent(event) {
+    if (event.stopReason === 'user_stop') {
+        return {
+            kind: 'terminal',
+            update: 'if_unset',
+            status: 'failed',
+            failure: { class: 'aborted', message: 'Turn was cancelled' },
+        };
+    }
+    const failureClass = failureClassFromCompleteStopReason(event.stopReason);
+    return failureClass
+        ? {
+            kind: 'terminal',
+            update: 'if_unset',
+            status: 'failed',
+            failure: { class: failureClass },
+        }
+        : { kind: 'terminal', update: 'if_unset', status: 'completed' };
+}
+function observationFromToolResult(result) {
+    if (result.isError && result.content.kind === 'text' && result.content.sandboxFailure) {
+        return {
+            kind: 'tool_result',
+            toolUseId: result.toolUseId,
+            outcome: 'sandbox_failure',
+        };
+    }
+    return result.isError
+        ? undefined
+        : { kind: 'tool_result', toolUseId: result.toolUseId, outcome: 'success' };
+}
+export function outcomeFromStoredTurn(messages, turnId) {
+    return classifierFromStoredTurn(messages, turnId, turnId).outcome('pending');
+}
+export function classifierFromStoredTurn(messages, turnId, outcomeId) {
+    const classifier = new TurnOutcomeClassifier(outcomeId);
+    acceptStoredTurn(classifier, messages, turnId);
+    return classifier;
+}
+export function acceptStoredTurn(classifier, messages, turnId) {
+    for (const message of messages) {
+        if (message.turnId === turnId)
+            classifier.accept(observationFromStoredMessage(message));
+    }
+}

package/dist/runtime-host-cli.js

@@ -19,7 +19,7 @@
 import { isAbsolute } from 'node:path';
 import { isProductReleaseVersion, isSha512PackageIntegrity, } from '@maka/runtime-host/operator/update-package-evidence';
 import { createRuntimeHostLegacyPosixOperatorCommand, decodeRuntimeHostPosixOperatorCommand, decodeRuntimeHostWebRtcStunPolicy, } from '@maka/runtime-host/operator';
-import { canonicalProjectDirectoryRootSpec, isCanonicalRuntimeHostWebSocketPath, PROJECT_DIRECTORY_MAX_ROOTS, projectDirectoryPosixRootSpecValid, projectDirectoryRootSpecValid, } from '@maka/runtime-host/protocol';
+import { canonicalProjectDirectoryRootSpec, isCanonicalRuntimeHostWebSocketPath, PROJECT_DIRECTORY_MAX_ROOTS, projectDirectoryRootSpecValid, } from '@maka/runtime-host/protocol';
 import { hasEphemeralRuntimeHostPeerPort } from './runtime-host-peer-artifact.js';
 import { installedUpdateHelpText, isRuntimeHostHelpTopic, runtimeHostCommandHelpText, runtimeHostHelpText, } from './runtime-host-help.js';
 export function parseRuntimeHostCommand(argv, cliCommand = 'maka') {
@@ -372,12 +372,26 @@ function parseSetupCommand(argv) {
     let repairRootAfterRemount = false;
     let updateExisting = false;
     let reuseExistingEnvironment = false;
+    let expectedOperator;
     let allowInterruptActiveTasks = false;
     let clientDataRoot;
     let enableDirectPeer = false;
     const coordinationRelays = [];
     const options = parseManagedServiceOptions(argv, {
         valueOptions: {
+            '--expected-operator-json': (value) => {
+                if (expectedOperator)
+                    return error('Duplicate --expected-operator-json');
+                try {
+                    const operator = decodeRuntimeHostPosixOperatorCommand(JSON.parse(value));
+                    if (operator.kind !== 'node')
+                        return error('Expected a POSIX Node operator');
+                    expectedOperator = operator;
+                }
+                catch {
+                    return error('--expected-operator-json must contain a POSIX Node operator');
+                }
+            },
             '--client-data-root': (value) => {
                 if (clientDataRoot !== undefined)
                     return error('Duplicate --client-data-root');
@@ -447,6 +461,10 @@ function parseSetupCommand(argv) {
     });
     if ('kind' in options)
         return options;
+    if ((options.managedRootId !== undefined || expectedOperator !== undefined) &&
+        (!reuseExistingEnvironment || !options.managedRootId || !expectedOperator)) {
+        return error('Node recovery requires --reuse-existing-environment, --managed-root-id, and --expected-operator-json');
+    }
     if (reuseExistingEnvironment &&
         (lifecycle !== 'on_demand' ||
             updateExisting ||
@@ -480,6 +498,9 @@ function parseSetupCommand(argv) {
         ...(repairRootAfterRemount ? { repairRootAfterRemount: true } : {}),
         ...(updateExisting ? { updateExisting: true } : {}),
         ...(reuseExistingEnvironment ? { reuseExistingEnvironment: true } : {}),
+        ...(expectedOperator
+            ? { expectedExisting: { rootId: options.managedRootId, operator: expectedOperator } }
+            : {}),
         ...(allowInterruptActiveTasks ? { allowInterruptActiveTasks: true } : {}),
         ...(clientDataRoot ? { clientDataRoot } : {}),
         ...(enableDirectPeer ? { directPeer: { coordinationRelays } } : {}),
@@ -1187,9 +1208,7 @@ function parseManagedServiceOptions(argv, input = {}) {
                     return error('--project-root cannot be combined with --no-project-roots');
                 }
                 projectDirectoryPolicySpecified = true;
-                const root = argument === '--project-root'
-                    ? parseProjectRoot(parsed, 'posix')
-                    : parseProjectRootJson(parsed, 'posix');
+                const root = argument === '--project-root' ? parseProjectRoot(parsed) : parseProjectRootJson(parsed);
                 if ('kind' in root)
                     return root;
                 if (projectDirectoryRoots.length >= PROJECT_DIRECTORY_MAX_ROOTS) {
@@ -1717,9 +1736,7 @@ function parseServeCommand(argv) {
             const parsed = optionValue(argv, index, argument);
             if (typeof parsed !== 'string')
                 return parsed;
-            const root = argument === '--project-root'
-                ? parseProjectRoot(parsed, 'native')
-                : parseProjectRootJson(parsed, 'native');
+            const root = argument === '--project-root' ? parseProjectRoot(parsed) : parseProjectRootJson(parsed);
             if ('kind' in root)
                 return root;
             if (projectDirectoryRoots.length >= PROJECT_DIRECTORY_MAX_ROOTS) {
@@ -1906,7 +1923,7 @@ function parseServeCommand(argv) {
             }),
     };
 }
-function parseProjectRoot(value, pathKind) {
+function parseProjectRoot(value) {
     const separator = value.indexOf('=');
     if (separator <= 0 || separator === value.length - 1) {
         return error('--project-root must use <label>=<absolute-path>');
@@ -1915,12 +1932,12 @@ function parseProjectRoot(value, pathKind) {
         label: value.slice(0, separator),
         path: value.slice(separator + 1),
     });
-    if (!projectRootValid(root, pathKind)) {
-        return error(`--project-root must use a valid label and absolute ${pathKind === 'posix' ? 'POSIX' : 'Host'} path`);
+    if (!projectRootValid(root)) {
+        return error(`--project-root must use a valid label and absolute Host path`);
     }
     return root;
 }
-function parseProjectRootJson(value, pathKind) {
+function parseProjectRootJson(value) {
     let parsed;
     try {
         parsed = JSON.parse(value);
@@ -1941,15 +1958,13 @@ function parseProjectRootJson(value, pathKind) {
         label: root.label,
         path: root.path,
     });
-    if (!projectRootValid(canonical, pathKind)) {
-        return error(`--project-root-json must use a valid label and absolute ${pathKind === 'posix' ? 'POSIX' : 'Host'} path`);
+    if (!projectRootValid(canonical)) {
+        return error(`--project-root-json must use a valid label and absolute Host path`);
     }
     return canonical;
 }
-function projectRootValid(root, pathKind) {
-    return pathKind === 'posix'
-        ? projectDirectoryPosixRootSpecValid(root)
-        : projectDirectoryRootSpecValid(root) && isAbsolute(root.path);
+function projectRootValid(root) {
+    return projectDirectoryRootSpecValid(root) && isAbsolute(root.path);
 }
 function parseAccessCommand(argv) {
     const action = argv[0];

package/dist/runtime-host-run-command.js

@@ -16,16 +16,19 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-import { failureClassFromCompleteStopReason } from '@maka/core/events';
 import { findProjectByIdentity } from '@maka/core/project';
 import { projectSessionCatalogSummary, readRuntimeHostSessions, readRuntimeHostProjects, RuntimeHostOperationError, isRuntimeHostReconnectingConnection, } from '@maka/runtime-host/client';
 import { runtimeHostProfileUsesHostWorkspace } from '@maka/runtime-host/profile-kind';
 import { runMakaTextCliCore, } from './run-command-core.js';
-import { connectRuntimeHostCli, resolveRuntimeHostCliTarget, } from './runtime-host-cli-context.js';
+import { connectRuntimeHostCli, connectRuntimeHostCliConnection, resolveRuntimeHostCliTarget, } from './runtime-host-cli-context.js';
 import { createRuntimeHostMakaSessionDriver, } from './runtime-host-session-driver.js';
 import { RuntimeHostRunMcp } from './runtime-host-run-mcp.js';
 import { formatRuntimeHostCliTaskBlockers, isRuntimeHostCliTaskBlocked, readRuntimeHostCliTaskReadiness, } from './runtime-host-task-readiness.js';
 import { resolveMakaClientDataRoot } from './workspace-root.js';
+import { TurnOutcomeClassifier, observationFromSessionEvent, outcomeFromStoredTurn, acceptStoredTurn, } from './run-turn-outcome.js';
+import { RunQuestionAvailable } from './run-session-result.js';
+import { isTemporaryNpxInstallation } from './runtime-host-cli-installation.js';
+import { runMakaSessionCommand } from './run-session-command.js';
 const GRAPH_POLL_INTERVAL_MS = 25;
 export async function runRuntimeHostTextCli(argv, overrides = {}, commandOverrides = {}, options = {
     cliCommand: 'maka',
@@ -39,6 +42,19 @@ export async function runRuntimeHostTextCli(argv, overrides = {}, commandOverrid
     };
     try {
         return await commandDeps.run(argv, {
+            runSession: async (sessionOptions, env) => {
+                const context = await connectRuntimeHostCliConnection({
+                    rootPath: env.workspaceRoot(),
+                    ...(sessionOptions.hostProfileId ? { profileId: sessionOptions.hostProfileId } : {}),
+                    clientDataRoot: options.clientDataRoot,
+                });
+                try {
+                    return await runMakaSessionCommand(context.connection, sessionOptions, env, context.profile.kind !== 'local' || !(await isTemporaryNpxInstallation()));
+                }
+                finally {
+                    await context.close();
+                }
+            },
             listSessions: async (rootPath, hostProfileId) => runtimeHostSessionSummaries(await readRuntimeHostSessions((await connect(rootPath, hostProfileId)).connection)),
             createContext: async (input) => {
                 const context = await connect(input.workspaceRoot, input.hostProfileId);
@@ -87,7 +103,7 @@ export function createRuntimeHostRunContext(connection, catalog, input, override
         ...(input.projectId ? { workspace: { kind: 'project', projectId: input.projectId } } : {}),
         ...(mcp ? { prepareSession: (sessionId) => mcp.prepare(sessionId) } : {}),
     });
-    const runtime = new RuntimeHostRunRuntime(connection, driver, mcp, input.runOutcomeObserver, input.enableAgentGraph === true, input.sessionCwdOverride, input.maxSteps);
+    const runtime = new RuntimeHostRunRuntime(connection, driver, mcp, input.runOutcomeObserver, input.enableAgentGraph === true, input.sessionCwdOverride, input.maxSteps, input.noWait === true, input.allowDetach !== false);
     return {
         runtime,
         target: { connection: { slug: target.connection.slug }, model: target.model },
@@ -130,7 +146,10 @@ async function prepareRuntimeHostRunInput(connection, catalog, profile, input, c
     if (isRuntimeHostCliTaskBlocked(snapshot)) {
         throw new Error(`Task is not ready:\n${formatRuntimeHostCliTaskBlockers(snapshot, cliCommand)}`);
     }
-    return preparedInput;
+    return {
+        ...preparedInput,
+        allowDetach: runtimeHostProfileUsesHostWorkspace(profile.kind) || !(await isTemporaryNpxInstallation()),
+    };
 }
 class RuntimeHostRunRuntime {
     #connection;
@@ -140,6 +159,8 @@ class RuntimeHostRunRuntime {
     #graphEnabled;
     #sessionCwdOverride;
     #maxSteps;
+    #noWait;
+    #allowDetach;
     #unsubscribeTranscriptReplacements;
     #sessionId;
     #activeTurn;
@@ -149,7 +170,7 @@ class RuntimeHostRunRuntime {
     #graphAdmissionTurnIds = new Set();
     #latestTranscriptReplacement;
     #graphTerminalWaiters = new Map();
-    constructor(connection, driver, mcp, observer, graphEnabled, sessionCwdOverride, maxSteps) {
+    constructor(connection, driver, mcp, observer, graphEnabled, sessionCwdOverride, maxSteps, noWait = false, allowDetach = true) {
         this.#connection = connection;
         this.#driver = driver;
         this.#mcp = mcp;
@@ -157,7 +178,9 @@ class RuntimeHostRunRuntime {
         this.#graphEnabled = graphEnabled;
         this.#sessionCwdOverride = sessionCwdOverride;
         this.#maxSteps = maxSteps;
-        this.#interactions = new NonInteractiveInteractionController(driver, (pending) => this.#stopForInteraction(pending));
+        this.#noWait = noWait;
+        this.#allowDetach = allowDetach;
+        this.#interactions = new NonInteractiveInteractionController(driver, (pending) => this.#stopForInteraction(pending), () => this.#allowDetach && !this.#graphEnabled && !this.#mcp?.ownsServers, () => this.#noWait);
         this.#unsubscribeTranscriptReplacements = driver.subscribeTranscriptReplacements((sessionId, turnId, messages) => {
             this.#acceptRootTranscript(sessionId, turnId, messages);
             this.#acceptGraphTranscript(messages);
@@ -177,6 +200,10 @@ class RuntimeHostRunRuntime {
         await this.#mcp?.ready();
         if (this.#stopRequested)
             throw new Error('Turn was cancelled before start');
+        if (this.#noWait && !this.#allowDetach)
+            throw new Error('--no-wait requires a persistent installation; temporary npx invocations may own the Host lifetime');
+        if (this.#noWait && this.#mcp?.ownsServers)
+            throw new Error('--no-wait cannot detach client-owned MCP servers; use the blocking run path');
         if (input.turnOrchestration?.mode === 'graph') {
             this.#graphAdmissionTurnIds = graphSupervisorTurnIds(await this.#driver.readMessages());
         }
@@ -331,6 +358,14 @@ class RuntimeHostRunRuntime {
         this.#sessionId = sessionId;
     }
     async *#observeTurn(turn, active) {
+        if (this.#noWait) {
+            await this.#observer?.({
+                outcomeId: active.runId,
+                status: 'running',
+                sandboxBoundary: 'none',
+            });
+            return;
+        }
         const events = turn.events[Symbol.asyncIterator]();
         for (;;) {
             const next = await this.#interactions.race(events.next());
@@ -441,150 +476,6 @@ class RuntimeHostRunRuntime {
 function runtimeHostSessionSummaries(items) {
     return items.flatMap((item) => ('kind' in item ? [] : [projectSessionCatalogSummary(item)]));
 }
-class TurnOutcomeClassifier {
-    #outcomeId;
-    #unresolvedSandboxFailures = new Set();
-    #finalOutput;
-    #finalOutputFromLive = false;
-    #terminal;
-    constructor(outcomeId) {
-        this.#outcomeId = outcomeId;
-    }
-    accept(observation) {
-        switch (observation?.kind) {
-            case undefined:
-                return;
-            case 'output':
-                // A subscriber is delivered in Host order, so the stream's last answer
-                // is the Turn's last answer. A transcript read stops wherever the Host
-                // had committed, so it can supply an answer the stream never carried
-                // but can never overrule one it did.
-                if (observation.source === 'stored' && this.#finalOutputFromLive)
-                    return;
-                this.#finalOutput = observation.text;
-                this.#finalOutputFromLive = observation.source === 'live';
-                return;
-            case 'terminal':
-                if (observation.update === 'replace' || this.#terminal === undefined) {
-                    this.#terminal = observation;
-                }
-                return;
-            case 'tool_result': {
-                if (observation.outcome === 'sandbox_failure') {
-                    this.#unresolvedSandboxFailures.add(observation.toolUseId);
-                }
-                // No clearing path: `maka run` denies every widening request, so the
-                // boundary cannot move mid-Turn and a later success cannot prove that
-                // a blocked call recovered. The failure stays unresolved to the end.
-                return;
-            }
-        }
-    }
-    outcome(incomplete) {
-        const terminal = this.#terminal;
-        if (!terminal && incomplete === 'pending')
-            return undefined;
-        const completed = terminal?.status === 'completed';
-        const sandboxBoundary = this.#unresolvedSandboxFailures.size > 0 ? 'unresolved' : 'none';
-        const failure = terminal?.status === 'failed'
-            ? terminal.failure
-            : {
-                class: 'missing_terminal_event',
-                message: 'Turn ended unexpectedly',
-            };
-        return {
-            outcomeId: this.#outcomeId,
-            status: completed ? 'completed' : 'failed',
-            ...(completed && this.#finalOutput !== undefined ? { finalOutput: this.#finalOutput } : {}),
-            ...(!completed ? { failure } : {}),
-            sandboxBoundary,
-        };
-    }
-}
-function observationFromSessionEvent(event) {
-    if (event.type === 'text_complete' && event.text.trim().length > 0) {
-        return { kind: 'output', text: event.text, source: 'live' };
-    }
-    if (event.type === 'error') {
-        return {
-            kind: 'terminal',
-            update: 'replace',
-            status: 'failed',
-            failure: { class: event.reason ?? event.code ?? 'runtime_error', message: event.message },
-        };
-    }
-    if (event.type === 'abort') {
-        return {
-            kind: 'terminal',
-            update: 'replace',
-            status: 'failed',
-            failure: { class: 'aborted', message: 'Turn was cancelled' },
-        };
-    }
-    if (event.type === 'complete') {
-        return observationFromCompleteEvent(event);
-    }
-    return event.type === 'tool_result' ? observationFromToolResult(event) : undefined;
-}
-function observationFromStoredMessage(message) {
-    if (message.type === 'assistant' && message.text.trim().length > 0) {
-        return { kind: 'output', text: message.text, source: 'stored' };
-    }
-    if (message.type === 'turn_state' && message.status === 'completed') {
-        return { kind: 'terminal', update: 'replace', status: 'completed' };
-    }
-    if (message.type === 'turn_state' && message.status === 'aborted') {
-        return {
-            kind: 'terminal',
-            update: 'replace',
-            status: 'failed',
-            failure: { class: 'aborted', message: 'Turn was cancelled' },
-        };
-    }
-    if (message.type === 'turn_state' && message.status === 'failed') {
-        return {
-            kind: 'terminal',
-            update: 'replace',
-            status: 'failed',
-            failure: {
-                class: message.errorClass ?? 'runtime_error',
-                message: 'Agent Graph final Turn failed',
-            },
-        };
-    }
-    return message.type === 'tool_result' ? observationFromToolResult(message) : undefined;
-}
-function observationFromCompleteEvent(event) {
-    if (event.stopReason === 'user_stop') {
-        return {
-            kind: 'terminal',
-            update: 'if_unset',
-            status: 'failed',
-            failure: { class: 'aborted', message: 'Turn was cancelled' },
-        };
-    }
-    const failureClass = failureClassFromCompleteStopReason(event.stopReason);
-    return failureClass
-        ? {
-            kind: 'terminal',
-            update: 'if_unset',
-            status: 'failed',
-            failure: { class: failureClass },
-        }
-        : { kind: 'terminal', update: 'if_unset', status: 'completed' };
-}
-function observationFromToolResult(result) {
-    if (result.isError && result.content.kind === 'text' && result.content.sandboxFailure) {
-        return {
-            kind: 'tool_result',
-            toolUseId: result.toolUseId,
-            outcome: 'sandbox_failure',
-        };
-    }
-    return result.isError
-        ? undefined
-        : { kind: 'tool_result', toolUseId: result.toolUseId, outcome: 'success' };
-}
 function graphSupervisorTurnIds(messages) {
     return new Set(messages.flatMap((message) => message.type === 'user' && message.origin?.kind === 'agent_graph' ? [message.turnId] : []));
 }
@@ -595,31 +486,21 @@ function lastNewGraphSupervisorTurnId(messages, admissionTurnIds) {
         message.origin?.kind === 'agent_graph' &&
         !admissionTurnIds.has(message.turnId))?.turnId;
 }
-function outcomeFromStoredTurn(messages, turnId) {
-    return classifierFromStoredTurn(messages, turnId, turnId).outcome('pending');
-}
-function classifierFromStoredTurn(messages, turnId, outcomeId) {
-    const classifier = new TurnOutcomeClassifier(outcomeId);
-    acceptStoredTurn(classifier, messages, turnId);
-    return classifier;
-}
-function acceptStoredTurn(classifier, messages, turnId) {
-    for (const message of messages) {
-        if (message.turnId === turnId)
-            classifier.accept(observationFromStoredMessage(message));
-    }
-}
 class NonInteractiveInteractionController {
     #driver;
     #stop;
+    #canReturnQuestion;
+    #detached;
     #handled = new Set();
     #tasks = new Set();
     #unsubscribe;
     #failure;
     #failureWaiters = new Set();
-    constructor(driver, stop) {
+    constructor(driver, stop, canReturnQuestion, detached) {
         this.#driver = driver;
         this.#stop = stop;
+        this.#canReturnQuestion = canReturnQuestion;
+        this.#detached = detached;
         this.#unsubscribe = driver.subscribePendingInteractions((pending) => this.#accept(pending));
     }
     race(operation) {
@@ -648,6 +529,10 @@ class NonInteractiveInteractionController {
         this.#unsubscribe();
     }
     #accept(pending) {
+        // Admission can publish interactions before its response arrives. A detached
+        // launcher never decides or stops them; later Session commands own handoff.
+        if (this.#detached())
+            return;
         if (this.#handled.has(pending.interactionId))
             return;
         this.#handled.add(pending.interactionId);
@@ -665,6 +550,9 @@ class NonInteractiveInteractionController {
             });
             return;
         }
+        if (pending.request.kind === 'question' && this.#canReturnQuestion()) {
+            throw new RunQuestionAvailable(pending);
+        }
         await this.#stop(pending);
         throw new Error(pending.request.kind === 'question'
             ? 'interactive user questions are unavailable in non-interactive mode'

package/dist/runtime-host-run-mcp.js

@@ -139,6 +139,9 @@ export class RuntimeHostRunMcp {
             throw new Error(`Session MCP server(s) unavailable: ${unavailable.join(', ')}`);
         }
     }
+    get ownsServers() {
+        return this.#enabledServerIds.length > 0;
+    }
     close() {
         this.#closeTask ??= this.#close(true);
         return this.#closeTask;

package/dist/runtime-host-session-channel.js

@@ -1005,5 +1005,7 @@ function runChannelOperation(operation, signal, discard) {
 function sameGoalProjection(a, b) {
     if (a === null || b === null)
         return a === b;
-    return a.goalId === b.goalId && a.revision === b.revision;
+    return (a.goalId === b.goalId &&
+        a.revision === b.revision &&
+        JSON.stringify(a.eventWait) === JSON.stringify(b.eventWait));
 }

package/dist/runtime-host-session-driver.js

@@ -996,6 +996,11 @@ class RuntimeHostMakaSessionDriverImpl {
         this.#todoChangeListeners.add(listener);
         return () => this.#todoChangeListeners.delete(listener);
     }
+    async cancelGoalEventWait(input) {
+        if (input.sessionId !== this.#sessionId)
+            throw new Error('Wait belongs to another Session');
+        return this.#request('goal.event-wait.cancel', input);
+    }
     async controlGoal(action) {
         const sessionId = this.#sessionId;
         if (!sessionId)