@myagentroam/node 0.10.35 → 0.10.37

package/dist/runner/mar-agent/computer-use.js

@@ -6,6 +6,7 @@ import { resolve } from 'node:path';
 import { createInterface } from 'node:readline';
 import { terminateProcessTree } from '../../process-tree.js';
 import { ComputerUseControlIndicator } from './computer-use-indicator.js';
+import { PYTHON_PROBE_SOURCE } from './computer-use-probe.js';
 const TOOL_NAME = 'mcp__computer__exec';
 const DEFAULT_TIMEOUT_MS = 30_000;
 const MAX_TIMEOUT_MS = 120_000;
@@ -545,40 +546,69 @@ export async function probeComputerUse(configuration) {
     try {
         await access(configuration.runtimeExecutable);
         const result = await runProbe(configuration.runtimeExecutable);
-        return result
-            ? {
-                ...base,
-                available: true,
-                reasonCode: null,
-                supportsScreenshot: true,
-                supportsInput: true,
-                supportsUnicodePaste: true,
-                supportsPrimaryDisplay: true
-            }
-            : { ...base, available: false, reasonCode: 'COMPUTER_RUNTIME_UNAVAILABLE' };
+        if (result === undefined)
+            return { ...base, available: false, reasonCode: 'COMPUTER_RUNTIME_UNAVAILABLE' };
+        return { ...base, ...result, available: result.reasonCode === null };
     }
     catch {
         return { ...base, available: false, reasonCode: 'COMPUTER_RUNTIME_UNAVAILABLE' };
     }
 }
 async function runProbe(executable) {
-    const child = spawn(executable, [
-        '-c',
-        'import pyautogui, pyperclip; im=pyautogui.screenshot(); assert im.width > 0 and im.height > 0; print("ok")'
-    ], { stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true });
+    const child = spawn(executable, ['-c', PYTHON_PROBE_SOURCE], {
+        stdio: ['ignore', 'pipe', 'pipe'],
+        windowsHide: true
+    });
     let stdout = '';
-    child.stdout.on('data', (chunk) => (stdout += chunk.toString('utf8')));
+    let overflow = false;
+    child.stdout.on('data', (chunk) => {
+        if (stdout.length + chunk.length > 4096)
+            overflow = true;
+        if (!overflow)
+            stdout += chunk.toString('utf8');
+    });
+    child.stderr.resume();
     return await new Promise((resolveProbe) => {
         const timeout = setTimeout(() => {
-            void terminateProcessTree(child).finally(() => resolveProbe(false));
+            void terminateProcessTree(child).finally(() => resolveProbe(undefined));
         }, 10_000);
-        child.once('exit', (code) => {
+        child.once('close', (code) => {
             clearTimeout(timeout);
-            resolveProbe(code === 0 && stdout.trim() === 'ok');
+            if (code !== 0 || overflow)
+                return resolveProbe(undefined);
+            try {
+                const value = JSON.parse(stdout);
+                if (value === null ||
+                    typeof value !== 'object' ||
+                    typeof value.supportsScreenshot !== 'boolean' ||
+                    typeof value.supportsInput !== 'boolean' ||
+                    typeof value.supportsUnicodePaste !== 'boolean' ||
+                    typeof value.supportsPrimaryDisplay !== 'boolean')
+                    return resolveProbe(undefined);
+                const reasonCode = value.reasonCode === 'COMPUTER_DESKTOP_UNSUPPORTED'
+                    ? value.reasonCode
+                    : !value.supportsScreenshot || !value.supportsPrimaryDisplay
+                        ? 'COMPUTER_RUNTIME_UNAVAILABLE'
+                        : !value.supportsInput
+                            ? 'COMPUTER_INPUT_PERMISSION_DENIED'
+                            : !value.supportsUnicodePaste
+                                ? 'COMPUTER_RUNTIME_UNAVAILABLE'
+                                : null;
+                resolveProbe({
+                    supportsScreenshot: value.supportsScreenshot,
+                    supportsInput: value.supportsInput,
+                    supportsUnicodePaste: value.supportsUnicodePaste,
+                    supportsPrimaryDisplay: value.supportsPrimaryDisplay,
+                    reasonCode
+                });
+            }
+            catch {
+                resolveProbe(undefined);
+            }
         });
         child.once('error', () => {
             clearTimeout(timeout);
-            resolveProbe(false);
+            resolveProbe(undefined);
         });
     });
 }

package/dist/runner/mar-agent/conversation-normalizer.js

@@ -579,6 +579,34 @@ function genericToolItem(id, toolName, status, input, outputSummary = null, erro
             truncated: truncated || source.length > 10_000 || output.length > 10_000
         }, status);
     }
