@myagentroam/node 0.10.47 → 0.10.49

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);
@@ -1248,6 +1284,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),
@@ -1619,7 +1656,8 @@ export class NodeConnector {
             emitSession: (session) => this.emitSessionWorkbenchEvent({
                 session: this.sessionPresentationService.present(session)
             }),
-            changed: () => this.scheduledSessions.changed()
+            changed: () => this.scheduledSessions.changed(),
+            proposed: (sessionId, proposalId) => this.emitScheduledProposalNotification(sessionId, proposalId)
         });
         this.operationRouter.registerAll(this.sessionScheduleService.operations());
         this.operationRouter.registerAll(this.sessionMessageService.operations());

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' ||
@@ -320,8 +325,10 @@ export class MarAgentManagedRunController {
             runtime.activeRunId = input.runId;
             await runtime.mcpLease.pool.refreshForExecution();
             controller.signal.throwIfAborted();
+            const marctlSkill = marctlHostSkill(input.secretEnvironment);
             const executionMcpServers = input.mcpServers
                 .filter(isExecutionScopedMcp)
+                .filter((server) => marctlSkill === undefined || server.name !== NODE_MCP.schedule.name)
                 .map((server) => ({ ...server, lifecycle: 'EXECUTION' }));
             computerUseBinding = await this.#computerUse?.bind({
                 runId: input.runId,
@@ -371,7 +378,6 @@ export class MarAgentManagedRunController {
                     ? {}
                     : { webFetch: (request, signal) => this.host.webFetch(request, signal) })
             }));
