maka-agent 0.2.2-dev.92.20261019 → 0.2.2-dev.97.20261024

package/dist/run-command-core.js

@@ -23,7 +23,7 @@ import { resolve } from 'node:path';
 import { isThinkingLevel } from '@maka/core/model-thinking';
 import { normalizeUserSessionName } from '@maka/core/session-name';
 import { selectMakaRunSession } from './run-session-selection.js';
-import { sessionEventSandboxBoundaryFailureReason } from './sandbox-boundary-failure.js';
+import { RuntimeHostOperationError } from '@maka/runtime-host/client';
 import { resolveMakaWorkspaceRoot } from './workspace-root.js';
 const VALUE_FLAGS = new Set([
     'session',
@@ -38,7 +38,6 @@ const VALUE_FLAGS = new Set([
     'host',
     'project',
 ]);
-const REPEATABLE_VALUE_FLAGS = new Set();
 const BOOLEAN_FLAGS = new Set([
     'continue',
     'yolo',
@@ -48,6 +47,7 @@ const BOOLEAN_FLAGS = new Set([
     'json',
     'status',
     'result',
+    'recap',
     'queue',
     'steer',
     'stop',
@@ -72,20 +72,17 @@ export function parseMakaRunArgs(argv) {
         if (!literal && arg.startsWith('--')) {
             const name = arg.slice(2);
             if (BOOLEAN_FLAGS.has(name) || (name === 'resume' && selectsSession)) {
-                if (booleanFlags.has(name))
-                    return { kind: 'error', message: `option repeated: ${arg}` };
                 booleanFlags.add(name);
                 continue;
             }
             if (!VALUE_FLAGS.has(name))
                 return { kind: 'error', message: `unknown option: ${arg}` };
-            if (!REPEATABLE_VALUE_FLAGS.has(name) && flags.has(name)) {
-                return { kind: 'error', message: `option repeated: ${arg}` };
-            }
             const value = argv[index + 1];
             if (value === undefined || value.startsWith('--')) {
                 return { kind: 'error', message: `option ${arg} needs a value` };
             }
+            if (flags.has(name) && flags.get(name) !== value)
+                return { kind: 'error', message: `conflicting values for ${arg}` };
             flags.set(name, value);
             index += 1;
             continue;
@@ -108,8 +105,9 @@ export function parseMakaRunArgs(argv) {
     if (booleanFlags.has('queue') && booleanFlags.has('steer')) {
         return { kind: 'error', message: '--queue and --steer cannot be used together' };
     }
-    const actions = Number(booleanFlags.has('status')) +
+    const actions = Number(booleanFlags.has('status') && !booleanFlags.has('recap')) +
         Number(booleanFlags.has('result')) +
+        Number(booleanFlags.has('recap')) +
         Number(flags.has('answer')) +
         Number(resumeExecution) +
         Number(booleanFlags.has('stop')) +
@@ -118,7 +116,7 @@ export function parseMakaRunArgs(argv) {
     if (actions > 1)
         return {
             kind: 'error',
-            message: 'choose one of --status, --result, --answer, --approve, --deny, --resume or --stop',
+            message: 'choose one Session action, or combine --status with --recap',
         };
     if ((booleanFlags.has('approve') || booleanFlags.has('deny')) && booleanFlags.has('yolo'))
         return {
@@ -134,14 +132,34 @@ export function parseMakaRunArgs(argv) {
             message: '--session cannot be combined with --continue or --project',
         };
     }
+    if (sessionId) {
+        const override = ['cwd', 'timeout', 'graph'].find((name) => flags.has(name) || booleanFlags.has(name));
+        if (override)
+            return {
+                kind: 'error',
+                message: `--${override} cannot be used with --session; use saved settings or legacy --resume <id> for run configuration`,
+            };
+        if (flags.has('max-steps') &&
+            (!positional.length || actions || booleanFlags.has('queue') || booleanFlags.has('steer')))
+            return {
+                kind: 'error',
+                message: '--max-steps requires a Session prompt without --queue/--steer',
+            };
+    }
     if (actions && positional.length)
         return { kind: 'error', message: 'session actions do not accept a prompt' };
     if ((booleanFlags.has('queue') || booleanFlags.has('steer')) && (!positional.length || actions)) {
         return { kind: 'error', message: '--queue and --steer require a prompt' };
     }
-    if ((booleanFlags.has('status') || booleanFlags.has('result') || booleanFlags.has('stop')) &&
+    if ((booleanFlags.has('status') ||
+        booleanFlags.has('result') ||
+        booleanFlags.has('recap') ||
+        booleanFlags.has('stop')) &&
         (booleanFlags.has('wait') || booleanFlags.has('no-wait'))) {
-        return { kind: 'error', message: '--status, --result and --stop do not accept wait options' };
+        return {
+            kind: 'error',
+            message: '--status, --result, --recap and --stop do not accept wait options',
+        };
     }
     if (booleanFlags.has('graph') && booleanFlags.has('no-wait')) {
         return { kind: 'error', message: '--graph must wait for its final result' };
@@ -202,6 +220,7 @@ export function parseMakaRunArgs(argv) {
             ...(booleanFlags.has('json') ? { json: true } : {}),
             ...(booleanFlags.has('status') ? { status: true } : {}),
             ...(booleanFlags.has('result') ? { result: true } : {}),
+            ...(booleanFlags.has('recap') ? { recap: true } : {}),
             ...(resumeExecution ? { resumeExecution: true } : {}),
             ...(booleanFlags.has('stop') ? { stop: true } : {}),
             ...(booleanFlags.has('approve')
@@ -240,7 +259,10 @@ export async function runMakaTextCliCore(argv, adapter, overrides = {}) {
         return 0;
     }
     if (parsed.kind === 'error') {
-        deps.writeStderr(`maka run: ${parsed.message}\n\n${makaRunHelpText(deps.cliCommand())}\n`);
+        const optionArgs = argv.includes('--') ? argv.slice(0, argv.indexOf('--')) : argv;
+        writeRunError(parsed.message, deps, optionArgs.includes('--json'));
+        if (!optionArgs.includes('--json'))
+            deps.writeStderr(`Run \`${deps.cliCommand()} run --help\` for usage.\n`);
         return 2;
     }
     if (parsed.options.sessionId) {
@@ -252,7 +274,7 @@ export async function runMakaTextCliCore(argv, adapter, overrides = {}) {
             if (options.prompt !== undefined || options.stdinPrompt)
                 options.prompt = await resolveRunPrompt(options, deps);
             const result = await deps.runSession(options, deps);
-            writeSessionResult(result, deps, options.json === true);
+            writeSessionResult(result, deps, options.json === true || options.status === true);
             const returnsTaskOutcome = options.prompt !== undefined ||
                 options.answers !== undefined ||
                 options.resumeExecution ||
@@ -262,7 +284,7 @@ export async function runMakaTextCliCore(argv, adapter, overrides = {}) {
             return result.status === 'failed' && returnsTaskOutcome ? 1 : 0;
         }
         catch (error) {
-            deps.writeStderr(`maka run: ${errorMessage(error)}\n`);
+            writeRunError(error, deps, parsed.options.json === true, parsed.options.sessionId);
             return error instanceof RunSessionInterrupted ? 130 : 1;
         }
     }
@@ -294,11 +316,11 @@ export async function runMakaTextCliCore(argv, adapter, overrides = {}) {
         });
     }
     catch (error) {
-        deps.writeStderr(`maka run: ${errorMessage(error)}\n`);
+        writeRunError(error, deps, parsed.options.json === true, parsed.options.sessionId);
         return 2;
     }
     let outcome;
-    let boundaryFailure = false;
+    let unavailableSandboxRequest = false;
     let context;
     try {
         context = await deps.createContext({
@@ -327,14 +349,12 @@ export async function runMakaTextCliCore(argv, adapter, overrides = {}) {
             ...(parsed.options.hostProfileId ? { hostProfileId: parsed.options.hostProfileId } : {}),
             ...(parsed.options.projectId ? { projectId: parsed.options.projectId } : {}),
             runOutcomeObserver: (result) => {
-                if (result.sandboxBoundary === 'unresolved')
-                    boundaryFailure = true;
                 outcome = result;
             },
         });
     }
     catch (error) {
-        deps.writeStderr(`maka run: ${errorMessage(error)}\n`);
+        writeRunError(error, deps, parsed.options.json === true, parsed.options.sessionId);
         return 2;
     }
     let session;
@@ -370,7 +390,7 @@ export async function runMakaTextCliCore(argv, adapter, overrides = {}) {
     }
     catch (error) {
         await context.close();
-        deps.writeStderr(`maka run: ${errorMessage(error)}\n`);
+        writeRunError(error, deps, parsed.options.json === true, parsed.options.sessionId);
         return 2;
     }
     let interrupted = false;
@@ -416,20 +436,12 @@ export async function runMakaTextCliCore(argv, adapter, overrides = {}) {
                 : {}),
         })) {
             if (event.type === 'sandbox_boundary_request') {
-                boundaryFailure = true;
-                deps.writeStderr('maka run: sandbox boundary expansion is unavailable in non-interactive mode\n');
+                unavailableSandboxRequest = true;
                 await context.runtime.respondToSandboxBoundary(session.id, {
                     requestId: event.requestId,
                     decision: 'deny',
                 });
             }
-            const sandboxFailureReason = sessionEventSandboxBoundaryFailureReason(event);
-            if (sandboxFailureReason) {
-                boundaryFailure = true;
-                deps.writeStderr(sandboxFailureReason === 'requires_bypass'
-                    ? 'maka run: sandbox bypass requires an explicit --yolo\n'
-                    : 'maka run: sandbox boundary expansion is unavailable in non-interactive mode\n');
-            }
         }
         graphActivity?.release();
         if (parsed.options.graph && outcome?.status === 'completed') {
@@ -443,7 +455,7 @@ export async function runMakaTextCliCore(argv, adapter, overrides = {}) {
         graphActivity?.release();
         await stopPromise?.catch(() => undefined);
         if (!interrupted && !timedOut && !question) {
-            deps.writeStderr(`maka run: ${errorMessage(error)}\n`);
+            writeRunError(error, deps, parsed.options.json === true, session.id);
         }
     }
     finally {
@@ -455,7 +467,7 @@ export async function runMakaTextCliCore(argv, adapter, overrides = {}) {
     if (interrupted)
         return 130;
     if (timedOut) {
-        deps.writeStderr(`maka run: timed out after ${parsed.options.timeoutMs}ms\n`);
+        writeRunError(`timed out after ${parsed.options.timeoutMs}ms`, deps, parsed.options.json === true, session.id);
         return 1;
     }
     if (question) {
@@ -464,10 +476,12 @@ export async function runMakaTextCliCore(argv, adapter, overrides = {}) {
     }
     if (streamFailed)
         return 1;
-    if (boundaryFailure)
+    if (unavailableSandboxRequest) {
+        writeRunError('sandbox boundary expansion is unavailable in non-interactive mode', deps, parsed.options.json === true, session.id);
         return 1;
+    }
     if (!outcome) {
-        deps.writeStderr('maka run: runtime produced no outcome\n');
+        writeRunError('runtime produced no outcome', deps, parsed.options.json === true, session.id);
         return 1;
     }
     if (outcome.status === 'running') {
@@ -487,12 +501,24 @@ export async function runMakaTextCliCore(argv, adapter, overrides = {}) {
     return 0;
 }
 export function writeSessionResult(result, deps, json) {
-    if (json || result.status !== 'completed' || result.finalOutput === undefined)
-        deps.writeStdout(`${JSON.stringify(result)}\n`);
-    else
-        deps.writeStdout(withTrailingNewline(result.finalOutput));
-    if (result.status === 'failed' && result.error)
+    if (result.error && result.recap === undefined && !json) {
         deps.writeStderr(`maka run: ${result.error}\n`);
+        return;
+    }
+    const text = result.recap ?? (result.status === 'completed' ? result.finalOutput : undefined);
+    deps.writeStdout(json || text === undefined ? `${JSON.stringify(result)}\n` : withTrailingNewline(text));
+}
+function writeRunError(error, deps, json, sessionId) {
+    const message = errorMessage(error);
+    if (json) {
+        deps.writeStdout(`${JSON.stringify({
+            ...(sessionId ? { sessionId } : {}),
+            error: message,
+            ...(error instanceof RuntimeHostOperationError ? { code: error.code } : {}),
+        })}\n`);
+    }
+    else
+        deps.writeStderr(`maka run: ${message}\n`);
 }
 async function resolveRunPrompt(options, deps) {
     const shouldReadStdin = options.stdinPrompt || !deps.stdinIsTTY();
@@ -515,44 +541,59 @@ async function canonicalDirectory(input) {
 function makaRunHelpText(cliCommand) {
     return [
         `Usage: ${cliCommand} run [PROMPT] [options]`,
-        `       ${cliCommand} -p [PROMPT] [options]`,
+        `       ${cliCommand} run --session <id> [PROMPT | ACTION] [options]`,
         '',
-        'Input:',
-        '  -                         Read the complete prompt from stdin',
-        '  PROMPT with piped stdin   Use PROMPT as instruction and stdin as context',
+        'Ordinary runs wait and print the final answer. For parent-agent coordination:',
+        `  ${cliCommand} run "Inspect this project" --no-wait`,
+        `  ${cliCommand} run --session <id> --wait --json`,
         '',
-        'Options:',
-        '  --cwd <path>              Working directory (default: current directory)',
-        '  --connection <slug>       Model connection to use',
-        '  --host <profile-id>       Connect through a saved Runtime Host profile',
-        '  --project <project-id>    Select an existing Project on a remote Host',
-        '  --model <id>              Model to use',
-        '  --thinking <level>        off|on|minimal|low|medium|high|xhigh|max|default',
-        '  --timeout <seconds>       Invocation timeout',
-        '  --max-steps <count>       Tool-step cap',
-        '  --yolo                    Grant full access; Session controls otherwise inherit saved access',
-        '  --session <session-id>    Select a Session (without a prompt: show its status)',
-        '  --wait                    Wait for this message/current Turn; return input/approval early',
-        '  --no-wait                 Submit and return (Host-owned execution only)',
-        '  --status                  Read current Session status without executing',
+        'Execution and output:',
+        '  --no-wait                 Submit and return a JSON receipt (persistent Host required)',
+        '  --wait                    Wait for this message/current Turn (default for prompts)',
+        '  --json                    Return JSON, including final answers and recaps',
+        '  --host <profile-id>       Use the same saved Host profile for every Session call',
+        '',
+        'Session actions (--session <id>; model settings below persist before the action):',
+        '  [no action]               Show status, or save supplied model settings without running',
+        '  --status                  Read status, pending questions/approvals, and execution boundary',
+        '  --recap                   Summarize recorded progress with a separate model call',
         '  --result                  Read the latest Turn result without waiting',
-        '  --stop                    Request stop for the current Turn (no --yolo needed)',
         '  --answer <json-array>     Answer the current AskUser, e.g. ["Yes",null]',
-        '  --approve                 Approve the single pending sandbox expansion',
-        '  --deny                    Deny the single pending sandbox expansion',
-        '  --queue                   Queue this prompt as its own next Turn (default)',
-        '  --steer                   Add this prompt to the current execution',
-        '  --json                    Return a structured result, including the Session ID',
-        '  --session <id> --resume   Safely resume stopped execution',
-        '  --resume <session-id>     Legacy Session selector (prefer --session)',
-        '  --continue                Continue the latest compatible task for cwd',
-        '  --graph                   Run this turn in Graph Mode and wait for graph completion',
+        '  --approve / --deny        Decide the single pending sandbox expansion',
+        '  PROMPT                    Queue a new Turn; --steer targets ongoing execution',
+        '  --resume                  Safely continue stopped execution',
+        '  --stop                    Request stop for the current Turn',
+        '',
+        'Model settings (creation or persistent Session updates):',
+        '  --connection <slug>       Select a model connection; otherwise keep the saved account',
+        '  --model <id>              Select a model; otherwise keep the saved model',
+        '  --thinking <level>        off|on|minimal|low|medium|high|xhigh|max|default',
+        '',
+        'Run settings (creation or legacy --resume <id>):',
+        '  --cwd <path>              Working directory (default: current directory)',
+        '  --timeout <seconds>       Invocation timeout',
+        '  --max-steps <count>       Tool-step cap; also supported for an idle Session prompt',
+        '  --project <project-id>    Select an existing Project on a remote Host',
+        '  --graph                   Run in Graph Mode and wait for graph completion',
+        '  --yolo                    Explicitly grant full access, including on Session execution',
+        '',
+        'Input and compatibility:',
+        '  -                         Read the prompt from stdin; piped stdin otherwise adds context',
+        '  --queue                   Explicit spelling of the default Session prompt placement',
+        '  --steer                   Deliver this prompt to ongoing execution',
+        '  --resume <session-id>     Legacy blocking selector; permits run-setting overrides',
+        '  --continue                Legacy selector for the latest compatible task in cwd',
+        `  ${cliCommand} -p [PROMPT]  Alias for run`,
         '  -h, --help                Show help',
         '',
-        'Session controls inherit saved permissions; --yolo explicitly grants full access.',
-        '--status reports the execution boundary; a read-only prompt does not restrict permissions.',
-        'Legacy --resume <id> still requires --yolo for a full-access Session.',
-        '--approve/--deny decide a sandbox request without changing the Session to full access.',
+        'Receipts, status, and pending interactions are JSON without an extra --json.',
+        'Check status, not just exit 0: needs_input/needs_approval require a caller decision.',
+        'finalOutput is a task result; recap is progress; submission is admission; configuration is saved settings.',
+        'Combine --status --recap for a JSON snapshot with both state and progress.',
+        '--status/--result/--recap/--stop do not accept wait flags. Recap consumes model usage.',
+        'Errors are brief text on stderr by default; --json returns structured errors on stdout.',
+        'Session controls inherit bypass access too; a read-only prompt does not restrict it.',
+        'Legacy --resume <id> requires --yolo for bypass. --approve/--deny do not switch to bypass.',
     ].join('\n');
 }
 function defaultMakaRunEnvironmentDeps() {

package/dist/run-session-command.js

@@ -17,26 +17,30 @@
  * under the License.
  */
 import { isInteractionAnswerValidForRequest } from '@maka/core/interaction';
+import { abortable, readRuntimeHostConnectionCatalog, } from '@maka/runtime-host/client';
 import { updateRuntimeHostSession } from './runtime-host-session-update.js';
 import { RuntimeHostSessionChannel } from './runtime-host-session-channel.js';
 import { RunSessionInterrupted } from './run-session-result.js';
 import { TurnOutcomeClassifier, acceptStoredTurn } from './run-turn-outcome.js';
+/** Session controls that must verify ownership before mutating a Host-owned Turn. */
+export function sessionControlRequiresExecutionBoundary(options) {
+    return (options.prompt !== undefined ||
+        options.answers !== undefined ||
+        options.resumeExecution === true ||
+        options.sandboxDecision !== undefined ||
+        options.stop === true);
+}
 /** Session commands observe Host-owned execution; they never publish client MCP. */
 export async function runMakaSessionCommand(connection, options, env, allowDetach = true) {
     const sessionId = options.sessionId;
     const executing = options.prompt !== undefined || options.answers !== undefined || options.resumeExecution;
     const decidingSandbox = options.sandboxDecision !== undefined;
+    const controllingTurn = sessionControlRequiresExecutionBoundary(options);
     if ((executing || decidingSandbox) && !allowDetach)
         throw new Error('Session control execution requires a persistent installation; use the blocking legacy run path for temporary npx invocations');
     // Never silently discard options that the old turn.start path supports.
-    if (options.graph ||
-        options.connection ||
-        options.model ||
-        options.thinking !== undefined ||
-        options.cwd ||
-        options.projectId ||
-        options.timeoutMs) {
-        throw new Error('Session commands use the saved configuration; use the blocking legacy --resume <id> path for configuration, cwd, timeout or Graph options');
+    if (options.graph || options.cwd || options.projectId || options.timeoutMs) {
+        throw new Error('Session workspace, timeout and Graph overrides require the blocking legacy --resume <id> path');
     }
     if (options.maxSteps !== undefined &&
         (options.prompt === undefined || options.placement !== undefined)) {
@@ -54,13 +58,45 @@ export async function runMakaSessionCommand(connection, options, env, allowDetac
     };
     try {
         assertActive();
+        const configured = options.model !== undefined ||
+            options.connection !== undefined ||
+            options.thinking !== undefined
+            ? await configureSessionModel(connection, options, assertActive)
+            : undefined;
+        const configuration = configured
+            ? {
+                connection: configured.llmConnectionSlug,
+                model: configured.model,
+                thinking: configured.thinkingLevel ?? null,
+            }
+            : undefined;
         let target = observer.snapshot.rootTurn?.turnId;
+        if (options.recap) {
+            const result = await abortable(() => connection.request('session.recap.generate', {
+                sessionId,
+                effectId: env.newId(),
+                reason: 'manual',
+            }), cancelled.signal);
+            assertActive();
+            if (result.kind === 'failed')
+                throw new Error(`Session recap failed: ${result.errorClass}`);
+            const executionBoundary = options.status
+                ? await connection.request('session.execution_boundary.query', { sessionId })
+                : undefined;
+            assertActive();
+            return {
+                ...observer.status(),
+                recap: result.text,
+                ...(configuration ? { configuration } : {}),
+                ...(executionBoundary ? { executionBoundary } : {}),
+            };
+        }
         let messageId;
         let submission;
         let admittedQueueRevision;
         let admittedQueueEpoch;
         let fullAccess = false;
-        if (executing) {
+        if (controllingTurn) {
             const boundary = await connection.request('session.execution_boundary.query', { sessionId });
             assertActive();
             if (boundary.kind === 'external')
@@ -212,7 +248,11 @@ export async function runMakaSessionCommand(connection, options, env, allowDetac
                 sessionId,
             });
             assertActive();
-            return { ...observer.status(), executionBoundary };
+            return {
+                ...observer.status(),
+                executionBoundary,
+                ...(configuration ? { configuration } : {}),
+            };
         }
         if (options.noWait) {
             if (submission !== 'queued' && submission !== 'steering')
@@ -281,6 +321,44 @@ export async function runMakaSessionCommand(connection, options, env, allowDetac
 function terminal(status) {
     return status === 'completed' || status === 'failed' || status === 'cancelled';
 }
+async function configureSessionModel(connection, options, assertActive) {
+    const selected = options.connection !== undefined
+        ? (await readRuntimeHostConnectionCatalog(connection)).connections.find((candidate) => candidate.slug === options.connection)
+        : undefined;
+    if (options.connection !== undefined && !selected)
+        throw new Error(`Runtime Host model connection is unavailable: ${options.connection}`);
+    return updateRuntimeHostSession(connection, options.sessionId, (current) => {
+        const changesModel = options.model !== undefined || options.connection !== undefined;
+        let patch = options.thinking !== undefined ? { thinkingLevel: options.thinking } : {};
+        if (changesModel) {
+            if (current.executorId && !selected) {
+                patch = { ...patch, executorConfig: { model: options.model } };
+            }
+            else {
+                const connectionId = selected?.connectionId ?? current.llmConnectionId;
+                if (!connectionId)
+                    throw new Error('Model selection requires an explicit --connection');
+                const changesTarget = connectionId !== current.llmConnectionId ||
+                    (options.model ?? current.model) !== current.model;
+                patch = {
+                    ...patch,
+                    ...(changesTarget && options.thinking === undefined ? { thinkingLevel: null } : {}),
+                    modelTarget: {
+                        kind: 'explicit',
+                        connectionId,
+                        connectionSlug: selected?.slug ?? current.llmConnectionSlug,
+                        model: options.model ?? current.model,
+                    },
+                };
+            }
+        }
+        return connection.request('session.configuration.update', {
+            sessionId: options.sessionId,
+            expectedRevision: current.revision,
+            patch,
+        });
+    }, { operation: 'session.configuration.update', assertRequestAllowed: assertActive });
+}
 class SessionRunObserver {
     #connection;
     #sessionId;
@@ -407,14 +485,14 @@ class SessionRunObserver {
         return result.landmarks.at(-1)?.turnId;
     }
     async result(turnId) {
-        const classifier = new TurnOutcomeClassifier(turnId, { recoverStoredRetries: true });
+        const classifier = new TurnOutcomeClassifier(turnId);
         await this.#channel.replayTranscript(async (messages) => {
             acceptStoredTurn(classifier, messages, turnId);
         }, this.#signal);
         const outcome = classifier.outcome('pending');
         if (!outcome)
             return undefined;
-        if (outcome.status === 'completed' && outcome.sandboxBoundary === 'none') {
+        if (outcome.status === 'completed') {
             return {
                 sessionId: this.#sessionId,
                 status: 'completed',
@@ -424,9 +502,7 @@ class SessionRunObserver {
         return {
             sessionId: this.#sessionId,
             status: 'failed',
-            error: outcome.sandboxBoundary === 'unresolved'
-                ? 'Turn encountered an unresolved sandbox boundary'
-                : (outcome.failure?.message ?? outcome.failure?.class ?? 'Turn failed'),
+            error: outcome.failure?.message ?? outcome.failure?.class ?? 'Turn failed',
         };
     }
     changed(version) {

package/dist/run-turn-outcome.js

@@ -16,28 +16,20 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-import { isDeepStrictEqual } from 'node:util';
 import { failureClassFromCompleteStopReason } from '@maka/core/events';
 export class TurnOutcomeClassifier {
     #outcomeId;
-    #recoverStoredRetries;
-    #calls = new Map();
     #unresolvedSandboxFailures = new Set();
     #finalOutput;
     #finalOutputFromLive = false;
     #terminal;
-    constructor(outcomeId, options = {}) {
+    constructor(outcomeId) {
         this.#outcomeId = outcomeId;
-        this.#recoverStoredRetries = options.recoverStoredRetries === true;
     }
     accept(observation) {
         switch (observation?.kind) {
             case undefined:
                 return;
-            case 'tool_call':
-                if (this.#recoverStoredRetries)
-                    this.#calls.set(observation.call.id, observation.call);
-                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
@@ -57,27 +49,6 @@ export class TurnOutcomeClassifier {
                 if (observation.outcome === 'sandbox_failure') {
                     this.#unresolvedSandboxFailures.add(observation.toolUseId);
                 }
-                if (observation.outcome === 'success' && this.#recoverStoredRetries) {
-                    const retry = this.#calls.get(observation.toolUseId);
-                    for (const id of this.#unresolvedSandboxFailures) {
-                        const failed = this.#calls.get(id);
-                        // Full durable arguments and a different provider step distinguish
-                        // a retry from an unrelated success or a same-step parallel sibling.
-                        // One successful retry reconciles one failed call, never all failures.
-                        if (retry?.stepId &&
-                            failed?.stepId &&
-                            retry.stepId !== failed.stepId &&
-                            retry.toolName === failed.toolName &&
-                            retry.args !== undefined &&
-                            failed.args !== undefined &&
-                            isDeepStrictEqual(retry.args, failed.args)) {
-                            this.#unresolvedSandboxFailures.delete(id);
-                            break;
-                        }
-                    }
-                }
-                // Blocking run keeps its original denial protection. Session results
-                // opt into durable retry evidence, since their boundary can be approved.
                 return;
             }
         }
@@ -129,8 +100,6 @@ export function observationFromSessionEvent(event) {
     return event.type === 'tool_result' ? observationFromToolResult(event) : undefined;
 }
 function observationFromStoredMessage(message) {
-    if (message.type === 'tool_call')
-        return { kind: 'tool_call', call: message };
     if (message.type === 'assistant' && message.text.trim().length > 0) {
         return { kind: 'output', text: message.text, source: 'stored' };
     }
@@ -152,7 +121,7 @@ function observationFromStoredMessage(message) {
             status: 'failed',
             failure: {
                 class: message.errorClass ?? 'runtime_error',
-                message: message.failureMessage ?? 'Turn failed',
+                message: message.failureMessage ?? message.errorClass ?? 'Turn failed',
             },
         };
     }

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)