+    if (toolName === 'code_exec_wait') {
+        const inputRecord = record(input);
+        const action = typeof inputRecord?.action === 'string' ? inputRecord.action : 'poll';
+        const inputSummary = compactRunnerValue(input, 10_000);
+        const result = output === undefined ? null : compactRunnerValue(output, 10_000);
+        const resultSummary = [outputSummary, result?.text]
+            .filter((value, index, values) => typeof value === 'string' && value.length > 0 && values.indexOf(value) === index)
+            .join('\n');
+        const details = [
+            `Action: ${compactRunnerText(action, 128)}`,
+            `Input: ${inputSummary.text || '{}'}`,
+            resultSummary.length === 0 ? '' : `Result: ${compactRunnerText(resultSummary, 10_000)}`,
+            errorCode === null ? '' : `Error: ${compactRunnerText(errorCode, 80)}`
+        ]
+            .filter(Boolean)
+            .join('\n');
+        return commandItem({
+            itemId: id,
+            command: toolName,
+            cwd: null,
+            outputPreview: details,
+            exitCode: null,
+            truncated: truncated ||
+                inputSummary.truncated ||
+                result?.truncated === true ||
+                resultSummary.length > 10_000
+        }, status);
+    }
     const subagent = marAgentSubagentProjection(toolName, input, output, subagentTitle, knownSubagentDetails);
     const toolCategory = isImageGenerationTool(toolName) ? 'IMAGE_GENERATION' : undefined;
     const inputSummary = compactRunnerValue(input, 10_000);

package/dist/runner/mar-agent/marctl-skill.js