-            const marctlSkill = marctlHostSkill(input.secretEnvironment);
             executionMcpBinding = runtime.host.bindExecutionExtensions({
                 ...extensions,
                 environment: marctlExecutionEnvironment(input.secretEnvironment),
@@ -444,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) {
@@ -558,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/runner/mar-agent/marctl-skill.js

@@ -10,7 +10,7 @@ export function marctlHostSkill(environment = {}) {
         return undefined;
     return {
         name: 'marctl',
-        description: 'You are in a MAR-managed Workspace with marctl on PATH. Use this skill to inspect, create, message, stop or coordinate independent Sessions, or use authorized Node terminals and file transfer. Load before cross-Session coordination.',
+        description: 'You are in a MAR-managed Workspace with marctl on PATH. Use this skill to inspect, create, rename, configure, message, stop or coordinate independent Sessions, manage their scheduled tasks, or use authorized Node terminals and file transfer. Load before cross-Session coordination.',
         requiredTools: ['exec'],
         load: async () => marctlInstructions
     };
@@ -27,6 +27,9 @@ const marctlInstructions = [
     '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.',
     'show --json fields: session.activity, session.model, session.effort, session.customTitle or session.runnerTitle, runs[] (id/status), queue.items[], and goal.status (goal may be null). Run status and Goal status are separate.',
+    'Rename any authorized Workspace Session with sessions rename <session-id> --title <name> --json; parent relationships do not restrict renaming.',
+    'show/config/history/graph/rename and schedule get/create/update may omit the Session ID to use the current Session. Without a current Session, specify an ID. send/goal/stop/wait always require explicit target IDs.',
+    'Use sessions schedule list/get/create/update for the same tasks as the built-in schedule MCP, which is hidden while this skill is available. list is Workspace-scoped. create requires --cron and text (-m/--message-file, up to 20,000 characters). update requires --expected-revision from get and at least cron or text. Other-owner edits return a PENDING proposal, not an applied change; scheduled execution is read-only. Follow existing approval rules and do not retry conflicts or uncertain writes blindly.',
     'Read results with sessions history <session-id> --limit 10 --json (default: latest 10 SEGMENTs, not messages; --limit 1..100). In segments[].items[], select kind === "assistant_message" and read payload.text; keep segment runId and user_message.payload.clientMessageId for queued-input correlation. Reuse the returned page; follow --cursor <nextCursor> only for missing evidence.',
     'Use sessions send <session-id> --steer -m "Additional context: focus on the resume path." --json for decision-changing updates rather than routine reports: it may switch the current execution. Node decides delivery from actual state; an idle Session receives ordinary input. 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; with an active Goal, ordinary queued input waits until the Goal exits. 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.',

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,84 @@ 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((result) => {
+            if (result.status === 'notAccepted')
+                return false;
+            onAccepted?.();
+            this.options.runtime.consumeSteeredQueueItem(itemId, active.id);
+            this.remove(itemId);
+            this.immediateQueueItems.delete(itemId);
+            this.options.runtime.resumeSessionQueue(item.sessionId);
+            this.options.clearImages(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 +419,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;

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/schedule-mcp-bridge.js

@@ -139,32 +139,18 @@ export class ScheduleMcpBridge {
             if (task === undefined)
                 throw new Error('SCHEDULE_NOT_FOUND');
             const args = record(request.arguments);
-            const objective = args.objective;
-            const cron = args.cron;
-            if ((objective !== undefined && typeof objective !== 'string') ||
-                (cron !== undefined && typeof cron !== 'string') ||
-                (objective === undefined && cron === undefined))
-                throw new Error('SCHEDULE_UPDATE_INVALID');
-            const patch = {
-                ...(objective === undefined ? {} : { objective: objective }),
-                ...(cron === undefined ? {} : { cron: cron })
-            };
-            if (capability.actorUserId === task.ownerUserId) {
-                const updated = this.store().update(task.sessionId, task.revision, {
-                    ...patch,
-                    ownerUserId: capability.actorUserId
-                });
+            const result = this.store().updateFromAgent(task.sessionId, task.revision, capability.actorUserId, args);
+            if ('proposalId' in result) {
+                this.proposed(task.sessionId, result.proposalId);
+                socket.end(`${JSON.stringify({ result })}\n`);
+            }
+            else {
                 this.#capabilities.set(request.token, {
                     ...capability,
-                    revision: updated.revision
+                    revision: result.revision
                 });
                 this.changed(task.sessionId);
-                socket.end(`${JSON.stringify({ result: updated })}\n`);
-            }
-            else {
-                const proposalId = this.store().propose(task, capability.actorUserId, patch);
-                this.proposed(task.sessionId, proposalId);
-                socket.end(`${JSON.stringify({ result: { proposalId, status: 'PENDING' } })}\n`);
+                socket.end(`${JSON.stringify({ result })}\n`);
             }
         }
         catch (error) {

package/dist/service/scheduled-session-store.js

@@ -25,6 +25,62 @@ export class ScheduledSessionStore {
             .prepare('SELECT * FROM scheduled_session_tasks WHERE enabled=1 AND next_run_at<=? ORDER BY next_run_at,id')
             .all(at).map(taskFromRow);
     }
+    list(workspaceId, cursor, limit = 20) {
+        if (!Number.isSafeInteger(limit) || limit < 1 || limit > 100)
+            throw new Error('SCHEDULE_INVALID');
+        let after = '';
+        if (cursor !== undefined) {
+            try {
+                if (cursor.length > 4096)
+                    throw new Error();
+                const decoded = JSON.parse(Buffer.from(cursor, 'base64url').toString('utf8'));
+                if (decoded.workspaceId !== workspaceId ||
+                    typeof decoded.after !== 'string' ||
+                    decoded.after.length < 1 ||
+                    decoded.after.length > 512)
+                    throw new Error();
+                after = decoded.after;
+            }
+            catch {
+                throw new Error('SCHEDULE_INVALID');
+            }
+        }
+        const rows = this.database
+            .prepare(`SELECT t.*, COALESCE(json_extract(s.metadata,'$.customTitle'),
+         json_extract(s.metadata,'$.runnerTitle'),s.id) AS session_title
+       FROM scheduled_session_tasks t JOIN agent_sessions s ON s.id=t.session_id
+       WHERE t.workspace_id=? AND t.id>? ORDER BY t.id LIMIT ?`)
+            .all(workspaceId, after, limit + 1);
+        const tasks = rows
+            .slice(0, limit)
+            .map((row) => ({ ...taskFromRow(row), sessionTitle: row['session_title'] }));
+        return {
+            tasks,
+            nextCursor: rows.length > limit
+                ? Buffer.from(JSON.stringify({ workspaceId, after: tasks.at(-1).id })).toString('base64url')
+                : null
+        };
+    }
+    updateFromAgent(sessionId, expectedRevision, actorUserId, input) {
+        if (!Number.isSafeInteger(actorUserId) || actorUserId < 1)
+            throw new Error('USER_AUTHORIZATION_REQUIRED');
+        const task = this.get(sessionId);
+        if (task === undefined)
+            throw new Error('SCHEDULE_NOT_FOUND');
+        if (task.revision !== expectedRevision)
+            throw new Error('SCHEDULE_REVISION_CONFLICT');
+        if ((input.objective !== undefined && typeof input.objective !== 'string') ||
+            (input.cron !== undefined && typeof input.cron !== 'string') ||
+            (input.objective === undefined && input.cron === undefined))
+            throw new Error('SCHEDULE_UPDATE_INVALID');
+        const patch = {
+            ...(input.objective === undefined ? {} : { objective: input.objective }),
+            ...(input.cron === undefined ? {} : { cron: input.cron })
+        };
+        if (actorUserId === task.ownerUserId)
+            return this.update(sessionId, expectedRevision, patch);
+        return { proposalId: this.propose(task, actorUserId, patch), status: 'PENDING' };
+    }
     nextDueAt() {
         const row = this.database
             .prepare('SELECT MIN(next_run_at) AS value FROM scheduled_session_tasks WHERE enabled=1')

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/session-schedule-service.js

@@ -21,11 +21,64 @@ export class SessionScheduleService {
     operations() {
         return {
             'session.schedule.get': (data) => this.get(record(data)),
+            'session.schedule.list': (data) => this.list(record(data)),
+            'session.schedule.agent.save': (data) => this.saveFromAgent(record(data)),
             'session.schedule.save': (data) => this.save(record(data)),
             'session.schedule.remove': (data) => this.remove(record(data)),
             'session.schedule.proposal.resolve': (data) => this.resolveProposal(record(data))
         };
     }
+    list(input) {
+        if (typeof input.workspaceId !== 'string' ||
+            this.options.database().getWorkspace(input.workspaceId) === undefined)
+            throw new Error('WORKSPACE_NOT_FOUND');
+        if ((input.cursor !== undefined && typeof input.cursor !== 'string') ||
+            (input.limit !== undefined && typeof input.limit !== 'number'))
+            throw new Error('SCHEDULE_INVALID');
+        const page = this.store().list(input.workspaceId, input.cursor, input.limit);
+        return {
+            ...page,
+            tasks: page.tasks.map((task) => {
+                const session = this.options.runtime.getAgentSession(task.sessionId);
+                return {
+                    ...task,
+                    sessionTitle: session?.customTitle ?? session?.runnerTitle ?? task.sessionTitle
+                };
+            })
+        };
+    }
+    async saveFromAgent(input) {
+        const session = await this.requireSession(input, input.mode === 'create');
+        const actor = input.__requestUserId;
+        if (!Number.isSafeInteger(actor) || actor < 1)
+            throw new Error('USER_AUTHORIZATION_REQUIRED');
+        const sessionId = session.externalSessionId ?? session.id;
+        if (input.mode === 'create') {
+            if (this.store().get(sessionId) !== undefined)
+                throw new Error('SCHEDULE_ALREADY_EXISTS');
+            if (typeof input.objective !== 'string' || typeof input.cron !== 'string')
+                throw new Error('SCHEDULE_INVALID');
+            return {
+                task: await this.createFromMcp({
+                    sessionId: session.id,
+                    workspaceId: session.workspaceId,
+                    actorUserId: actor,
+                    objective: input.objective,
+                    cron: input.cron
+                })
+            };
+        }
+        if (input.mode !== 'update')
+            throw new Error('SCHEDULE_INVALID');
+        const result = this.store().updateFromAgent(sessionId, input.expectedRevision, actor, input);
+        if ('proposalId' in result) {
+            this.options.proposed?.(sessionId, result.proposalId);
+            return result;
+        }
+        this.options.emitSession(this.options.runtime.getAgentSession(session.id) ?? session);
+        this.options.changed?.();
+        return { task: result };
+    }
     async get(input) {
         const session = await this.requireSession(input);
         const store = this.store();
@@ -128,14 +181,14 @@ export class SessionScheduleService {
         this.options.changed?.();
         return { task, proposals: this.store().pendingProposals(task.id) };
     }
-    async requireSession(input) {
+    async requireSession(input, allowPendingNative = false) {
         if (typeof input.sessionId !== 'string' || typeof input.workspaceId !== 'string')
             throw new Error('SCHEDULE_INVALID');
         const session = this.options.runtime.getAgentSession(input.sessionId) ??
             (await this.options.projection.createMetadataProjection(input.sessionId));
         if (session === undefined ||
             session.workspaceId !== input.workspaceId ||
-            session.externalSessionId === null)
+            (session.externalSessionId === null && !allowPendingNative))
             throw new Error('SESSION_NOT_FOUND');
         return session;
     }

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/node",
-  "version": "0.10.47",
+  "version": "0.10.49",
   "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/agent": "0.10.47",
+    "@myagentroam/agent": "0.10.49",
     "@myagentroam/code-navigation": "0.10.1",
-    "@myagentroam/protocol": "0.10.47",
-    "@myagentroam/marctl": "0.10.9"
+    "@myagentroam/marctl": "0.10.10",
+    "@myagentroam/protocol": "0.10.49"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"