@myagentroam/node 0.10.48 → 0.10.50

package/dist/connector.js

@@ -1,4 +1,5 @@
 import { normalizeMarAgentUsage } from './runner/mar-agent/conversation-normalizer.js';
+import { isImageAttachment } from './util/node-operation-parsers.js';
 import { ModelUsageOutbox } from './service/model-usage-outbox.js';
 import { NodeModelUsageService } from './service/model-usage-service.js';
 import { dirname, resolve } from 'node:path';
@@ -801,6 +802,41 @@ export class NodeConnector {
         });
         this.continuousRunCoordinator = new ContinuousRunCoordinator({
             runtime: this.runtime,
+            steer: (prepared, item, executionId) => {
+                const runner = this.runners.optional(prepared.runner);
+                if (!runner?.supportsNativeSteer())
+                    return undefined;
+                const images = item.attachments.filter(isImageAttachment).map((image) => ({
+                    name: image.name,
+                    mimeType: image.mime,
+                    dataBase64: image.dataBase64
+                }));
+                return runner
+                    .steerManagedRun({
+                    expectedExecutionId: executionId,
+                    prompt: item.content,
+                    modelText: prepared.input,
+                    clientMessageId: item.clientMessageId,
+                    model: prepared.model,
+                    effort: prepared.effort,
+                    access: prepared.access,
+                    collaborationMode: prepared.collaborationMode,
+                    images
+                })
+                    .then((result) => {
+                    if (result.status !== 'accepted')
+                        return result;
+                    const attachments = this.runAttachmentService.append(executionId, item.attachments.filter(isImageAttachment));
+                    return {
+                        ...result,
+                        item: {
+                            ...result.item,
+                            merge: true,
+                            payload: { ...result.item.payload, ...(attachments.length ? { attachments } : {}) }
+                        }
+                    };
+                });
+            },
             emitQueue: (workspaceId, sessionId) => {
                 this.runEventBridge.emitQueue(workspaceId, sessionId);
                 this.runAttachmentService.refreshSession(sessionId);
@@ -820,37 +856,8 @@ export class NodeConnector {
             retainEnvironment: (environment) => this.gitExecution().retain(environment),
             goalCurrent: (input) => input.goal === undefined || this.goalGenerationCurrent(input.sessionId, input.goal),
             goalActive: (sessionId) => this.goalRuntime.get(sessionId)?.status === 'active',
-            afterExecutionStarted: async (input) => {
-                if (input.goal === undefined)
-                    return;
-                if (!this.goalGenerationCurrent(input.sessionId, input.goal))
-                    return;
-                const updated = this.goalRuntime.recordTurn(input.sessionId);
-                const session = this.runtime.getAgentSession(input.sessionId);
-                const run = this.runtime.getRun(input.runId);
-                await this.enqueueGoalContinuation({
-                    sessionId: input.sessionId,
-                    goal: { id: input.goal.id, revision: input.goal.revision },
-                    ...(run?.initiatedByUserId === undefined
-                        ? {}
-                        : { initiatedByUserId: run.initiatedByUserId }),
-                    ...(input.usageGrant === undefined ? {} : { usageGrant: input.usageGrant }),
-                    secretEnvironment: input.secretEnvironment,
-                    ...(input.personalInstructions === undefined
-                        ? {}
-                        : { personalInstructions: input.personalInstructions }),
-                    ...(input.marAgentModel === undefined ? {} : { marAgentModel: input.marAgentModel }),
-                    ...(input.marAgentModels === undefined ? {} : { marAgentModels: input.marAgentModels }),
-                    ...(input.marAgentCompact === undefined
-                        ? {}
-                        : { marAgentCompact: input.marAgentCompact }),
-                    ...(input.marAgentRuntimeScopeId === undefined
-                        ? {}
-                        : { marAgentRuntimeScopeId: input.marAgentRuntimeScopeId })
-                });
-                if (updated !== undefined && session !== undefined)
-                    this.publishGoalState(session, updated);
-            },
+            afterExecutionStarted: (input) => this.maintainGoalContinuation(input, true),
+            afterExecutionSteered: (input) => this.maintainGoalContinuation(input, false),
             afterExecutionStartFailed: (input, error) => {
                 nodeLog('goal.execution-start.failed', {
                     sessionId: input.sessionId,
@@ -1248,6 +1255,7 @@ export class NodeConnector {
             respondUserInput: (runId, requestId, answers) => this.openCodeRunController.respondUserInput(runId, requestId, answers)
         });
         this.marAgentClient.bindControl({
+            steer: (input) => this.marAgentRunController.steer(input),
             decideApproval: (input) => this.marAgentRunController.decideApproval(input),
             start: (envelope) => this.marAgentRunController.start(envelope),
             cancel: (runId, intent) => this.marAgentRunController.cancel(runId, intent),
@@ -1926,6 +1934,34 @@ export class NodeConnector {
             current.id === goal.id &&
             current.revision === goal.revision);
     }
+    async maintainGoalContinuation(input, started) {
+        if (this.stopped || input.goal === undefined)
+            return;
+        if (!this.goalGenerationCurrent(input.sessionId, input.goal))
+            return;
+        const updated = started ? this.goalRuntime.recordTurn(input.sessionId) : undefined;
+        const session = this.runtime.getAgentSession(input.sessionId);
+        const run = this.runtime.getRun(input.runId);
+        await this.enqueueGoalContinuation({
+            sessionId: input.sessionId,
+            goal: { id: input.goal.id, revision: input.goal.revision },
+            continuationEpoch: input.goal.epoch,
+            ...(run?.initiatedByUserId === undefined ? {} : { initiatedByUserId: run.initiatedByUserId }),
+            ...(input.usageGrant === undefined ? {} : { usageGrant: input.usageGrant }),
+            secretEnvironment: input.secretEnvironment,
+            ...(input.personalInstructions === undefined
+                ? {}
+                : { personalInstructions: input.personalInstructions }),
+            ...(input.marAgentModel === undefined ? {} : { marAgentModel: input.marAgentModel }),
+            ...(input.marAgentModels === undefined ? {} : { marAgentModels: input.marAgentModels }),
+            ...(input.marAgentCompact === undefined ? {} : { marAgentCompact: input.marAgentCompact }),
+            ...(input.marAgentRuntimeScopeId === undefined
+                ? {}
+                : { marAgentRuntimeScopeId: input.marAgentRuntimeScopeId })
+        });
+        if (updated !== undefined && session !== undefined)
+            this.publishGoalState(session, updated);
+    }
     handleNativeGoalUpdate(runId, nativeGoal) {
         const pending = this.continuousRunCoordinator.pending(runId);
         if (pending?.goal === undefined || !this.goalGenerationCurrent(pending.sessionId, pending.goal))

package/dist/runner/abstract-runner.js

@@ -158,6 +158,12 @@ export class AbstractRunner {
     cancelManagedRun(runId, intent) {
         return this.control?.cancel(runId, intent) === true;
     }
+    supportsNativeSteer() {
+        return this.control?.steer !== undefined;
+    }
+    steerManagedRun(input) {
+        return this.control?.steer?.(input) ?? Promise.resolve({ status: 'notAccepted' });
+    }
     decideApproval(input) {
         return this.control?.decideApproval?.(input) === true;
     }

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

@@ -7,6 +7,21 @@ export function normalizeMarAgentUsage(usage) {
 import { boundedConversationItemId, compactRunnerText, compactRunnerValue } from '../../util/node-operation-parsers.js';
 import { runnerErrorProjection } from '../../util/runner-error.js';
 export class MarAgentConversationNormalizer {
+    input(entry) {
+        return {
+            itemId: boundedConversationItemId('mar-agent-input', entry.recordId ?? String(entry.sequence)),
+            kind: 'user_message',
+            status: 'COMPLETED',
+            merge: true,
+            payload: {
+                text: entry.text,
+                clientMessageId: entry.clientMessageId ?? null,
+                contexts: [],
+                delivery: 'ACCEPTED',
+                recordId: entry.recordId
+            }
+        };
+    }
     #tools = new Map();
     #commands = new Map();
     #processOrigins = new Map();
@@ -18,6 +33,8 @@ export class MarAgentConversationNormalizer {
         return itemId('message', nativeItemId);
     }
     normalize(event, options = {}) {
+        if (event.type === 'input.received')
+            return [this.input(event.entry)];
         if (event.type === 'execution.failed') {
             const projected = runnerErrorProjection({ code: event.code, message: event.message }, 'MAR_AGENT_RUN_FAILED');
             return [

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

@@ -1,5 +1,6 @@
 import { MarAgentConversationNormalizer } from './conversation-normalizer.js';
 import { publicGoalHistoryText } from '../../service/goal-runtime.js';
+import { boundedConversationItemId } from '../../util/node-operation-parsers.js';
 export function projectMarAgentHistory(session, entries, options = {}) {
     const turns = new Map();
     const normalizer = new MarAgentConversationNormalizer();
@@ -48,9 +49,11 @@ export function projectMarAgentHistory(session, entries, options = {}) {
             const turn = ensure(entry.turnId, at);
             // SDK mailbox messages are persisted as additional turn.user records in the same Turn.
             // The first input keeps its existing identity; later inputs use their storage sequence.
-            const id = turn.userItemId === null
-                ? `${entry.turnId}:user`
-                : `${entry.turnId}:user:${entry.sequence}`;
+            const id = entry.recordId
+                ? boundedConversationItemId('mar-agent-input', entry.recordId)
+                : turn.userItemId === null
+                    ? `${entry.turnId}:user`
+                    : `${entry.turnId}:user:${entry.sequence}`;
             const images = entry.images;
             const registeredImages = images === undefined ? [] : (options.registerInputImages?.(entry) ?? []);
             replace(turn, historyItem(session, turn, id, 'user_message', 'COMPLETED', {

package/dist/runner/mar-agent/hosted-conversation-runtime.js

@@ -134,8 +134,9 @@ export class MarAgentHostedConversationRuntime {
         let titleTask;
         const metadata = await agent.getSession(input.sessionId).catch(() => undefined);
         let execution;
+        let session;
         try {
-            const session = await agent.openSession(input.sessionId);
+            session = await agent.openSession(input.sessionId);
             execution = session.run({
                 prompt: input.prompt,
                 clientMessageId: input.clientMessageId,
@@ -228,6 +229,19 @@ export class MarAgentHostedConversationRuntime {
                 completedAt: null
             },
             completion,
+            steer: (request) => {
+                if (settled ||
+                    this.#active.get(input.sessionId)?.handle !== handle ||
+                    (request.modelId !== undefined && request.modelId !== input.modelId) ||
+                    (request.runtimeScopeId !== undefined && request.runtimeScopeId !== input.runtimeScopeId))
+                    return Promise.resolve({ status: 'notAccepted' });
+                return session.steer({
+                    expectedExecutionId: execution.executionId,
+                    prompt: request.prompt,
+                    modelText: request.modelText,
+                    clientMessageId: request.clientMessageId
+                });
+            },
             cancel: () => {
                 if (settled || this.#active.get(input.sessionId)?.handle !== handle)
                     return false;

package/dist/runner/mar-agent/managed-run-controller.js

@@ -9,7 +9,7 @@ import { nodeExecutionEnvironment } from '../../node-execution-environment.js';
 import { nodeLog } from '../../operational.js';
 import { BUNDLED_RIPGREP_VERSION, bundledRipgrepPath, prependBundledRipgrepToPath } from '../../ripgrep-binary.js';
 import { LocalAgentHost, createMarAgent, generateSessionTitle } from '@myagentroam/agent';
-import { marAgentReasoningEffortSchema, marAgentRuntimeModelConfigurationSchema, marAgentRuntimeCompactConfigurationSchema } from '@myagentroam/protocol';
+import { marAgentReasoningEffortSchema, resolveMarAgentDefaultReasoningEffort, marAgentRuntimeModelConfigurationSchema, marAgentRuntimeCompactConfigurationSchema } from '@myagentroam/protocol';
 import { boundedConversationItemId } from '../codex/conversation-parser.js';
 import { parseSecretEnvironment } from '../../util/secret-environment.js';
 import { canonicalJson } from '../../util/canonical-json.js';
@@ -32,6 +32,7 @@ export class MarAgentManagedRunController {
     host;
     #mcpClients = new MarAgentMcpClientCache();
     #executions = new Map();
+    #steerTargets = new Map();
     #sessionRuntimes = new Map();
     #runtimeAcquisitions = new Map();
     #runtimeCreations = new Map();
@@ -165,6 +166,10 @@ export class MarAgentManagedRunController {
             states: this.host.commandStates(session.id)
         };
     }
+    steer(input) {
+        return (this.#steerTargets.get(input.expectedExecutionId)?.(input) ??
+            Promise.resolve({ status: 'notAccepted' }));
+    }
     start(envelope) {
         const payload = envelope.payload;
         if (payload.runner !== 'mar-agent' ||
@@ -445,6 +450,29 @@ export class MarAgentManagedRunController {
                     ? session.compact(runInput)
                     : session.run(runInput);
             cancelExecution = () => handle.cancel();
+            const steerNormalizer = runtime.normalizer;
+            if (input.mode !== 'compact')
+                this.#steerTargets.set(input.runId, async (request) => {
+                    if (controller.signal.aborted ||
+                        (request.model && request.model !== input.model.id) ||
+                        (request.effort &&
+                            request.effort !==
+                                (reasoningEffort ??
+                                    resolveMarAgentDefaultReasoningEffort(input.model.defaultReasoningEffort, input.model.reasoningEfforts))) ||
+                        (request.access !== null && request.access !== (input.access ?? 'auto')) ||
+                        request.collaborationMode !== (input.mode === 'plan' ? 'plan' : 'default'))
+                        return { status: 'notAccepted' };
+                    const result = await session.steer({
+                        expectedExecutionId: handle.executionId,
+                        prompt: request.prompt,
+                        modelText: request.modelText,
+                        clientMessageId: request.clientMessageId,
+                        images: request.images
+                    });
+                    return result.status === 'accepted'
+                        ? { status: 'accepted', item: steerNormalizer.input(result.entry) }
+                        : result;
+                });
             this.host.emit(input.runId, 'run.running', {}, 'RUNNING');
             for await (const event of handle) {
                 if (event.type === 'execution.started' && metadata?.automaticTitlePending && !titleTask) {
@@ -559,6 +587,7 @@ export class MarAgentManagedRunController {
                 await this.#finishRuntimeExecution(input.runId, runtime).catch(() => undefined);
             this.host.active.delete(input.runId);
             this.#executions.delete(input.runId);
+            this.#steerTargets.delete(input.runId);
             if (cancelledDuringPreparation)
                 this.host.emit(input.runId, 'run.cancelled', { status: 'CANCELLED' }, 'CANCELLED');
         }

package/dist/runtime-state.js

@@ -1,5 +1,9 @@
 import { randomUUID } from 'node:crypto';
 import { permissionStopSchema } from '@myagentroam/protocol';
+/** User inputs arrive with a durable Session identity, unlike execution-local output IDs. */
+export function runConversationItemId(runId, itemId, kind) {
+    return kind === 'user_message' ? itemId : `${runId}:${itemId}`;
+}
 /**
  * Deliberately process-local runtime domain.  No method in this class writes
  * into Node SQLite: a Node restart loses active runs, approvals, leases and
@@ -32,6 +36,7 @@ export class NodeRuntimeState {
     sessionHistoryMutations = new Set();
     /** Session FIFO metadata is deliberately process-local with the rest of run state. */
     queuedItems = new Map();
+    receivingQueueItems = new Set();
     queueVersions = new Map();
     pausedQueues = new Set();
     /** Bounded tombstones reject stale internal start envelopes after terminal cleanup. */
@@ -441,6 +446,32 @@ export class NodeRuntimeState {
     getQueueItem(id) {
         return this.queueItems.get(id);
     }
+    reserveQueueItem(itemId) {
+        this.requireQueueItem(itemId);
+        this.assertQueueItemMutable(itemId);
+        this.receivingQueueItems.add(itemId);
+        return () => {
+            this.receivingQueueItems.delete(itemId);
+        };
+    }
+    assertQueueItemMutable(itemId) {
+        if (this.receivingQueueItems.has(itemId))
+            throw new Error('QUEUE_ITEM_RECEIVING');
+    }
+    consumeSteeredQueueItem(itemId, runId) {
+        const item = this.requireQueueItem(itemId);
+        const run = this.getRun(runId);
+        if (!run || run.sessionId !== item.sessionId || !this.receivingQueueItems.has(itemId))
+            throw new Error('QUEUE_ITEM_INVALID');
+        this.queuedItems.set(item.sessionId, (this.queuedItems.get(item.sessionId) ?? []).filter((id) => id !== itemId));
+        this.queueItems.delete(itemId);
+        this.bumpQueueVersion(item.sessionId);
+        this.messageSubmissions.set(`${item.sessionId}\u0000${item.clientMessageId}`, {
+            kind: 'run',
+            id: run.id
+        });
+        this.recentUserMessages.set(run.id, item.content);
+    }
     claimNextQueueItem(sessionId, content) {
         if (this.pausedQueues.has(sessionId))
             return undefined;
@@ -451,6 +482,8 @@ export class NodeRuntimeState {
         const itemId = queue[0];
         if (itemId === undefined)
             return undefined;
+        if (this.receivingQueueItems.has(itemId))
+            return undefined;
         const item = this.requireQueueItem(itemId);
         const run = {
             ...active,
@@ -508,6 +541,8 @@ export class NodeRuntimeState {
     }
     reorderSessionQueue(sessionId, expectedVersion, itemIds) {
         const current = this.queuedItems.get(sessionId) ?? [];
+        for (const id of current)
+            this.assertQueueItemMutable(id);
         if (this.sessionQueue(sessionId).version !== expectedVersion ||
             current.length !== itemIds.length ||
             new Set(current).size !== current.length ||
@@ -519,6 +554,7 @@ export class NodeRuntimeState {
         this.bumpQueueVersion(sessionId);
     }
     prioritizeQueueItem(itemId) {
+        this.assertQueueItemMutable(itemId);
         const item = this.requireQueueItem(itemId);
         const queue = this.queuedItems.get(item.sessionId) ?? [];
         if (!queue.includes(itemId))
@@ -531,6 +567,7 @@ export class NodeRuntimeState {
         return item;
     }
     updateQueueItem(itemId, content) {
+        this.assertQueueItemMutable(itemId);
         const item = this.requireQueueItem(itemId);
         if (!(this.queuedItems.get(item.sessionId) ?? []).includes(itemId))
             throw new Error('QUEUE_ITEM_INVALID');
@@ -540,6 +577,7 @@ export class NodeRuntimeState {
         return next;
     }
     updateQueueItemAttachments(itemId, attachments, content) {
+        this.assertQueueItemMutable(itemId);
         const item = this.requireQueueItem(itemId);
         const next = { ...item, attachments, ...(content === undefined ? {} : { content }) };
         this.queueItems.set(itemId, next);
@@ -548,6 +586,7 @@ export class NodeRuntimeState {
         return next;
     }
     deleteQueueItem(itemId) {
+        this.assertQueueItemMutable(itemId);
         const item = this.requireQueueItem(itemId);
         const queue = this.queuedItems.get(item.sessionId) ?? [];
         if (!queue.includes(itemId))
@@ -1324,13 +1363,16 @@ export class NodeRuntimeState {
             }
             const projected = conversationItemFromEvent(event);
             if (projected !== undefined) {
+                const itemId = runConversationItemId(event.runId, projected.itemId, projected.kind);
                 const trailingItem = turn.items.at(-1);
-                const orderedItems = trailingItem?.kind === 'assistant_message' && activeConversationItem(trailingItem.status)
+                const orderedItems = projected.kind !== 'user_message' &&
+                    trailingItem?.kind === 'assistant_message' &&
+                    activeConversationItem(trailingItem.status)
                     ? turn.items.map((item) => item.id === trailingItem.id
                         ? { ...item, status: 'COMPLETED', completedAt: event.createdAt }
                         : item)
                     : turn.items;
-                const existing = orderedItems.find((item) => item.id === `${event.runId}:${projected.itemId}`) ??
+                const existing = orderedItems.find((item) => item.id === itemId) ??
                     (projected.kind === 'assistant_message' &&
                         projected.itemId.startsWith('codex:') &&
                         trailingItem?.kind === 'assistant_message' &&
@@ -1340,7 +1382,7 @@ export class NodeRuntimeState {
                         : undefined);
                 const status = projected.status;
                 const item = {
-                    id: `${event.runId}:${projected.itemId}`,
+                    id: itemId,
                     sessionId: run.sessionId,
                     turnId: turn.id,
                     runId: event.runId,
@@ -1480,7 +1522,8 @@ function conversationItemFromEvent(event) {
     };
 }
 function projectableConversationKind(value) {
-    return (value === 'assistant_message' ||
+    return (value === 'user_message' ||
+        value === 'assistant_message' ||
         value === 'reasoning_summary' ||
         value === 'tool_call' ||
         value === 'command_execution' ||

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

@@ -2,6 +2,7 @@ import { withNonImageAttachmentPrompt } from '../util/node-operation-parsers.js'
 import { safeErrorCode } from '../util/safe-error.js';
 import { withSessionPrompt } from '../util/personal-instructions.js';
 import { prepareComposerResourceInput } from './composer-message-input.js';
+import { nodeLog } from '../operational.js';
 export class ContinuousRunCoordinator {
     options;
     preparedInputs = new Map();
@@ -10,6 +11,7 @@ export class ContinuousRunCoordinator {
     startedExecutions = new Set();
     scheduledSessions = new Map();
     immediateQueueItems = new Set();
+    steerInFlight = new Map();
     suspended = false;
     constructor(options) {
         this.options = options;
@@ -108,6 +110,25 @@ export class ContinuousRunCoordinator {
             this.options.emitRun(run.id, 'run.rejected', { code }, 'FAILED');
     }
     settle(input) {
+        const item = this.options.runtime.getQueueItem(input.submissionId);
+        const active = item && this.options.runtime.activeSessionRun(item.sessionId);
+        const turn = active && this.options.runtime.conversationTurnForRun(active.id);
+        if (input.steerTarget &&
+            active &&
+            active.id === input.activeRunId &&
+            turn?.id === input.steerTarget.turnId &&
+            this.options.runtime.currentExecutionId(active.id) === input.steerTarget.executionId) {
+            const attempt = this.tryNativeSteer(input.submissionId, active, input.onNativeAccepted);
+            if (attempt)
+                return attempt.then((accepted) => accepted
+                    ? 'RESTARTING'
+                    : this.suspended || this.options.stopped()
+                        ? 'QUEUED'
+                        : this.settleFallback(input));
+        }
+        return this.settleFallback(input);
+    }
+    settleFallback(input) {
         const prepared = this.preparedInputs.get(input.submissionId);
         const item = this.options.runtime.getQueueItem(input.submissionId);
         const sessionId = prepared?.sessionId ?? item?.sessionId;
@@ -187,6 +208,100 @@ export class ContinuousRunCoordinator {
         return 'QUEUED';
     }
     executeQueueItem(itemId) {
+        const item = this.requirePreparedItem(itemId);
+        const active = this.options.runtime.activeSessionRun(item.sessionId);
+        if (active) {
+            const attempt = this.tryNativeSteer(itemId, active);
+            if (attempt)
+                return attempt.then((accepted) => accepted
+                    ? { run: active, delivery: 'RESTARTING' }
+                    : this.suspended || this.options.stopped()
+                        ? { run: active, delivery: 'QUEUED' }
+                        : this.executeQueueItemFallback(itemId));
+        }
+        return this.executeQueueItemFallback(itemId);
+    }
+    tryNativeSteer(itemId, active, onAccepted) {
+        const previous = this.steerInFlight.get(itemId);
+        if (previous)
+            return previous.task;
+        if (this.suspended || this.options.stopped() || !this.options.steer || !this.canSteer(active))
+            return undefined;
+        const executionId = this.options.runtime.currentExecutionId(active.id);
+        if (!executionId)
+            return undefined;
+        this.prepareSteering(itemId);
+        const prepared = this.preparedInputs.get(itemId);
+        const item = this.options.runtime.getQueueItem(itemId);
+        const release = this.options.runtime.reserveQueueItem(itemId);
+        let attempt;
+        try {
+            attempt = this.options.steer(prepared, item, executionId);
+        }
+        catch (error) {
+            release();
+            throw error;
+        }
+        if (!attempt) {
+            release();
+            return undefined;
+        }
+        const task = attempt
+            .then(async (result) => {
+            if (result.status === 'notAccepted')
+                return false;
+            onAccepted?.();
+            this.options.runtime.consumeSteeredQueueItem(itemId, active.id);
+            this.immediateQueueItems.delete(itemId);
+            this.options.runtime.resumeSessionQueue(item.sessionId);
+            this.options.clearImages(itemId);
+            if (prepared.goal !== undefined && this.goalCurrent(prepared)) {
+                const current = this.preparedInputs.get(executionId);
+                if (current !== undefined)
+                    this.preparedInputs.set(executionId, { ...current, goal: prepared.goal });
+            }
+            try {
+                await this.options.afterExecutionSteered?.({ ...prepared, runId: executionId });
+            }
+            catch (error) {
+                nodeLog('queue.native_steer.continuation_failed', {
+                    level: 'warn',
+                    sessionId: item.sessionId,
+                    executionId,
+                    code: safeErrorCode(error, 'NATIVE_STEER_CONTINUATION_FAILED')
+                });
+            }
+            this.remove(itemId);
+            // Publication is best effort after ownership transfers; it cannot undo SDK acceptance.
+            for (const notify of [
+                () => {
+                    if (result.status === 'accepted')
+                        this.options.emitRun(executionId, 'conversation.item', result.item);
+                },
+                () => this.publish(item.sessionId)
+            ]) {
+                try {
+                    notify();
+                }
+                catch {
+                    nodeLog('queue.native_steer.notification_failed', {
+                        level: 'warn',
+                        sessionId: item.sessionId,
+                        executionId
+                    });
+                }
+            }
+            return true;
+        })
+            .finally(() => {
+            release();
+            this.steerInFlight.delete(itemId);
+            this.schedule(item.sessionId);
+        });
+        this.steerInFlight.set(itemId, { sessionId: item.sessionId, task });
+        return task;
+    }
+    executeQueueItemFallback(itemId) {
         const item = this.requirePreparedItem(itemId);
         const active = this.options.runtime.activeSessionRun(item.sessionId);
         if (active !== undefined && this.canSteer(active))
@@ -320,6 +435,8 @@ export class ContinuousRunCoordinator {
     async dispatch(sessionId) {
         if (this.suspended || this.options.stopped())
             return;
+        if ([...this.steerInFlight.values()].some((entry) => entry.sessionId === sessionId))
+            return;
         const active = this.options.runtime.activeSessionRun(sessionId);
         if (active === undefined)
             return;
@@ -490,6 +607,9 @@ export class ContinuousRunCoordinator {
         for (const [id, pending] of this.preparedInputs) {
             if (id === preservedSubmissionId)
                 continue;
+            // Native admission owns receiving items until its receipt settles.
+            if (this.steerInFlight.has(id))
+                continue;
             if (pending.sessionId !== sessionId || pending.goal === undefined)
                 continue;
             if (pending.goal.id === preservedGoal?.id && pending.goal.revision === preservedGoal.revision)

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

@@ -37,6 +37,7 @@ export class HostedConversationNodeService {
     pendingMessages = new Map();
     activeRuns = new Map();
     runSettlements = new Map();
+    nativeAdmissions = new Map();
     activities = new Map();
     expectedInterruptions = new Set();
     uploads = new Map();
@@ -448,6 +449,45 @@ export class HostedConversationNodeService {
             return this.startMessage(payload, input);
         }
         const steerPrompt = steerComposerMessage(input.prompt);
+        if (handle.steer) {
+            const barrier = Promise.withResolvers();
+            this.nativeAdmissions.set(handle, barrier.promise);
+            let result;
+            try {
+                const attachments = await Promise.all(input.attachmentIds.map((fileId) => this.requireAttachment(payload.userId, conversation.id, fileId)));
+                result = await handle.steer({
+                    prompt: input.prompt,
+                    modelText: attachmentPrompt(steerPrompt, attachments),
+                    clientMessageId: input.clientMessageId,
+                    ...(input.modelId === undefined ? {} : { modelId: input.modelId }),
+                    ...(payload.runtimeScopeId === undefined
+                        ? {}
+                        : { runtimeScopeId: payload.runtimeScopeId })
+                });
+                if (result.status !== 'notAccepted') {
+                    const now = this.now();
+                    this.options.store.createMessage({
+                        conversationId: conversation.id,
+                        clientMessageId: input.clientMessageId,
+                        runId: handle.run.id,
+                        userTextPresent: result.status === 'accepted' && sessionTitleFromFirstMessage(input.prompt).length > 0,
+                        status: 'RUNNING',
+                        createdAt: handle.run.startedAt,
+                        updatedAt: now
+                    });
+                    const accepted = await this.options.store.saveMessageAcceptance({
+                        conversationId: conversation.id,
+                        modelId: conversation.modelId,
+                        activityAt: now
+                    });
+                    return { conversation: this.summary(accepted.conversation), run: handle.run };
+                }
+            }
+            finally {
+                barrier.resolve();
+                this.nativeAdmissions.delete(handle);
+            }
+        }
         if (!this.interruptActiveRun(payload.userId, conversation, handle))
             throw new Error('HOSTED_CONVERSATION_RUN_ACTIVE');
         await this.runSettlements.get(conversation.id)?.catch(() => undefined);
@@ -637,6 +677,7 @@ export class HostedConversationNodeService {
                     status: 'FAILED',
                     completedAt: this.now()
                 }));
+                await this.nativeAdmissions.get(handle);
                 await this.finishRun(payload.userId, conversation.id, input.clientMessageId, handle.run, completion);
             }
             catch {
@@ -736,7 +777,7 @@ export class HostedConversationNodeService {
         const expectedInterruption = this.expectedInterruptions.has(interruptionKey);
         let conversation;
         try {
-            this.options.store.finishMessage(conversationId, clientMessageId, completion.status, completion.completedAt);
+            this.options.store.finishRunMessages(conversationId, run.id, completion.status, completion.completedAt);
             this.publishHostedEvent(conversationId, {
                 conversationId,
                 kind: 'run',

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

@@ -649,6 +649,11 @@ export class HostedConversationStore {
          WHERE conversation_id=? AND client_message_id=?`)
             .run(status, updatedAt, conversationId, clientMessageId);
     }
+    finishRunMessages(conversationId, runId, status, updatedAt) {
+        this.options.database.raw
+            .prepare(`UPDATE hosted_conversation_messages SET status=?,updated_at=? WHERE conversation_id=? AND run_id=?`)
+            .run(status, updatedAt, conversationId, runId);
+    }
     async rebuildConversationIndex() {
         const existing = this.existingFilesByConversation();
         const rebuilt = await this.scanConversationRoot(this.usersDirectory, existing);

package/dist/service/node-run-event-bridge.js

@@ -1,4 +1,5 @@
 import { conversationSegmentIdentityForItem, conversationSegments } from './conversation-segment-service.js';
+import { runConversationItemId } from '../runtime-state.js';
 import { isNodeAgentRun, isNodeConversationTurn, isPlainRecord } from '../runner/codex/conversation-parser.js';
 export function workbenchPayloadSessionId(runtime, category, payload) {
     if (!isPlainRecord(payload))
@@ -59,7 +60,8 @@ export class NodeRunEventBridge {
                 ? turn.items.find((candidate) => candidate.kind === 'assistant_message' && candidate.revision === sequence)
                 : nativeItemId === undefined
                     ? undefined
-                    : turn.items.find((candidate) => candidate.id === `${runId}:${nativeItemId}`);
+                    : turn.items.find((candidate) => candidate.id ===
+                        runConversationItemId(runId, nativeItemId, typeof rawPayload?.kind === 'string' ? rawPayload.kind : undefined));
             if (text !== undefined && item?.kind === 'assistant_message') {
                 const segment = conversationSegmentIdentityForItem(turn, item.id, item.kind);
                 payload = {

package/dist/service/session-message-service.js

@@ -206,6 +206,7 @@ export class SessionMessageService {
                 this.options.coordinator.publishCurrentTurn(created.run.id);
             const prepare = async () => {
                 let reservation;
+                let nativeAccepted = false;
                 try {
                     const currentSession = this.options.runtime.getAgentSession(session.id) ?? session;
                     if (attachmentIds.length > 0)
@@ -301,7 +302,10 @@ export class SessionMessageService {
                     this.options.attachments.retainSessionFiles(currentSession.id, submissionId);
                     const delivery = internalRestore
                         ? 'QUEUED'
-                        : this.options.coordinator.settle({
+                        : await this.options.coordinator.settle({
+                            onNativeAccepted: () => {
+                                nativeAccepted = true;
+                            },
                             submissionId,
                             intent,
                             queueBefore: queueBeforeCreate,
@@ -313,6 +317,8 @@ export class SessionMessageService {
                     return delivery;
                 }
                 catch (error) {
+                    if (nativeAccepted)
+                        throw error;
                     reservation?.release();
                     if (goalMessage !== undefined)
                         this.options.goalPreparationFailed(session, goalMessage.goal, goalMessage.activated);

package/dist/service/workspace-queue-workbench-service.js

@@ -144,12 +144,12 @@ export class WorkspaceQueueWorkbenchService {
             auditReceipt: this.auditReceipt(item.sessionId, item.id, 'DELETE_QUEUE')
         };
     }
-    execute(input) {
+    async execute(input) {
         if (typeof input.queueItemId !== 'string')
             throw new Error('QUEUE_INVALID');
         const item = this.requireItem(input.queueItemId, input.workspaceId);
         assertQueueItemOwner(item, input.__requestUserId);
-        const result = this.options.coordinator.executeQueueItem(input.queueItemId);
+        const result = await this.options.coordinator.executeQueueItem(input.queueItemId);
         if (isPlainRecord(result))
             return {
                 ...result,

package/dist/service/workspace-upload-service.js

@@ -1,5 +1,5 @@
 import { createHash, randomUUID } from 'node:crypto';
-import { link, lstat, mkdir, open, readFile, rename, rm, stat } from 'node:fs/promises';
+import { link, lstat, mkdir, open, readFile, rename, rm } from 'node:fs/promises';
 import { dirname, join, posix, resolve } from 'node:path';
 import { parseComposerAttachmentUpload, validComposerAttachmentName } from '../util/node-operation-parsers.js';
 import { preflightWorkspaceUpload, workspaceUploadTemporaryName } from '../workspace.js';
@@ -61,9 +61,7 @@ export class WorkspaceUploadService {
             throw new Error('UPLOAD_TARGET_BUSY');
         const id = randomUUID();
         const temporaryPath = resolve(dirname(target.absolutePath), workspaceUploadTemporaryName(id));
-        const parentIdentity = await stat(dirname(target.absolutePath));
         const handle = await open(temporaryPath, 'wx+');
-        const stagingIdentity = await handle.stat();
         const timer = setTimeout(() => {
             const upload = this.state.uploads.get(id);
             if (upload !== undefined)
@@ -73,8 +71,6 @@ export class WorkspaceUploadService {
             id,
             workspaceId: workspace.id,
             workspacePath: workspace.path,
-            parentIdentity,
-            stagingIdentity,
             path: target.path,
             targetPath: target.absolutePath,
             temporaryPath,
@@ -361,15 +357,10 @@ export class WorkspaceUploadService {
                 throw new Error('UPLOAD_TARGET_EXISTS');
         }
         const parent = await lstat(dirname(upload.targetPath));
-        if (!parent.isDirectory() ||
-            parent.isSymbolicLink() ||
-            !sameIdentity(parent, upload.parentIdentity))
+        if (!parent.isDirectory() || parent.isSymbolicLink())
             throw new Error('UPLOAD_TARGET_INVALID');
         const staging = await lstat(upload.temporaryPath);
-        if (!staging.isFile() ||
-            staging.isSymbolicLink() ||
-            !sameIdentity(staging, upload.stagingIdentity) ||
-            staging.size !== upload.size)
+        if (!staging.isFile() || staging.isSymbolicLink() || staging.size !== upload.size)
             throw new Error('UPLOAD_STAGING_INVALID');
     }
     async remove(upload) {
@@ -382,9 +373,9 @@ export class WorkspaceUploadService {
                 return undefined;
             throw error;
         });
-        if (!sameIdentity(parent, upload.parentIdentity) ||
+        if (!parent.isDirectory() ||
             parent.isSymbolicLink() ||
-            (staging !== undefined && !sameIdentity(staging, upload.stagingIdentity)))
+            (staging !== undefined && (!staging.isFile() || staging.isSymbolicLink())))
             throw new Error('UPLOAD_CLEANUP_FAILED');
         if (staging !== undefined)
             await rm(upload.temporaryPath, { force: true });
@@ -427,9 +418,6 @@ export class WorkspaceUploadService {
         };
     }
 }
-function sameIdentity(actual, expected) {
-    return actual.dev === expected.dev && actual.ino === expected.ino;
-}
 async function safeDirectory(path) {
     const value = await lstat(path);
     if (!value.isDirectory() || value.isSymbolicLink())

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/node",
-  "version": "0.10.48",
+  "version": "0.10.50",
   "description": "MyAgentRoam Node runtime CLI.",
   "license": "Apache-2.0 AND GPL-2.0-or-later",
   "type": "module",
@@ -37,10 +37,10 @@
     "playwright": "1.62.1",
     "ws": "^8.21.3",
     "zod": "4.4.3",
-    "@myagentroam/code-navigation": "0.10.1",
-    "@myagentroam/agent": "0.10.48",
+    "@myagentroam/agent": "0.10.50",
+    "@myagentroam/protocol": "0.10.50",
     "@myagentroam/marctl": "0.10.10",
-    "@myagentroam/protocol": "0.10.48"
+    "@myagentroam/code-navigation": "0.10.1"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"