@@ -18,15 +18,16 @@ export function marctlHostSkill(environment = {}) {
 const marctlInstructions = [
     '## MAR Workspace CLI',
     'Use exec to run marctl. Reuse loaded guidance while it remains in context. Consult local marctl help sessions for unclear options and marctl --version when version matters; neither needs a network request. Capabilities and permissions still apply.',
-    'Use sessions current --json only when the current identity or scope is unknown. For a known target ID, use sessions show <session-id> --json only when fresh state is needed, without current/list first. Use sessions list --limit 10 --json to discover an unknown target; list has no name-search option. Stop once found and follow nextCursor only if needed. Do not scan the Workspace to prove capacity: check assigned work, recorded worker IDs and overlapping write scopes.',
+    'Use sessions current --json only when the current identity or scope is unknown. For a known target ID, use sessions show <session-id> --json only when fresh state is needed, without current/list first. Use sessions list --limit 10 --json to discover an unknown target; narrow with --query <title> or --parent <session-id>. These query Node-known Sessions without scanning Runners. Use sessions graph <session-id> --json only for a creation tree (bounded to 100 nodes with truncated); start automatically records the current Session as parent, not task ownership. Stop once found and follow nextCursor only if needed. Do not scan the Workspace to prove capacity: check assigned work, recorded worker IDs and overlapping write scopes.',
     'MAR binds sessions to the current Node and Workspace. No --node or --workspace override exists. Use returned native Session IDs, not titles, for later operations. A Workspace terminal may have no current Session. Missing scope, an old Node, expired authorization or an unavailable Runner is an explicit error, not permission to bypass the API.',
     '## Create and coordinate independent Sessions',
+    'Change an existing Session with sessions config <session-id> --model <id> --effort high --json; either option can be set alone. Use show for current settings; active execution is not restarted.',
     'Prefer -m / --message for short text; use --message-file for longer UTF-8 text or an existing file (- reads stdin). These options are mutually exclusive. Example: marctl sessions start --runner codex --title "fixer#42 Handle empty totals" -m "Implement issue #42 and report test evidence" --json. Other Runner names are mar-agent, claude-code and opencode. An omitted model uses the target Runner configuration, not the Coordinator model.',
     'For start/send, repeat --image <local-path> to attach PNG, JPEG, GIF or WebP images, with or without text. Images are read on this CLI host, not by remote path. Limits: 5 images, 5 MiB each, 10 MiB total. Actual Runner/model image capabilities apply; goal set accepts text only.',
     'Create workers only as tasks need them, named fixer#<task-id> <description> or reviewer#<task-or-change-id> <description>. These are conventions, not product roles or a fixed pool. Put role, scope, acceptance criteria and delivery requirements in the first message. Follow the repository workflow for development and review. Session Prompt is edited in the Web UI only; marctl has no editing command, and sends to existing Sessions use normal prompt injection.',
     'Reuse recorded Session/Run IDs and receipts. Refresh volatile Run, queue and Goal state with sessions show only when the next action depends on it. Select needed JSON fields instead of dumping full Session lists or tool transcripts. Hidden reasoning, credentials and raw model requests are not collaboration artifacts.',
     'Read results with sessions history <session-id> --limit 10 --json (default: latest 10 SEGMENTs, not messages; --limit 1..100). Extract needed assistant_message payload.text from segments[].items[]; keep segment runId and user_message.payload.clientMessageId for queued-input correlation. Reuse the returned page; follow --cursor <nextCursor> only for missing evidence.',
-    'Send with sessions send <session-id> -m "Review the updated patch" --json. Default send does not interrupt and can resume a paused queue; --delivery queue preserves a paused queue. Otherwise eligible queued input can start when idle. --delivery replace-current cancels the current Run and prioritizes the new input after release; it is not live steering. There are no queue-item edit/delete/reorder commands; show includes queue state. start/send return clientMessageId and the accepted/queued result. A queued result may refer to the currently active Run: associate queueItemId/clientMessageId with history before deciding that input finished.',
+    'When useful, add gentle context to an in-progress task with sessions send <session-id> --steer -m "Additional context: focus on the resume path." --json. Choose exactly one of --steer or --queue, even when idle; missing, conflicting, repeated, or obsolete options are rejected locally before input is read or a request is sent. Use --queue to place input in a subsequent turn. start/send return clientMessageId and the accepted/queued result. A queued result may refer to the currently active Run: associate queueItemId/clientMessageId with history before deciding that input finished. There are no queue-item edit/delete/reorder commands; show includes queue state.',
     'Wait with sessions wait <session-id> --run <run-id> --timeout 5m --json through the existing Watch. Prefer --timeout 5m when blocked on task completion; use 30s for a short deadline. Continue useful independent work before waiting. If exec returns a running process or cell, reuse its process/cell handle rather than starting another wait or polling show/list. Timeout or cancelled waiting does not stop the task. Use sessions stop <session-id> --run <run-id> --json only to stop that active Run; ownership rules still apply.',
     'Goal get/set/clear use the existing Session Goal semantics; see marctl help sessions. A Coordinator can work from ordinary messages or its existing schedule without a Goal. Worker completion never automatically wakes it. Actively wait/read results, or finish and reconcile on the next user message or scheduled input.',
     '## Verify, recover and respect authorization',

package/dist/runner/mar-agent-runner.js

@@ -369,6 +369,38 @@ export class MarAgentRunner extends AbstractRunner {
             await catalog.close().catch(() => undefined);
         }
     }
+    async restartInputState(sessionId, clientMessageId) {
+        const catalog = await openMarAgentSessionCatalog({ homeDirectory: this.homeDirectory });
+        try {
+            let cursor;
+            const states = new Map();
+            do {
+                const page = await catalog.history(sessionId, {
+                    ...(cursor === undefined ? {} : { cursor }),
+                    limit: 1000
+                });
+                for (const entry of page.entries) {
+                    if (entry.kind !== 'event' || entry.event.turnId === undefined)
+                        continue;
+                    const event = entry.event;
+                    if (event.type === 'execution.completed')
+                        states.set(event.turnId, event.permissionStop === undefined ? 'completed' : 'paused');
+                    else if (event.type === 'execution.failed')
+                        states.set(event.turnId, 'completed');
+                    else if (event.type === 'execution.cancelled')
+                        states.set(event.turnId, 'interrupted');
+                }
+                const user = page.entries.find((entry) => entry.kind === 'user' && entry.clientMessageId === clientMessageId);
+                if (user?.kind === 'user')
+                    return states.get(user.turnId) ?? 'interrupted';
+                cursor = page.nextCursor;
+            } while (cursor !== undefined);
+            return 'missing';
+        }
+        finally {
+            await catalog.close();
+        }
+    }
     async readOfficialConversation(session, input) {
         if (session.externalSessionId === null)
             return undefined;

package/dist/runtime-state.js

@@ -84,6 +84,7 @@ export class NodeRuntimeState {
             // A first user prompt is only a process-local temporary title. A
             // Runner/native title can replace it on the next discovery refresh.
             titleSource: customTitle === null ? 'AUTO' : 'CUSTOM',
+            parentSessionId: input.parentSessionId ?? null,
             lastActivityAt: input.lastActivityAt ?? now,
             createdAt: input.createdAt ?? now
         };
@@ -163,9 +164,9 @@ export class NodeRuntimeState {
     }
     updateAgentSessionConfiguration(input) {
         return this.replaceSession(input.sessionId, {
-            model: input.model,
-            effort: input.effort,
-            access: input.access
+            ...(input.model === undefined ? {} : { model: input.model }),
+            ...(input.effort === undefined ? {} : { effort: input.effort }),
+            ...(input.access === undefined ? {} : { access: input.access })
         });
     }
     updateAgentSessionAccess(sessionId, access) {
@@ -338,6 +339,7 @@ export class NodeRuntimeState {
             version: 0,
             clientMessageId: input.clientMessageId,
             ...(input.source === undefined ? {} : { source: input.source }),
+            ...(input.suppressNotifications === true ? { suppressNotifications: true } : {}),
             ...(input.initiatedByUserId === undefined
                 ? {}
                 : { initiatedByUserId: input.initiatedByUserId }),
@@ -416,6 +418,7 @@ export class NodeRuntimeState {
             runner: session.runner,
             clientMessageId: input.clientMessageId,
             content: input.content,
+            ...(input.suppressNotifications === true ? { suppressNotifications: true } : {}),
             attachments: input.attachments ?? [],
             ...(input.initiatedByUserId === undefined
                 ? {}
@@ -449,11 +452,14 @@ export class NodeRuntimeState {
         if (itemId === undefined)
             return undefined;
         const item = this.requireQueueItem(itemId);
-        const run = active.initiatedByUserId === undefined && item.initiatedByUserId !== undefined
-            ? { ...active, initiatedByUserId: item.initiatedByUserId }
-            : active;
-        if (run !== active)
-            this.runs.set(run.id, run);
+        const run = {
+            ...active,
+            ...(active.initiatedByUserId === undefined && item.initiatedByUserId !== undefined
+                ? { initiatedByUserId: item.initiatedByUserId }
+                : {}),
+            suppressNotifications: item.suppressNotifications === true
+        };
+        this.runs.set(run.id, run);
         this.queuedItems.set(sessionId, queue.slice(1));
         this.bumpQueueVersion(sessionId);
         this.queueItems.delete(itemId);
@@ -482,6 +488,7 @@ export class NodeRuntimeState {
             clientMessageId: item.clientMessageId,
             content: content ?? item.content,
             recentUserMessage: item.content,
+            ...(item.suppressNotifications === true ? { suppressNotifications: true } : {}),
             ...(item.attachments.length === 0 ? {} : { attachments: item.attachments }),
             ...(item.initiatedByUserId === undefined ? {} : { initiatedByUserId: item.initiatedByUserId })
         });
@@ -607,8 +614,6 @@ export class NodeRuntimeState {
             return { kind: 'run', run: this.requireRun(submission.id) };
         const item = this.requireQueueItem(submission.id);
         const run = this.activeSessionRun(sessionId);
-        if (run === undefined)
-            throw new Error('RUN_NOT_FOUND');
         return { kind: 'queue', item, run };
     }
     messagePreparationFailure(sessionId, clientMessageId) {

package/dist/service/continuous-run-coordinator.js

@@ -10,9 +10,25 @@ export class ContinuousRunCoordinator {
     startedExecutions = new Set();
     scheduledSessions = new Map();
     immediateQueueItems = new Set();
+    suspended = false;
     constructor(options) {
         this.options = options;
     }
+    suspend() {
+        this.suspended = true;
+        for (const timer of this.scheduledSessions.values())
+            clearTimeout(timer);
+        this.scheduledSessions.clear();
+    }
+    resumeScheduling() {
+        this.suspended = false;
+    }
+    isImmediate(itemId) {
+        return this.immediateQueueItems.has(itemId);
+    }
+    restoreImmediate(itemId) {
+        this.immediateQueueItems.add(itemId);
+    }
     accept(message, environment = {}) {
         const release = this.options.retainEnvironment?.(environment);
         let retained = false;
@@ -31,6 +47,7 @@ export class ContinuousRunCoordinator {
                 sessionId: message.sessionId,
                 clientMessageId: message.clientMessageId,
                 content: message.content,
+                ...(message.suppressNotifications === true ? { suppressNotifications: true } : {}),
                 ...(message.initiatedByUserId === undefined
                     ? {}
                     : { initiatedByUserId: message.initiatedByUserId }),
@@ -98,6 +115,23 @@ export class ContinuousRunCoordinator {
             throw new Error('SESSION_NOT_FOUND');
         const active = this.options.runtime.activeSessionRun(sessionId);
         const activeTurn = active && this.options.runtime.conversationTurnForRun(active.id);
+        const steering = input.steerTarget !== undefined &&
+            active !== undefined &&
+            active.id === input.activeRunId &&
+            activeTurn?.id === input.steerTarget.turnId &&
+            (activeTurn === undefined
+                ? !this.isMessageRun(active)
+                : this.options.runtime.currentExecutionId(active.id) !== undefined &&
+                    !['SUCCEEDED', 'FAILED', 'INTERRUPTED'].includes(activeTurn.status)) &&
+            (input.steerTarget.executionId === undefined ||
+                this.options.runtime.currentExecutionId(active.id) === input.steerTarget.executionId);
+        const intent = input.steerTarget !== undefined && !steering ? 'SEND' : input.intent;
+        if (steering && prepared?.prepareSteerInput !== undefined && !prepared.steering)
+            this.preparedInputs.set(input.submissionId, {
+                ...prepared,
+                input: prepared.prepareSteerInput(),
+                steering: true
+            });
         const executionEnded = active !== undefined &&
             this.options.runtime.currentExecutionId(active.id) === undefined &&
             activeTurn !== undefined &&
@@ -106,9 +140,11 @@ export class ContinuousRunCoordinator {
                 activeTurn.status === 'INTERRUPTED');
         const queueVersionBeforeSettle = this.options.runtime.sessionQueue(sessionId).version;
         const startsAcceptedRun = active !== undefined && input.submissionId === active.id;
-        if (startsAcceptedRun || !input.queueBefore.paused || input.intent !== 'QUEUE')
+        if (startsAcceptedRun || !input.queueBefore.paused || intent !== 'QUEUE')
             this.options.runtime.resumeSessionQueue(sessionId);
-        if (input.activeRunId !== undefined && active?.id === input.activeRunId) {
+        if (input.activeRunId !== undefined &&
+            active?.id === input.activeRunId &&
+            (input.steerTarget === undefined || steering)) {
             if (item !== undefined)
                 this.immediateQueueItems.add(item.id);
             if (executionEnded) {
@@ -140,13 +176,13 @@ export class ContinuousRunCoordinator {
             return 'QUEUED';
         }
         if (active === undefined && item !== undefined) {
-            if (input.queueBefore.paused && input.intent === 'SEND')
+            if (input.queueBefore.paused && intent === 'SEND')
                 this.options.runtime.prioritizeQueueItem(item.id);
             this.startIdleQueue(sessionId);
             return 'STARTED';
         }
         if (executionEnded && item !== undefined) {
-            if (input.queueBefore.paused && input.intent === 'SEND') {
+            if (input.queueBefore.paused && intent === 'SEND') {
                 this.options.runtime.prioritizeQueueItem(item.id);
                 this.publish(sessionId);
             }
@@ -186,7 +222,17 @@ export class ContinuousRunCoordinator {
         const resources = prepareComposerResourceInput(input, pending.cwd, pending.workspacePath ?? pending.cwd);
         this.preparedInputs.set(itemId, {
             ...pending,
-            input: withNonImageAttachmentPrompt(resources, pending.attachmentPaths, pending.attachmentFiles)
+            ...(pending.restartMessage === undefined
+                ? {}
+                : {
+                    restartMessage: {
+                        ...pending.restartMessage,
+                        content: this.options.runtime.getQueueItem(itemId)?.content ?? input
+                    }
+                }),
+            input: withNonImageAttachmentPrompt(pending.precedingInput === undefined
+                ? resources
+                : `${pending.precedingInput}\n\n${resources}`, pending.attachmentPaths, pending.attachmentFiles)
         });
     }
     deleteQueueItem(itemId) {
@@ -227,6 +273,7 @@ export class ContinuousRunCoordinator {
             if (current !== undefined && replacement !== undefined)
                 this.preparedInputs.set(item.id, {
                     ...replacement,
+                    precedingInput: current.input,
                     input: `${current.input}\n\n${replacement.input}`
                 });
         }
@@ -238,6 +285,8 @@ export class ContinuousRunCoordinator {
         this.startIdleQueue(sessionId);
     }
     schedule(sessionId, delayMs = 0) {
+        if (this.suspended)
+            return;
         if (this.scheduledSessions.has(sessionId))
             return;
         const timer = setTimeout(() => {
@@ -256,6 +305,8 @@ export class ContinuousRunCoordinator {
         this.schedule(sessionId);
     }
     async dispatch(sessionId) {
+        if (this.suspended || this.options.stopped())
+            return;
         const active = this.options.runtime.activeSessionRun(sessionId);
         if (active === undefined)
             return;
@@ -323,6 +374,8 @@ export class ContinuousRunCoordinator {
             const goalMcp = pending.goal === undefined ? undefined : await this.options.goalMcp?.(executionInput);
             const scheduledMcp = await this.options.scheduledMcp?.(executionInput);
             const mailMcp = await this.options.mailMcp?.(executionInput);
+            if (this.suspended || this.options.stopped())
+                return;
             if (!this.goalCurrent(pending)) {
                 this.dispatchedExecutions.delete(executionId);
                 this.rejectStaleGoal(executionId);

package/dist/service/direct-transfer-service.js

@@ -77,12 +77,12 @@ export class DirectTransferService {
     handleTerminal(value) {
         return this.terminalDirect?.handle(value, (id) => this.transports.get(id)?.peer) ?? false;
     }
-    close() {
+    close(code = 'DIRECT_NODE_STOPPED') {
         this.terminalDirect?.close();
         for (const transfer of [...this.transfers.values()])
-            void this.removeTransfer(transfer, 'DIRECT_NODE_STOPPED');
+            void this.removeTransfer(transfer, code);
         for (const transport of [...this.transports.values()])
-            this.removeTransport(transport, 'DIRECT_NODE_STOPPED');
+            this.removeTransport(transport, code);
     }
     dispose() {
         if (this.disposed)
@@ -215,6 +215,7 @@ export class DirectTransferService {
             uploadCommitted: false,
             opened: false,
             processing: Promise.resolve(),
+            controller: new AbortController(),
             lastLeaseAliveAt: this.now(),
             leaseExpiresAt: command.expiresAt,
             leaseTimer: undefined
@@ -267,10 +268,11 @@ export class DirectTransferService {
                     channel.close();
                 return;
             }
+            const pendingTransfer = this.transfers.get(openFrameSessionId(event.data) ?? '');
             void this.openChannel(transport, channel, event.data).catch((error) => {
                 channel.close();
                 const id = openFrameSessionId(event.data);
-                if (id !== undefined)
+                if (id !== undefined && this.transfers.get(id) === pendingTransfer)
                     this.fail(id, errorCode(error), errorMessage(error));
             });
         };
@@ -294,16 +296,25 @@ export class DirectTransferService {
         transfer.opened = true;
         channel.onmessage = (event) => {
             transfer.processing = transfer.processing
-                .then(() => this.channelMessage(transfer, event.data))
-                .catch((error) => this.fail(transfer.command.directSessionId, errorCode(error), errorMessage(error)));
+                .then(() => {
+                if (this.current(transfer))
+                    return this.channelMessage(transfer, event.data);
+            })
+                .catch((error) => {
+                if (this.current(transfer))
+                    this.fail(transfer.command.directSessionId, errorCode(error), errorMessage(error));
+            });
         };
         channel.onclose = () => {
             if (this.transfers.get(transfer.command.directSessionId) === transfer)
                 void this.removeTransfer(transfer, 'DIRECT_CHANNEL_CLOSED');
         };
-        await this.open(transfer);
+        transfer.processing = this.open(transfer);
+        await transfer.processing;
     }
     async channelMessage(transfer, data) {
+        if (!this.current(transfer))
+            return;
         const descriptor = transfer.command.transfer;
         const expectedSize = transferredSize(descriptor);
         if (descriptor.direction === 'DOWNLOAD') {
@@ -326,8 +337,10 @@ export class DirectTransferService {
                 throw new Error('DIRECT_FRAME_INVALID');
             if (control.size !== descriptor.size)
                 throw new Error('DIRECT_INTEGRITY_FAILED');
-            await transfer.upload.complete(control.size);
+            await transfer.upload.complete(control.size, transfer.controller.signal);
             transfer.uploadCommitted = true;
+            if (!this.current(transfer))
+                return;
             this.emit(transfer.command.directSessionId, {
                 type: 'direct.complete',
                 directSessionId: transfer.command.directSessionId,
@@ -340,6 +353,8 @@ export class DirectTransferService {
         if (bytes.byteLength === 0 || bytes.byteLength > 256 * 1024 || transfer.upload === undefined)
             throw new Error('DIRECT_CHUNK_INVALID');
         const offset = await transfer.upload.write(bytes);
+        if (!this.current(transfer))
+            return;
         transfer.channel?.send(JSON.stringify({ type: 'ACK', offset }));
     }
     async open(transfer) {
@@ -348,6 +363,11 @@ export class DirectTransferService {
             if (this.options.openUpload === undefined)
                 throw new Error('DIRECT_UPLOAD_UNAVAILABLE');
             transfer.upload = await this.options.openUpload(descriptor);
+            if (!this.current(transfer)) {
+                if (!transfer.preserveUpload)
+                    await this.cancelUpload(transfer);
+                return;
+            }
             transfer.channel?.send(JSON.stringify({ type: 'ACK', offset: transfer.upload.offset }));
             this.emit(transfer.command.directSessionId, {
                 type: 'direct.opened',
@@ -359,6 +379,8 @@ export class DirectTransferService {
         if (this.options.openDownload === undefined)
             throw new Error('DIRECT_DOWNLOAD_UNAVAILABLE');
         const source = await this.options.openDownload(descriptor);
+        if (!this.current(transfer))
+            return;
         const expectedSize = transferredSize(descriptor);
         transfer.channel?.send(JSON.stringify({ type: 'ACK', offset: source.offset }));
         this.emit(transfer.command.directSessionId, {
@@ -444,12 +466,20 @@ export class DirectTransferService {
             });
     }
     async removeTransfer(transfer, code) {
-        if (!this.transfers.delete(transfer.command.directSessionId))
+        if (!this.current(transfer))
             return;
+        this.transfers.delete(transfer.command.directSessionId);
         clearInterval(transfer.leaseTimer);
-        if (!transfer.uploadCommitted)
-            await transfer.upload?.cancel().catch(() => undefined);
+        const preserveWorkspaceUpload = transfer.command.transfer.direction === 'UPLOAD' &&
+            transfer.command.transfer.composerAttachment === undefined &&
+            (code === 'DIRECT_CHANNEL_CLOSED' ||
+                code === 'DIRECT_CONNECTION_FAILED' ||
+                code === 'DIRECT_TRANSFER_CONTROL_UNAVAILABLE');
+        transfer.preserveUpload = preserveWorkspaceUpload;
+        transfer.controller.abort();
         transfer.channel?.close();
+        if (!transfer.uploadCommitted && !preserveWorkspaceUpload)
+            await this.cancelUpload(transfer);
         if (code !== undefined)
             this.options.send('direct.error', {
                 type: 'direct.error',
@@ -458,6 +488,23 @@ export class DirectTransferService {
                 message: directErrorMessage(code)
             });
     }
+    current(transfer) {
+        return (this.transfers.get(transfer.command.directSessionId) === transfer &&
+            !transfer.controller.signal.aborted);
+    }
+    async cancelUpload(transfer) {
+        if (transfer.upload === undefined)
+            return;
+        transfer.cleanup ??= transfer.upload.cancel().catch(() => {
+            this.options.send('direct.error', {
+                type: 'direct.error',
+                directSessionId: transfer.command.directSessionId,
+                code: 'DIRECT_UPLOAD_CLEANUP_FAILED',
+                message: 'Temporary upload cleanup could not be completed.'
+            });
+        });
+        await transfer.cleanup;
+    }
 }
 function transferredSize(descriptor) {
     return descriptor.direction === 'DOWNLOAD' && descriptor.range !== undefined

package/dist/service/external-session-resume-service.js

@@ -70,7 +70,8 @@ export class ExternalSessionResumeService {
                         access: configuration.access,
                         ...(session.runnerTitle === null ? {} : { title: session.runnerTitle }),
                         ...(session.customTitle === null ? {} : { customTitle: session.customTitle }),
-                        sessionPrompt: session.sessionPrompt ?? null
+                        sessionPrompt: session.sessionPrompt ?? null,
+                        parentSessionId: session.parentSessionId ?? null
                     });
                 },
                 workspacePath: this.options.workspacePath,

package/dist/service/goal-runtime.js

@@ -31,6 +31,8 @@ export function stripGoalStartPrompt(text) {
     return close === -1 ? '' : text.slice(close + tags.close.length).trimStart();
 }
 export function publicGoalHistoryText(text) {
+    if (parseComposerTags(text)[0]?.kind === 'mar_restart')
+        return serializeComposerTag('mar_restart', {});
     const tags = goalPromptTags(text);
     if (tags === undefined)
         return text;
@@ -61,6 +63,17 @@ export class GoalRuntime {
     get(sessionId) {
         return this.goals.get(sessionId);
     }
+    restartState(sessionId) {
+        const goal = this.goals.get(sessionId);
+        return goal === undefined
+            ? undefined
+            : { goal: { ...goal }, executionFailures: this.executionFailures.get(sessionId) ?? 0 };
+    }
+    restoreRestartState(state) {
+        this.goals.set(state.goal.sessionId, { ...state.goal });
+        this.executionFailures.set(state.goal.sessionId, state.executionFailures);
+        this.changed(state.goal);
+    }
     migrateSession(previousId, nextId) {
         if (previousId === nextId)
             return;

package/dist/service/hosted-conversation-node-service.js

@@ -1,4 +1,4 @@
-import { modelUsageGrantSchema } from '@myagentroam/protocol';
+import { modelUsageGrantSchema, steerComposerMessage } from '@myagentroam/protocol';
 import { createHash, randomUUID } from 'node:crypto';
 import { constants } from 'node:fs';
 import { lstat, mkdir, open, readFile, rename, rm, utimes } from 'node:fs/promises';
@@ -446,12 +446,13 @@ export class HostedConversationNodeService {
                 throw new Error('HOSTED_CONVERSATION_RUN_ACTIVE');
             return this.startMessage(payload, input);
         }
+        const steerPrompt = steerComposerMessage(input.prompt);
         if (!this.interruptActiveRun(payload.userId, conversation, handle))
             throw new Error('HOSTED_CONVERSATION_RUN_ACTIVE');
         await this.runSettlements.get(conversation.id)?.catch(() => undefined);
-        return this.startMessage(payload, input);
+        return this.startMessage(payload, input, steerPrompt);
     }
-    async startMessage(payload, input) {
+    async startMessage(payload, input, steerPrompt) {
         let conversation = this.options.store.requireConversation(payload.userId, input.conversationId);
         if (this.cleanupLocks.has(conversation.id))
             throw new Error('HOSTED_CONVERSATION_STATE_INVALID');
@@ -494,7 +495,7 @@ export class HostedConversationNodeService {
             selected = selectModel(version, models, input.modelId ?? conversation.modelId);
         }
         const attachments = await Promise.all(input.attachmentIds.map((fileId) => this.requireAttachment(payload.userId, conversation.id, fileId)));
-        const prompt = attachmentPrompt(input.prompt, attachments);
+        const prompt = attachmentPrompt(steerPrompt ?? input.prompt, attachments);
         const generatedImagesDirectory = marAgentGeneratedImagesDirectory(paths.homeDirectory, conversation.sessionId);
         const generatedImagesLogicalPath = hostedConversationGeneratedImagesDisplayDirectory(conversation.sessionId);
         if (generatedImagesDirectory === undefined || generatedImagesLogicalPath === undefined)