@myagentroam/node 0.10.36 → 0.10.38

package/dist/connector.js

@@ -1476,6 +1476,7 @@ export class NodeConnector {
             onConnected: () => {
                 this.runtimeCredentials.connected();
                 this.scheduledRunAuthorization.connected();
+                this.scheduledSessions.connected();
                 this.restartAuthorization.connected();
                 if (!this.stopped)
                     void this.restartHandoff.recover();
@@ -1866,6 +1867,7 @@ export class NodeConnector {
         this.usageOutbox.recoverInterrupted();
         this.database.closeRunningTerminalSessions();
         await this.restartHandoff.load();
+        this.scheduledSessions.recoverInterrupted();
         this.scheduledSessions.start();
         await this.initializeConversationHosting();
         this.computerUseEnablement.initialize();

package/dist/database.js

@@ -1,6 +1,7 @@
 import { NODE_SCHEMA_MIGRATION_V17 } from './migrations/v017.js';
 import { NODE_SCHEMA_MIGRATION_V18 } from './migrations/v018.js';
 import { NODE_SCHEMA_MIGRATION_V19 } from './migrations/v019.js';
+import { NODE_SCHEMA_MIGRATION_V20 } from './migrations/v020.js';
 import { normalizeSessionPrompt } from './util/personal-instructions.js';
 import { randomUUID } from 'node:crypto';
 import { closeSync, existsSync, mkdirSync, openSync, rmSync } from 'node:fs';
@@ -21,7 +22,8 @@ export const NODE_SCHEMA_MIGRATIONS = [
     NODE_SCHEMA_MIGRATION_V16,
     NODE_SCHEMA_MIGRATION_V17,
     NODE_SCHEMA_MIGRATION_V18,
-    NODE_SCHEMA_MIGRATION_V19
+    NODE_SCHEMA_MIGRATION_V19,
+    NODE_SCHEMA_MIGRATION_V20
 ];
 const LEGACY_NODE_SCHEMA_V12 = NODE_SCHEMA_VERSION_V13 - 1;
 const OBSOLETE_NODE_SCHEMA_V16 = 16;

package/dist/migrations/v020.js

@@ -0,0 +1,46 @@
+import { DatabaseSync } from 'node:sqlite';
+import { NODE_SCHEMA_V13 } from './v013.js';
+import { NODE_SCHEMA_MIGRATION_V14 } from './v014.js';
+import { NODE_SCHEMA_MIGRATION_V15 } from './v015.js';
+import { NODE_SCHEMA_MIGRATION_V16 } from './v016.js';
+import { NODE_SCHEMA_MIGRATION_V17 } from './v017.js';
+import { NODE_SCHEMA_MIGRATION_V18 } from './v018.js';
+import { NODE_SCHEMA_MIGRATION_V19 } from './v019.js';
+const sql = `CREATE INDEX scheduled_session_occurrences_unfinished
+  ON scheduled_session_occurrences(status) WHERE status IN ('CLAIMED','SUBMITTED');`;
+export const NODE_SCHEMA_MIGRATION_V20 = {
+    version: 20,
+    sql,
+    preflight: (database) => NODE_SCHEMA_MIGRATION_V19.assert(database),
+    assert(database) {
+        const reference = new DatabaseSync(':memory:');
+        try {
+            reference.exec(NODE_SCHEMA_V13);
+            for (const migration of [
+                NODE_SCHEMA_MIGRATION_V14,
+                NODE_SCHEMA_MIGRATION_V15,
+                NODE_SCHEMA_MIGRATION_V16,
+                NODE_SCHEMA_MIGRATION_V17,
+                NODE_SCHEMA_MIGRATION_V18,
+                NODE_SCHEMA_MIGRATION_V19
+            ])
+                reference.exec(migration.sql);
+            reference.exec(sql);
+            const schema = (db) => db
+                .prepare("SELECT type,name,sql FROM sqlite_master WHERE sql IS NOT NULL AND name NOT LIKE 'sqlite_%' ORDER BY type,name")
+                .all()
+                .map((row) => [
+                row.type,
+                row.name,
+                row.name === 'node_schema_migrations'
+                    ? String(row.sql).replace(/\s+/g, '')
+                    : String(row.sql).replace(/\s+/g, ' ').trim()
+            ]);
+            if (JSON.stringify(schema(reference)) !== JSON.stringify(schema(database)))
+                throw new Error('NODE_DATABASE_SCHEMA_INVALID:scheduled_session_occurrences_unfinished');
+        }
+        finally {
+            reference.close();
+        }
+    }
+};

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

@@ -0,0 +1,126 @@
+/** Read-only platform evidence; never inject input or replace clipboard contents. */
+export const PYTHON_PROBE_SOURCE = String.raw `
+import ctypes
+import json
+import os
+import shutil
+import subprocess
+import sys
+
+result = dict(supportsScreenshot=False, supportsPrimaryDisplay=False,
+              supportsInput=False, supportsUnicodePaste=False,
+              reasonCode="COMPUTER_RUNTIME_UNAVAILABLE")
+
+def signature(library, name, arguments, returns):
+    function = getattr(library, name)
+    function.argtypes = arguments
+    function.restype = returns
+    return function
+
+def windows_desktop():
+    user = ctypes.WinDLL("user32", use_last_error=True)
+    kernel = ctypes.WinDLL("kernel32", use_last_error=True)
+    handle, integer = ctypes.c_void_p, ctypes.c_uint32
+    open_desktop = signature(user, "OpenInputDesktop", [integer, ctypes.c_int, integer], handle)
+    close_desktop = signature(user, "CloseDesktop", [handle], ctypes.c_int)
+    thread_id = signature(kernel, "GetCurrentThreadId", [], integer)
+    thread_desktop = signature(user, "GetThreadDesktop", [integer], handle)
+    station = signature(user, "GetProcessWindowStation", [], handle)
+    information = signature(user, "GetUserObjectInformationW",
+                            [handle, ctypes.c_int, handle, integer, handle], ctypes.c_int)
+    def name(object_handle):
+        buffer = ctypes.create_unicode_buffer(256)
+        needed = integer()
+        if not information(object_handle, 2, buffer, ctypes.sizeof(buffer), ctypes.byref(needed)):
+            return None
+        return buffer.value
+    # DESKTOP_READOBJECTS | DESKTOP_WRITEOBJECTS. Do not switch or attach desktops.
+    desktop = open_desktop(0, False, 0x0001 | 0x0080)
+    if not desktop:
+        return False
+    try:
+        desktop_name = name(desktop)
+        return (name(station()) == "WinSta0" and desktop_name is not None
+                and desktop_name == name(thread_desktop(thread_id())))
+    finally:
+        close_desktop(desktop)
+
+def input_supported(gui):
+    if sys.platform == "win32":
+        return windows_desktop()
+    if sys.platform == "darwin":
+        services = ctypes.CDLL("/System/Library/Frameworks/ApplicationServices.framework/ApplicationServices")
+        graphics = ctypes.CDLL("/System/Library/Frameworks/CoreGraphics.framework/CoreGraphics")
+        trusted = signature(services, "AXIsProcessTrusted", [], ctypes.c_bool)
+        post_access = signature(graphics, "CGPreflightPostEventAccess", [], ctypes.c_bool)
+        return bool(trusted() and post_access())
+    if sys.platform == "linux":
+        display = gui._pyautogui_x11._display
+        if not display.has_extension("XTEST"):
+            return False
+        display.xtest_get_version(2, 2)
+        return True
+    return False
+
+def clipboard_supported():
+    import pyperclip
+    copy, paste = pyperclip.determine_clipboard()
+    if not callable(copy) or not callable(paste) or not copy or not paste:
+        return False
+    names = (getattr(copy, "__name__", ""), getattr(paste, "__name__", ""))
+    if sys.platform == "win32" and names == ("copy_windows", "paste_windows"):
+        user = ctypes.WinDLL("user32", use_last_error=True)
+        open_clipboard = signature(user, "OpenClipboard", [ctypes.c_void_p], ctypes.c_int)
+        close_clipboard = signature(user, "CloseClipboard", [], ctypes.c_int)
+        if not open_clipboard(None):
+            return False
+        # Opening and closing does not empty, read, or take ownership of the clipboard.
+        return bool(close_clipboard())
+    if sys.platform == "darwin":
+        import AppKit
+        board = AppKit.NSPasteboard.generalPasteboard()
+        if board is None:
+            return False
+        # Newer systems expose pasteboard policy. Do not provoke an access prompt.
+        if hasattr(board, "accessBehavior"):
+            allowed = getattr(AppKit, "NSPasteboardAccessBehaviorAlwaysAllow", None)
+            if allowed is None or board.accessBehavior() != allowed:
+                return False
+        if names == ("copy_osx_pyobjc", "paste_osx_pyobjc"):
+            return True
+        return (names == ("copy_osx_pbcopy", "paste_osx_pbcopy")
+                and shutil.which("pbcopy") is not None and shutil.which("pbpaste") is not None)
+    if sys.platform == "linux":
+        commands = {("copy_xclip", "paste_xclip"): ["xclip", "-version"],
+                    ("copy_xsel", "paste_xsel"): ["xsel", "--version"]}
+        command = commands.get(names)
+        executable = shutil.which(command[0]) if command is not None else None
+        if executable is None:
+            return False
+        # X11 access was established above. Verify the selected backend can run,
+        # without consuming a one-shot selection or requesting clipboard contents.
+        subprocess.run([executable, *command[1:]], stdin=subprocess.DEVNULL,
+                       stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=True, timeout=2)
+        return True
+    return False
+
+try:
+    if sys.platform not in ("win32", "darwin", "linux") or (sys.platform == "linux" and
+            (not os.environ.get("DISPLAY") or os.environ.get("WAYLAND_DISPLAY"))):
+        result["reasonCode"] = "COMPUTER_DESKTOP_UNSUPPORTED"
+    else:
+        import pyautogui
+        image = pyautogui.screenshot()
+        if image.width > 0 and image.height > 0:
+            result["supportsScreenshot"] = result["supportsPrimaryDisplay"] = True
+            result["reasonCode"] = "COMPUTER_INPUT_PERMISSION_DENIED"
+            if input_supported(pyautogui):
+                result["supportsInput"] = True
+                result["reasonCode"] = "COMPUTER_RUNTIME_UNAVAILABLE"
+                if clipboard_supported():
+                    result["supportsUnicodePaste"] = True
+                    result["reasonCode"] = None
+except Exception:
+    pass
+print(json.dumps(result))
+`;

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/managed-run-controller.js

@@ -20,6 +20,12 @@ import { MarAgentRuntimeModelFactory, sdkModelConfigurations, closeImageCredenti
 import { createImageGenerationExtensions } from './image-generation-extensions.js';
 import { createWebToolsExtensions } from './web-tools-extensions.js';
 import { combineExecutionExtensions } from './execution-extensions.js';
+const HOST_CONFIGURATION_CATEGORIES = [
+    'cwd',
+    'mcpServers',
+    'environment',
+    'guaranteedCommands'
+];
 export class MarAgentManagedRunController {
     runner;
     host;
@@ -592,7 +598,7 @@ export class MarAgentManagedRunController {
                     throw new Error('MAR_AGENT_SESSION_RUNTIME_ACTIVE');
                 if (!existing.released &&
                     existing.release === undefined &&
-                    existing.fingerprint === fingerprint) {
+                    existing.fingerprint.value === fingerprint.value) {
                     const configurations = compactRuntimeConfigurations(input.models, input.compact);
                     if (existing.modelFingerprint !== modelFingerprint ||
                         configurations.some((model) => model.credential?.type === 'RUNTIME_TICKET' ||
@@ -631,7 +637,7 @@ export class MarAgentManagedRunController {
                     });
                     return existing;
                 }
-                await this.#releaseRuntime(existing, 'host_configuration_changed');
+                await this.#releaseRuntime(existing, 'host_configuration_changed', HOST_CONFIGURATION_CATEGORIES.filter((category) => existing.fingerprint.categories[category] !== fingerprint.categories[category]));
             }
             const creation = this.#createRuntime(input, sessionKey, fingerprint, hostConfiguration);
             for (const key of creationKeys)
@@ -791,7 +797,7 @@ export class MarAgentManagedRunController {
             return;
         this.#scheduleRuntimeRelease(runtime);
     }
-    #releaseRuntime(runtime, reason) {
+    #releaseRuntime(runtime, reason, changedCategories = []) {
         if (runtime.release !== undefined)
             return runtime.release;
         runtime.release = (async () => {
@@ -800,6 +806,7 @@ export class MarAgentManagedRunController {
                 runtimeId: runtime.runtimeId,
                 sessionId: runtime.session.id,
                 reason,
+                ...(changedCategories.length === 0 ? {} : { changedCategories }),
                 ...(runtime.activeRunId === undefined ? {} : { runId: runtime.activeRunId })
             });
             if (runtime.idleTimer !== undefined) {
@@ -977,16 +984,25 @@ function isExecutionScopedMcp(server) {
         (server.transport === 'STDIO' && server.environment?.['MAR_CTL_USER_TOKEN'] !== undefined));
 }
 function sessionHostFingerprint(input, hostConfiguration) {
-    return createHash('sha256')
-        .update(canonicalJson({
+    const configuration = {
         cwd: input.cwd,
         mcpServers: input.mcpServers.filter((server) => !isExecutionScopedMcp(server)),
         environment: Object.entries(hostConfiguration.environment)
             .filter((entry) => entry[1] !== undefined)
             .sort(([left], [right]) => left.localeCompare(right)),
         guaranteedCommands: Object.entries(hostConfiguration.guaranteedCommands).sort(([left], [right]) => left.localeCompare(right))
-    }))
-        .digest('hex');
+    };
+    const digest = (value) => createHash('sha256').update(canonicalJson(value)).digest('hex');
+    return {
+        value: digest(configuration),
+        // Only fixed category names leave this comparison; never log these value fingerprints.
+        categories: {
+            cwd: digest(configuration.cwd),
+            mcpServers: digest(configuration.mcpServers),
+            environment: digest(configuration.environment),
+            guaranteedCommands: digest(configuration.guaranteedCommands)
+        }
+    };
 }
 function sessionModelFingerprint(input) {
     const compact = marAgentRuntimeCompactConfigurationSchema.safeParse(input.compact);

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

@@ -27,7 +27,7 @@ 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.',
     '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 urgent corrections with sessions send <session-id> --forced -m "Use the corrected acceptance criteria" --json. Always choose exactly one of --forced or --queue, even when idle; missing or conflicting modes are rejected locally. --forced inserts: send immediately when idle; if busy, interrupt the current execution and prioritize the new input after release, not live steering. Use --queue to wait for an eligible FIFO turn without interrupting or resuming a paused queue; eligible input can start immediately when idle. For non-urgent follow-ups, use sessions send <session-id> --queue -m "Include test evidence" --json. 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/service/continuous-run-coordinator.js

@@ -115,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 &&
@@ -123,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) {
@@ -157,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);
             }
@@ -211,7 +230,9 @@ export class ContinuousRunCoordinator {
                         content: this.options.runtime.getQueueItem(itemId)?.content ?? input
                     }
                 }),
-            input: withNonImageAttachmentPrompt(resources, pending.attachmentPaths, pending.attachmentFiles)
+            input: withNonImageAttachmentPrompt(pending.precedingInput === undefined
+                ? resources
+                : `${pending.precedingInput}\n\n${resources}`, pending.attachmentPaths, pending.attachmentFiles)
         });
     }
     deleteQueueItem(itemId) {
@@ -252,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}`
                 });
         }

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)

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

@@ -1,13 +1,26 @@
+import { SCHEDULE_RESTART_OUTCOME_UNKNOWN } from './scheduled-session-store.js';
 export class ScheduledSessionCoordinator {
     options;
     #now;
     #timer;
     #running = false;
     #closed = true;
+    #recovered = [];
     constructor(options) {
         this.options = options;
         this.#now = options.now ?? Date.now;
     }
+    /** Called only at Node startup, before admitting any new scheduled occurrence. */
+    recoverInterrupted() {
+        for (const recovered of this.options.store().recoverInterrupted())
+            this.#recovered.push(recovered);
+    }
+    connected() {
+        // Startup has no control connection yet. Send these best-effort alerts once it is ready.
+        for (const { task, occurrenceId } of this.#recovered.splice(0)) {
+            this.options.notify(task, occurrenceId, SCHEDULE_RESTART_OUTCOME_UNKNOWN, 'FAILED');
+        }
+    }
     start() {
         if (!this.#closed)
             return;

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

@@ -1,5 +1,6 @@
 import { randomUUID } from 'node:crypto';
 import { assertScheduleTimezone, nextScheduledAt, parseScheduledCron } from './scheduled-session-recurrence.js';
+export const SCHEDULE_RESTART_OUTCOME_UNKNOWN = 'SCHEDULE_RESTART_OUTCOME_UNKNOWN';
 export class ScheduledSessionStore {
     database;
     now;
@@ -176,6 +177,26 @@ export class ScheduledSessionStore {
             throw error;
         }
     }
+    recoverInterrupted() {
+        return this.write(() => {
+            // FAILED closes scheduling bookkeeping, not the unknown execution or its side effects.
+            const rows = this.database
+                .prepare(`UPDATE scheduled_session_occurrences SET status='FAILED',code=?,updated_at=?
+          WHERE status IN ('CLAIMED','SUBMITTED') RETURNING id,task_id`)
+                .all(SCHEDULE_RESTART_OUTCOME_UNKNOWN, this.now());
+            const tasks = new Map();
+            for (const row of rows) {
+                if (tasks.has(row.task_id))
+                    continue;
+                const task = this.getById(row.task_id);
+                if (task === undefined)
+                    throw new Error('SCHEDULE_TASK_NOT_FOUND');
+                tasks.set(task.id, task);
+                this.pruneTerminal(row.id);
+            }
+            return rows.map((row) => ({ task: tasks.get(row.task_id), occurrenceId: row.id }));
+        });
+    }
     finish(occurrenceId, status, code, runId) {
         const result = this.database
             .prepare(`UPDATE scheduled_session_occurrences SET status=?,code=?,run_id=?,updated_at=?
@@ -183,6 +204,9 @@ export class ScheduledSessionStore {
             .run(status, code ?? null, runId ?? null, this.now(), occurrenceId);
         if (result.changes === 0 || status === 'SUBMITTED')
             return;
+        this.pruneTerminal(occurrenceId);
+    }
+    pruneTerminal(occurrenceId) {
         this.database
             .prepare(`DELETE FROM scheduled_session_occurrences
       WHERE task_id=(SELECT task_id FROM scheduled_session_occurrences WHERE id=?)

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

@@ -5,7 +5,7 @@ import { parseSecretEnvironment } from '../util/secret-environment.js';
 import { personalInstructionsForRunner } from '../util/personal-instructions.js';
 import { safeErrorCode } from '../util/safe-error.js';
 import { publicGoalStartText } from './goal-runtime.js';
-import { serializeComposerTag, composerVisibleText } from '@myagentroam/protocol';
+import { serializeComposerTag, composerVisibleText, steerComposerMessage } from '@myagentroam/protocol';
 import { relative } from 'node:path';
 import { prepareComposerResourceInput, composerResourceInputTags, validateComposerSkills } from './composer-message-input.js';
 const INTERNAL_GOAL = Symbol('internalGoal');
@@ -161,6 +161,19 @@ export class SessionMessageService {
             if (internalSchedule && (active !== undefined || queueBeforeCreate.itemIds.length > 0))
                 throw new Error('SCHEDULE_SESSION_BUSY');
             const replaceCurrentRun = intent === 'REPLACE_CURRENT' ? active : undefined;
+            const userSteer = requestedIntent === 'REPLACE_CURRENT' &&
+                goalMessage?.activated !== true &&
+                !internalGoal &&
+                !internalSchedule &&
+                !internalRestore;
+            const steerTarget = userSteer
+                ? {
+                    turnId: active === undefined
+                        ? undefined
+                        : this.options.runtime.conversationTurnForRun(active.id)?.id,
+                    executionId: active === undefined ? undefined : this.options.runtime.currentExecutionId(active.id)
+                }
+                : undefined;
             const acceptedMessage = {
                 runId,
                 sessionId: session.id,
@@ -245,6 +258,11 @@ export class SessionMessageService {
                         workspaceId: currentSession.workspaceId,
                         runner: currentSession.runner,
                         input: runner.prepareMessageInput(runnerInput, planActive ? 'plan' : 'default'),
+                        ...(userSteer
+                            ? {
+                                prepareSteerInput: () => runner.prepareMessageInput(steerComposerMessage(runnerInput), planActive ? 'plan' : 'default')
+                            }
+                            : {}),
                         clientMessageId,
                         attachments: runnerImageAttachments,
                         attachmentPaths,
@@ -285,6 +303,7 @@ export class SessionMessageService {
                             submissionId,
                             intent,
                             queueBefore: queueBeforeCreate,
+                            ...(steerTarget === undefined ? {} : { steerTarget }),
                             ...(replaceCurrentRun === undefined ? {} : { activeRunId: replaceCurrentRun.id })
                         });
                     reservation?.commit((directories) => this.options.attachments.adoptSessionFiles(currentSession.id, submissionId, directories, currentSession.workspaceId, attachmentPaths));

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

@@ -1,3 +1,4 @@
+import { steerComposerMessage } from '@myagentroam/protocol';
 import { isPlainRecord, withNonImageAttachmentPrompt } from '../util/node-operation-parsers.js';
 import { assertQueueItemOwner, assertSessionControlOwner } from './run-ownership-policy.js';
 export class WorkspaceQueueWorkbenchService {
@@ -118,12 +119,13 @@ export class WorkspaceQueueWorkbenchService {
         const item = this.requireItem(input.queueItemId, input.workspaceId);
         assertQueueItemOwner(item, input.__requestUserId);
         const content = input.content.trim();
-        this.options.runtime.updateQueueItem(item.id, content);
         const prepared = this.options.coordinator.pending(item.id);
-        if (prepared !== undefined) {
-            const runnerInput = withNonImageAttachmentPrompt(content, prepared.attachmentPaths, prepared.attachmentFiles);
-            this.options.coordinator.updatePreparedInput(item.id, this.options.prepareInput(prepared.runner, runnerInput, prepared.collaborationMode));
-        }
+        const runnerInput = prepared === undefined
+            ? undefined
+            : this.options.prepareInput(prepared.runner, withNonImageAttachmentPrompt(prepared.steering ? steerComposerMessage(content) : content, prepared.attachmentPaths, prepared.attachmentFiles), prepared.collaborationMode);
+        this.options.runtime.updateQueueItem(item.id, content);
+        if (runnerInput !== undefined)
+            this.options.coordinator.updatePreparedInput(item.id, runnerInput);
         this.options.emit(item.workspaceId, item.sessionId);
         return {
             queue: this.present(item.workspaceId, item.sessionId),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/node",
-  "version": "0.10.36",
+  "version": "0.10.38",
   "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.36",
+    "@myagentroam/agent": "0.10.38",
     "@myagentroam/code-navigation": "0.10.1",
-    "@myagentroam/marctl": "0.10.6",
-    "@myagentroam/protocol": "0.10.36"
+    "@myagentroam/marctl": "0.10.7",
+    "@myagentroam/protocol": "0.10.38"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"