@myagentroam/node 0.11.48 → 0.11.50

package/dist/application/node-lifecycle.js

@@ -98,7 +98,7 @@ export class NodeLifecycle {
             await this.shutdown.closeResume();
             if (failure === undefined && handoff) {
                 stage = 'capture';
-                snapshot = this.shutdown.capture();
+                snapshot = await this.shutdown.capture();
             }
         }
         catch (error) {

package/dist/application/node-operation-admission.js

@@ -23,7 +23,6 @@ export class NodeOperationAdmission {
         if (this.stopped())
             throw new Error('NODE_STOPPED');
         const input = isPlainRecord(data) ? data : {};
-        const sessionId = typeof input.sessionId === 'string' ? input.sessionId : undefined;
         if (this.restart.blocksOperation(operation, input))
             throw new Error('SESSION_RESTART_PENDING');
         if (!this.databaseAvailable())
@@ -34,12 +33,7 @@ export class NodeOperationAdmission {
         const task = this.git.execute(operation, data, (value) => this.router.execute(operation, value));
         this.inFlight.add(task);
         try {
-            const result = await task;
-            if ((operation === 'session.command.execute' || operation === 'session.message') &&
-                sessionId !== undefined &&
-                Number.isSafeInteger(input.__requestUserId))
-                this.restart.rememberUser(sessionId, input.__requestUserId);
-            return result;
+            return await task;
         }
         finally {
             this.inFlight.delete(task);

package/dist/connector.js

@@ -67,7 +67,7 @@ import { SessionScheduleService } from './session/session-schedule-service.js';
 import { ScheduledSessionCoordinator } from './service/scheduled-session-coordinator.js';
 import { ScheduledSessionStore } from './service/scheduled-session-store.js';
 import { RunAuthorizationControl } from './service/run-authorization-control.js';
-import { PlannedRestartHandoff } from './service/planned-restart-handoff.js';
+import { PlannedRestartHandoff, plannedRestartCaptureDiagnostic } from './service/planned-restart-handoff.js';
 import { NodeUpgradeCredentialControl } from './service/node-upgrade-credential-control.js';
 import { RestartSessionRestorer } from './service/restart-session-restorer.js';
 import { ScheduleMcpBridge } from './service/schedule-mcp-bridge.js';
@@ -159,7 +159,6 @@ export class NodeConnector {
     controlChannel;
     controlMessages;
     scheduledRunAuthorization;
-    restartAuthorization;
     restartHandoff;
     operationAdmission;
     executionLifecycle;
@@ -195,12 +194,18 @@ export class NodeConnector {
             await this.sessionMessageService.drain();
         },
         closeResume: () => this.externalSessionResumeService.close(),
-        capture: () => (this.config?.nodeId ? this.restartHandoff.capture() : undefined),
+        capture: async () => {
+            if (!this.config?.nodeId)
+                return;
+            await this.marAgentRuntimeModels.waitForPendingCredentials();
+            return this.restartHandoff.capture();
+        },
         dispose: () => this.disposeRuntime(),
         publish: (snapshot) => this.restartHandoff.publish(snapshot),
         diagnose: (stage, error) => nodeLog('node.shutdown.failed', {
             stage,
-            errorCode: safeErrorCode(error, 'NODE_SHUTDOWN_FAILED')
+            errorCode: safeErrorCode(error, 'NODE_SHUTDOWN_FAILED'),
+            ...(stage === 'capture' ? plannedRestartCaptureDiagnostic(error) : undefined)
         })
     });
     get stopped() {
@@ -1127,15 +1132,6 @@ export class NodeConnector {
             coordinator: this.continuousRunCoordinator,
             messages: this.sessionMessageService,
             resolve: (id) => this.externalSessionResumeService.resolveForMessage(id),
-            authorize: async (request) => {
-                const context = await this.restartAuthorization.authorize(request);
-                return {
-                    secretEnvironment: context.secretEnvironment,
-                    personalInstructions: context.personalInstructions,
-                    usageGrant: context.usageGrant,
-                    executionContext: this.runners.require(request.runner).prepareExecutionContext(context)
-                };
-            },
             inputState,
             withGrant: (context, work) => this.modelUsage.withGrant(context.usageGrant, work),
             publishGoal: (session, goal) => this.goalCoordinator.publishGoalState(session, goal),
@@ -1145,13 +1141,16 @@ export class NodeConnector {
         this.restartHandoff = new PlannedRestartHandoff({
             directory: () => nodeDataDirectory(this.config, this.configPath),
             identity: () => ({ nodeId: this.config.nodeId, serverUrl: this.config.serverUrl }),
+            credential: () => this.config.credential,
             runtime: this.runtime,
             coordinator: this.continuousRunCoordinator,
             goals: this.goalRuntime,
+            goalExecution: (id) => this.goalCoordinator.restartExecution(id),
+            executionContext: (id, context, modelId) => this.marAgentRunController.restartExecutionContext(id, context, modelId === undefined ? this.runtime.getAgentSession(id)?.modelId : modelId),
             commandActive: (id, command) => this.commandStates.get(id, command)?.active === true,
             inputState,
             restore: (entry, id) => restorer.restore(entry, id),
-            diagnose: (code, sessionId) => nodeLog('node.restart.diagnostic', { code, sessionId })
+            diagnose: (code, sessionId, errorCode) => nodeLog('node.restart.diagnostic', { code, sessionId, errorCode })
         });
         this.sessionCatalogService = new SessionCatalogService({
             resolveExecutionDirectory,
@@ -1292,7 +1291,6 @@ export class NodeConnector {
                 this.runtimeCredentials.disconnected();
                 this.chatgptLogins.close();
                 this.scheduledRunAuthorization.disconnected();
-                this.restartAuthorization.disconnected();
                 this.mailNotificationControl.disconnected();
                 this.marctlExecutionCredentials.disconnected();
                 this.upgradeCredentials.disconnect();
@@ -1352,8 +1350,7 @@ export class NodeConnector {
             handleNodeRequest: (envelope) => this.nodeRequests.handle(envelope),
             cancelNodeWait: (requestId) => this.nodeRequests.cancelWait(requestId),
             handleRuntimeCredentialResponse: (envelope) => this.runtimeCredentials.handle(envelope),
-            handleScheduledRunAuthorizeResponse: (envelope) => this.scheduledRunAuthorization.handle(envelope) ||
-                this.restartAuthorization.handle(envelope),
+            handleScheduledRunAuthorizeResponse: (envelope) => this.scheduledRunAuthorization.handle(envelope),
             handleMailNotificationResponse: (envelope) => this.mailNotificationControl.handle(envelope),
             handleMarctlExecutionCredentialResponse: (envelope) => this.marctlExecutionCredentials.handle(envelope),
             handleUpgradeCredentialResponse: (envelope) => this.upgradeCredentials.handle(envelope),
@@ -1451,7 +1448,6 @@ export class NodeConnector {
                 this.runtimeCredentials.connected();
                 this.scheduledRunAuthorization.connected();
                 this.scheduledSessions.connected();
-                this.restartAuthorization.connected();
                 if (!this.stopped)
                     void this.restartHandoff.recover();
                 this.mailNotificationControl.connected();
@@ -1465,7 +1461,6 @@ export class NodeConnector {
             return this.database;
         };
         this.scheduledRunAuthorization = new RunAuthorizationControl((envelope) => this.controlChannel.sendEnvelope(envelope));
-        this.restartAuthorization = new RunAuthorizationControl((envelope) => this.controlChannel.sendEnvelope(envelope), 'restart');
         this.scheduledSessions = new ScheduledSessionCoordinator({
             store: () => new ScheduledSessionStore(requireDatabase().raw),
             busy: (task) => this.stopped ||
@@ -1810,7 +1805,6 @@ export class NodeConnector {
         this.chatgptLogins.close();
         const scheduledDrain = this.scheduledSessions.stop();
         this.scheduledRunAuthorization.close();
-        this.restartAuthorization.close();
         this.mailNotificationControl.close();
         this.marctlExecutionCredentials.disconnected();
         this.upgradeCredentials.disconnect();

package/dist/marctl-guidance.js

@@ -6,7 +6,7 @@ export function hasMarctlContext(environment) {
         !!environment['MAR_CTL_WORKSPACE_ID']);
 }
 export const marctlManagementDescription = 'Use marctl to manage MAR Agent session settings (model, effort, title, persistent prompts, and schedules), discover authorized MAR Nodes, and execute commands or transfer files on those Nodes. Use native agent_* tools for other Agent lifecycle and collaboration operations.';
-const marctlSafety = 'Acceptance is not completion. If a request result is unknown, inspect history before retrying. Session IDs and parent relationships do not grant authorization.';
+const marctlSafety = 'If a request result is unknown, inspect history before retrying. Session IDs and parent relationships do not grant authorization.';
 export const marctlManagementInstructions = [
     '## MAR Workspace management',
     'Use native agent_* tools for Agent discovery, creation, communication, observation, waiting and stopping. Do not switch to marctl when a native operation fails.',
@@ -19,10 +19,12 @@ export const marctlDescription = 'Use marctl agents to create, send to, wait for
 export const marctlInstructions = [
     '## MAR Workspace CLI',
     'Run marctl from the shell. Commands use the authenticated Node and Workspace; marctl help agents, nodes, ssh or scp shows options.',
-    'Use agents start --title <title> -m <text> [--runner <runner>] [--model-id <id>] [--effort <effort>] [--goal <objective>]. An Agent must supply a nonblank title; a manual terminal may omit it. The default Runner is the current Session Runner; a terminal without a current Session must specify --runner or an explicit --parent. Start returns without waiting.',
-    'Use agents send <id> -m <text> [--steer|--queue], agents wait [<id>] [--wait-for message|completion] [--timeout <duration>], agents stop <id> --execution <execution-id>, agents list [--scope tree|active], and agents view <id> [--history]. Wait defaults to direct-child completion for 30 seconds; --timeout 0ms takes a snapshot. Stop clears the target Session Goal.',
-    'Prefer agents send <id> --steer -m <text> for timely communication or course correction. Use --queue only for deliberately deferred input: it is consumed after current work and earlier queued inputs finish, and with an active Goal it is not consumed until that Goal exits. Acceptance is not a guarantee of immediate processing.',
-    'Start and send accept repeated --image <local-path> for PNG, JPEG, GIF or WebP; limits are five images, 5 MiB each and 10 MiB total. Send can update a Goal alone with --goal <objective> or --clear-goal; omitted Goal leaves it unchanged. Decide a direct child approval with send <id> --approval <approval-id> --decision approve|reject.',
+    'Use agents start --title <title> -m <text> [--runner <runner>] [--model-id <id>] [--effort <effort>] [--goal <objective>]. An Agent must supply a nonblank title; a manual terminal may omit it. The default Runner is the current Session Runner; a terminal without a current Session must specify --runner or an explicit --parent. Start returns without waiting for completion.',
+    'Use agents send <id> -m <text> [--steer|--queue], agents wait [<id>] [--wait-for message|completion] [--timeout <duration>], agents stop <id> --execution <execution-id>, agents list [--scope tree|active], and agents view <id> [--history]. --timeout 0ms takes a snapshot. Stop clears the target Session Goal.',
+    'While children run, prefer advancing meaningful, non-overlapping task work rather than duplicating delegated work. Waiting is generally useful once no meaningful local task work remains and a required result is needed to unblock or finish the task.',
+    'Prefer agents send <id> --steer -m <text> for timely communication or course correction. --queue is best reserved for deferred input explicitly requested by the user or recipient: it is consumed after current work and earlier queued inputs finish, and with an active Goal it is not consumed until that Goal exits. Acceptance is not a guarantee of immediate processing.',
+    'An accepted message normally needs no separate acknowledgment. Requests for receipt-only replies and immediate agents view checks solely to confirm receipt are usually unnecessary.',
+    'Send can update a Goal alone with --goal <objective> or --clear-goal; omitted Goal leaves it unchanged. Decide an authorized Agent approval with send <id> --approval <approval-id> --decision approve|reject.',
     'List accepts only --scope tree|active, optional --query <title-fragment> and --limit <1..100> (default 100). With a current Session it defaults to the containing collaboration tree, including idle Sessions; without one it defaults to active Workspace Sessions (running or sleeping), and explicit tree is rejected. Returns currentAgentId (null without a Session), flat sessions with id, parentSessionId, title, runner and status, and truncated; no cursor or pagination. Reuse known IDs directly.',
     'Only direct-child updates are collected automatically. Sending to a non-child never subscribes; an explicit wait observes it only for that call.',
     'Use agents config, rename, prompt and schedule for management. marctl nodes, ssh and scp use authorized Nodes.',

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

@@ -1,3 +1,4 @@
+import { AgentError } from '@myagentroam/agent';
 import { agentNetworkWaitModelOutput } from './agent-network-wait-output.js';
 import { agentOperationEvent } from './agent-operation-presentation.js';
 const text = { type: 'string', minLength: 1 };
@@ -5,22 +6,6 @@ const runner = {
     ...text,
     description: 'Runner type (for example mar-agent), not a model name; defaults to the current Runner.'
 };
-const attachmentIds = {
-    type: 'array',
-    items: text,
-    maxItems: 32,
-    description: 'Existing composer attachment IDs.'
-};
-const attachments = {
-    type: 'array',
-    maxItems: 5,
-    items: {
-        type: 'object',
-        additionalProperties: false,
-        required: ['name', 'mime', 'dataBase64'],
-        properties: { name: text, mime: text, dataBase64: text }
-    }
-};
 const goal = {
     anyOf: [
         { type: 'null' },
@@ -38,15 +23,13 @@ const goal = {
         }
     ]
 };
-const deliveryGuidance = 'Default to STEER. Use QUEUE only when the user or recipient explicitly requests deferred delivery. Do not queue merely to avoid interrupting the recipient or because the message is a report.';
+const deliveryGuidance = 'STEER is the default and preferred for timely communication. QUEUE is best reserved for deferred delivery explicitly requested by the user or recipient, not merely to avoid interruption or send a report.';
 const tools = [
     {
         action: 'start',
-        description: 'Start a child Agent with a message or image and optional Goal; returns without waiting.',
+        description: 'Start a child Agent with a task and optional Goal; returns without waiting for completion.',
         properties: {
-            content: { type: 'string' },
-            attachments,
-            attachmentIds,
+            content: text,
             runner,
             modelId: {
                 ...text,
@@ -57,16 +40,14 @@ const tools = [
             goal,
             clientMessageId: text
         },
-        required: ['title']
+        required: ['title', 'content']
     },
     {
         action: 'send',
-        description: `Send input, decide an approval or update a Goal; goal:null leaves it unchanged, goal:{clear:true} clears it. ${deliveryGuidance} QUEUE is consumed only after current work and earlier queued inputs finish; an active Goal must exit first.`,
+        description: 'Send a message to an Agent, update its Goal, or decide an approval.',
         properties: {
             agentId: text,
             content: { type: 'string' },
-            attachments,
-            attachmentIds,
             goal,
             approval: {
                 type: 'object',
@@ -77,7 +58,7 @@ const tools = [
             delivery: {
                 type: 'string',
                 enum: ['STEER', 'QUEUE'],
-                description: deliveryGuidance
+                description: `${deliveryGuidance} QUEUE is consumed only after current work and earlier queued inputs finish; an active Goal must exit first.`
             },
             clientMessageId: text
         },
@@ -85,7 +66,7 @@ const tools = [
     },
     {
         action: 'wait',
-        description: 'Wait for completion or messages; defaults to direct children, completion and 30 seconds. Use waitMs 0 for a snapshot.',
+        description: 'Wait for Agent messages or execution completion.',
         properties: {
             agentId: text,
             agentIds: { type: 'array', items: text, minItems: 1, maxItems: 8 },
@@ -102,7 +83,7 @@ const tools = [
     },
     {
         action: 'list',
-        description: "List the current Session's collaboration tree by default, or active Workspace Sessions. Active includes running and sleeping. Reuse known Session IDs directly. Returns currentAgentId, flat sessions (id, parentSessionId, title, runner, status) and truncated; no pagination.",
+        description: 'List the current collaboration tree or active Agents in the Workspace.',
         properties: {
             scope: {
                 type: 'string',
@@ -119,7 +100,7 @@ const tools = [
     },
     {
         action: 'view',
-        description: 'View an Agent session, Goal and recent history.',
+        description: "View an Agent's state, Goal and public history.",
         properties: {
             agentId: text,
             includeHistory: { type: 'boolean' },
@@ -131,17 +112,20 @@ const tools = [
 ];
 const delegationPrompt = [
     '# Delegation and coordination',
-    'Delegate bounded, self-contained tasks when independent progress or context savings materially helps. Keep simple or tightly coupled work local.',
-    'Give each child an objective, necessary context, expected output, and a read-only boundary or non-overlapping write scope.',
-    'Follow up through the direct delegate by default; inspect deeper Sessions only when a concrete issue needs independent verification.',
-    'While children run, continue meaningful non-overlapping work. Do not redo delegated work. Wait only when the next step needs the result.',
+    'Prefer handling focused or tightly coupled work locally.',
+    'Consider delegating a clearly separable subtask when parallel progress or context savings materially outweigh coordination overhead.',
+    'Avoid splitting work merely because agents are available.',
+    'A useful handoff includes an objective, necessary context, expected output, and a read-only boundary or non-overlapping write scope.',
+    'Prefer following up through the direct delegate; deeper Session inspection is usually useful only when a concrete issue needs independent verification.',
+    'While children run, prefer advancing meaningful, non-overlapping task work rather than duplicating delegated work. Waiting is generally useful once no meaningful local task work remains and a required result is needed to unblock or finish the task.',
     'Verify consequential findings and changes. Join or stop task-required child work before final delivery, and retain responsibility for the final result.'
 ].join('\n\n');
 const collaborationPrompt = [
     '# Workspace collaboration',
-    "Use native agent_* tools to collaborate within the Agent Network when another Session's context or ongoing work materially helps. Keep requests focused and avoid unnecessary cross-Session coordination. Peer Sessions retain their own work and lifecycle; do not treat them as task-owned children or stop them merely for task cleanup. Explicitly wait when you need progress or completion.",
-    'Reuse known Session IDs rather than rediscovering them. Send updates only when requested or when the recipient needs to decide or change course; combine related updates and avoid acknowledgment-only exchanges.',
-    'For delegated work, do not provide routine progress updates or acknowledgments unless requested. Contact the parent before completion only when requested or for blockers, scope conflicts, or information that requires the parent to decide or change course. Return a concise final handoff; do not also send a duplicate completion message.'
+    "Use native agent_* tools to collaborate within the Agent Network when another Session's context or ongoing work materially helps. Prefer focused requests and avoid unnecessary cross-Session coordination. Peer Sessions retain their own work and lifecycle; do not treat them as task-owned children or stop them merely for task cleanup.",
+    'Prefer reusing known Session IDs rather than rediscovering them. Updates are most useful when requested or when the recipient needs to decide or change course; prefer combining related updates.',
+    'An accepted message normally needs no separate acknowledgment. Requests for receipt-only replies and immediate agent_view calls solely to confirm receipt are usually unnecessary.',
+    'For delegated work, prefer a concise final handoff over routine progress reports or duplicate completion messages. Early contact is most useful for requested updates, blockers, scope conflicts, or information needed for a decision.'
 ].join('\n\n');
 const managementPrompt = [
     '# Workspace management',
@@ -152,6 +136,15 @@ export function agentNetworkExtension(invoke, currentExecution) {
         id: 'mar.node.agent-network',
         apiVersion: '1.0',
         attachSession(context) {
+            // Reject retired input before generic unknown-field normalization can discard it.
+            context.hooks.intercept('tool.invoke', (input, _call, next) => {
+                if ((input.name === 'agent_start' || input.name === 'agent_send') &&
+                    input.arguments !== null &&
+                    typeof input.arguments === 'object' &&
+                    ('attachments' in input.arguments || 'attachmentIds' in input.arguments))
+                    throw new AgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Agent collaboration accepts text input only.');
+                return next(input);
+            }, { reentry: 'allow' });
             context.hooks.intercept('prompt.sections', (input, _call, next) => {
                 const available = new Set(input.facts?.tools);
                 const enabled = input.facts?.mode !== 'compact';
@@ -224,9 +217,7 @@ export function agentNetworkExtension(invoke, currentExecution) {
                         let operationInput = args;
                         if (tool.action === 'send') {
                             const { delivery, ...sendInput } = args;
-                            const hasMessage = (typeof args.content === 'string' && !!args.content.trim()) ||
-                                (Array.isArray(args.attachments) && args.attachments.length > 0) ||
-                                (Array.isArray(args.attachmentIds) && args.attachmentIds.length > 0);
+                            const hasMessage = typeof args.content === 'string' && !!args.content.trim();
                             operationInput =
                                 delivery !== undefined || hasMessage
                                     ? {

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

@@ -15,6 +15,7 @@ import { MarAgentConversationNormalizer, normalizeMarAgentUsage } from './conver
 import { parseRunnerImageAttachments } from '../../session/attachments.js';
 import { runnerErrorProjection } from '../runner-error.js';
 import { MarAgentRuntimeModelFactory, sdkModelConfigurations, closeImageCredentialProviders } from './runtime-model-factory.js';
+import { snapshotRuntimeModel } from './runtime-model-factory.js';
 import { createImageGenerationExtensions } from './image-generation-extensions.js';
 import { createWebToolsExtensions } from './web-tools-extensions.js';
 import { combineExecutionExtensions } from './execution-extensions.js';
@@ -94,6 +95,43 @@ export class MarAgentManagedRunController {
     releaseSession(sessionId) {
         return this.#runtimes.releaseSession(sessionId);
     }
+    restartExecutionContext(sessionId, context, selectedModelId) {
+        const runtime = this.#runtimes.findRuntime(sessionId);
+        const input = marAgentEnvelopeInput(context);
+        if (runtime === undefined || typeof input?.runtimeScopeId !== 'string')
+            return context;
+        const scope = input.runtimeScopeId;
+        const snapshots = new Map(runtime.models.flatMap((model) => {
+            const snapshot = snapshotRuntimeModel(model, scope);
+            return snapshot === undefined ? [] : [[model.id, snapshot]];
+        }));
+        if (snapshots.size === 0)
+            return context;
+        const refresh = (value) => {
+            if (value === null || typeof value !== 'object' || !('id' in value))
+                return value;
+            return typeof value.id === 'string' ? (snapshots.get(value.id) ?? value) : value;
+        };
+        const models = Array.isArray(input.models) ? input.models.map(refresh) : input.models;
+        const selected = Array.isArray(models)
+            ? models.find((model) => model !== null &&
+                typeof model === 'object' &&
+                'id' in model &&
+                model.id === selectedModelId)
+            : undefined;
+        const compact = input.compact;
+        return {
+            runner: 'mar-agent',
+            runnerInput: {
+                ...input,
+                model: selected ?? refresh(input.model),
+                models,
+                compact: compact !== null && typeof compact === 'object' && 'model' in compact
+                    ? { ...compact, model: refresh(compact.model) }
+                    : compact
+            }
+        };
+    }
     async executeCommand(session, command, input, context) {
         if (command.id === 'plan') {
             const current = this.host.commandState(session.id, 'plan');

package/dist/runner/mar-agent/runtime-model-factory.js

@@ -21,14 +21,42 @@ class PendingCredentialResolution {
         this.initialReason = initialReason;
     }
 }
+const restartConfigurations = new WeakMap();
+export function snapshotRuntimeModel(model, scope) {
+    const state = restartConfigurations.get(model);
+    if (state === undefined || state.scope !== scope)
+        return;
+    const configuration = structuredClone(state.configuration);
+    for (const credential of [configuration.credential, configuration.imageGeneration?.credential]) {
+        if (credential?.type !== 'RUNTIME_TICKET')
+            continue;
+        const key = `${credential.credentialId}\0${credential.ticket.runtimeScopeId}\0${credential.ticket.purpose ?? 'MODEL'}`;
+        const current = state.tickets.get(key);
+        if (current === undefined || current.released)
+            return;
+        credential.ticket = structuredClone(current.ticket);
+    }
+    return configuration;
+}
 const CREDENTIAL_REFRESH_WINDOW_MS = 60_000;
 const CREDENTIAL_REFRESH_RETRY_MS = 30_000;
 export class MarAgentRuntimeModelFactory {
-    control;
     now;
+    control;
+    pendingCredentials = new Set();
     constructor(control, now = Date.now) {
-        this.control = control;
         this.now = now;
+        this.control = {
+            resolve: (...args) => {
+                const pending = control.resolve(...args);
+                this.pendingCredentials.add(pending);
+                void pending.then(() => this.pendingCredentials.delete(pending), () => this.pendingCredentials.delete(pending));
+                return pending;
+            }
+        };
+    }
+    async waitForPendingCredentials() {
+        await Promise.allSettled([...this.pendingCredentials]);
     }
     create(configurations, context) {
         const tickets = new Map();
@@ -36,6 +64,14 @@ export class MarAgentRuntimeModelFactory {
         try {
             return configurations.map((raw) => {
                 const configuration = marAgentRuntimeModelConfigurationSchema.parse(raw);
+                const remember = (model) => {
+                    restartConfigurations.set(model, {
+                        configuration,
+                        scope: context.runtimeScopeId,
+                        tickets
+                    });
+                    return model;
+                };
                 const imageGeneration = configuration.imageGeneration === undefined ||
                     configuration.imageGeneration.credential === undefined
                     ? undefined
@@ -89,10 +125,10 @@ export class MarAgentRuntimeModelFactory {
                 };
                 const { credential } = configuration;
                 if (credential.type === 'INLINE_API_KEY')
-                    return {
+                    return remember({
                         ...model,
                         apiKey: new SecretValue(credential.value)
-                    };
+                    });
                 if (credential?.type !== 'RUNTIME_TICKET')
                     throw new AgentError('MAR_AGENT_RUNTIME_MODEL_CREDENTIAL_INVALID', 'The runtime model credential is invalid.');
                 if (context.runtimeScopeId === undefined ||
@@ -100,7 +136,7 @@ export class MarAgentRuntimeModelFactory {
                     !credential.ticket.allowedModelIds.includes(configuration.id))
                     throw new AgentError('MAR_AGENT_RUNTIME_CREDENTIAL_SCOPE_INVALID', 'The runtime credential does not authorize this execution or model.');
                 const provider = runtimeProvider(credential, configuration.id, context, tickets, providers, this.control, this.now);
-                return {
+                return remember({
                     ...model,
                     ...(configuration.imageGeneration !== undefined &&
                         configuration.imageGeneration.credential === undefined
@@ -117,7 +153,7 @@ export class MarAgentRuntimeModelFactory {
                         }
                         : {}),
                     credentialProvider: provider
-                };
+                });
             });
         }
         catch (error) {

package/dist/service/agent-network-bindings.js

@@ -221,9 +221,7 @@ export function createNodeAgentNetwork(options) {
                 ...(!terminal && parent ? { __marctlOrigin: origin(parent) } : {}),
                 ...(input.title === undefined ? {} : { title: input.title }),
                 ...(model ? { modelId: model } : {}),
-                ...(input.effort === undefined ? {} : { effort: input.effort }),
-                ...(input.attachments === undefined ? {} : { attachments: input.attachments }),
-                ...(input.attachmentIds === undefined ? {} : { attachmentIds: input.attachmentIds })
+                ...(input.effort === undefined ? {} : { effort: input.effort })
             };
             signal?.throwIfAborted();
             const result = await options.withGrant(actor, () => input.goal.kind === 'set'
@@ -236,10 +234,6 @@ export function createNodeAgentNetwork(options) {
                     suppressNotifications: true,
                     ...(!terminal && parent ? { messageOrigin: origin(parent) } : {}),
                     clientMessageId: input.clientMessageId,
-                    ...(input.attachments === undefined ? {} : { attachments: input.attachments }),
-                    ...(input.attachmentIds === undefined
-                        ? {}
-                        : { attachmentIds: input.attachmentIds }),
                     ...(actor.requestUserId === undefined
                         ? {}
                         : { initiatedByUserId: actor.requestUserId }),
@@ -287,11 +281,7 @@ export function createNodeAgentNetwork(options) {
                     : {
                         messageContent: message.content,
                         clientMessageId: message.clientMessageId,
-                        messageIntent: message.deliveryIntent,
-                        ...(message.attachments === undefined ? {} : { attachments: message.attachments }),
-                        ...(message.attachmentIds === undefined
-                            ? {}
-                            : { attachmentIds: message.attachmentIds })
+                        messageIntent: message.deliveryIntent
                     })
             }));
             return publicReceipt(result);

package/dist/service/agent-network-service.js

@@ -20,12 +20,9 @@ export class AgentNetworkService {
         const goal = parseAgentGoal(input.goal);
         const content = input.content ?? '';
         if (typeof content !== 'string' ||
-            (!content.trim() && !input.attachments?.length && !input.attachmentIds?.length) ||
-            (input.attachments !== undefined && !Array.isArray(input.attachments)) ||
-            (input.attachmentIds !== undefined &&
-                (!Array.isArray(input.attachmentIds) ||
-                    input.attachmentIds.some((id) => typeof id !== 'string' || !id))) ||
-            (!!input.attachments?.length && !!input.attachmentIds?.length) ||
+            !content.trim() ||
+            'attachments' in input ||
+            'attachmentIds' in input ||
             !validOptionalString(input.runner) ||
             'model' in input ||
             !validOptionalString(input.modelId) ||
@@ -62,16 +59,9 @@ export class AgentNetworkService {
         if (typeof input.agentId !== 'string' ||
             !input.agentId ||
             typeof content !== 'string' ||
-            (!content.trim() &&
-                !input.attachments?.length &&
-                !input.attachmentIds?.length &&
-                goal.kind === 'unchanged' &&
-                input.approval === undefined) ||
-            (input.attachments !== undefined && !Array.isArray(input.attachments)) ||
-            (input.attachmentIds !== undefined &&
-                (!Array.isArray(input.attachmentIds) ||
-                    input.attachmentIds.some((id) => typeof id !== 'string' || !id))) ||
-            (!!input.attachments?.length && !!input.attachmentIds?.length) ||
+            (!content.trim() && goal.kind === 'unchanged' && input.approval === undefined) ||
+            'attachments' in input ||
+            'attachmentIds' in input ||
             !validOptionalString(input.clientMessageId) ||
             (input.approval !== undefined &&
                 (!isPlainRecord(input.approval) ||
@@ -83,7 +73,7 @@ export class AgentNetworkService {
         if (input.deliveryIntent !== undefined &&
             !['SEND', 'QUEUE', 'REPLACE_CURRENT'].includes(input.deliveryIntent))
             throw new Error('AGENT_SEND_INVALID');
-        const hasMessage = !!content.trim() || !!input.attachments?.length || !!input.attachmentIds?.length;
+        const hasMessage = !!content.trim();
         const session = await this.options.target(actor, input.agentId);
         signal?.throwIfAborted();
         if (hasMessage)
@@ -122,9 +112,7 @@ export class AgentNetworkService {
             ? {
                 clientMessageId: input.clientMessageId ?? randomUUID(),
                 content,
-                deliveryIntent: input.deliveryIntent ?? 'SEND',
-                ...(input.attachments === undefined ? {} : { attachments: input.attachments }),
-                ...(input.attachmentIds === undefined ? {} : { attachmentIds: input.attachmentIds })
+                deliveryIntent: input.deliveryIntent ?? 'SEND'
             }
             : undefined;
         let goalResult;

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

@@ -580,6 +580,9 @@ export class ContinuousRunCoordinator {
             return;
         }
         let executionId = this.options.runtime.currentExecutionId(active.id);
+        // Immediate commands own a root Runner handle without a normal message Execution.
+        if (executionId === undefined && this.options.runtime.isExecutionActive(active.id))
+            return;
         if (executionId !== undefined && this.dispatchedExecutions.has(executionId))
             return;
         let pending = executionId === undefined

package/dist/service/goal-continuation-coordinator.js

@@ -4,6 +4,7 @@ import { isPlainRecord } from '../util/records.js';
 import { safeErrorCode } from '../util/safe-error.js';
 import { NODE_MCP } from '../mcp/naming.js';
 import { composerResourceInputTags } from './composer-message-input.js';
+import { captureRestartExecution } from './restart-execution-state.js';
 /** Owns transient Goal orchestration, not the domain state or execution queue. */
 export class GoalContinuationCoordinator {
     options;
@@ -47,6 +48,10 @@ export class GoalContinuationCoordinator {
     freeze() {
         this.frozen = true;
     }
+    restartExecution(sessionId) {
+        const retry = this.goalRetryTimers.get(sessionId);
+        return captureRestartExecution(retry?.context, retry?.initiatedByUserId);
+    }
     dispose() {
         this.frozen = true;
         this.disposed = true;
@@ -107,6 +112,9 @@ export class GoalContinuationCoordinator {
         const continuationEpoch = this.continuationEpoch(pending.sessionId);
         const retry = {
             sessionId: pending.sessionId,
+            context: pending,
+            initiatedByUserId: this.options.runtime.activeSessionRun(pending.sessionId)
+                ?.initiatedByUserId,
             timer: setTimeout(() => {
                 this.goalRetryTimers.delete(retry.sessionId);
                 void this.enqueueGoalContinuation({
@@ -497,6 +505,8 @@ export class GoalContinuationCoordinator {
                 clearTimeout(previousRetry.timer);
             const retry = {
                 sessionId: attempt.sessionId,
+                context: input,
+                initiatedByUserId: input.initiatedByUserId,
                 timer: setTimeout(() => {
                     if (!this.goalGenerationCurrent(retry.sessionId, generation))
                         return;

package/dist/service/planned-restart-handoff.js

@@ -3,6 +3,8 @@ import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
 import { resolve } from 'node:path';
 import { z } from 'zod';
 import { parseComposerTags } from '@myagentroam/protocol';
+import { safeErrorCode } from '../util/safe-error.js';
+import { captureRestartExecution, openRestartState, restartExecutionSchema, sealRestartState } from './restart-execution-state.js';
 const identifier = z.string().min(1).max(512);
 const count = z.number().int().nonnegative();
 const attachmentSchema = z
@@ -18,7 +20,7 @@ const messageSchema = z
     clientMessageId: identifier,
     content: z.string().max(1_000_000),
     attachments: z.array(attachmentSchema).max(5),
-    initiatedByUserId: z.number().int().positive(),
+    execution: restartExecutionSchema.optional(),
     immediate: z.boolean(),
     suppressNotifications: z.boolean().optional()
 })
@@ -56,7 +58,7 @@ const sessionSchema = z
         access: z.string().nullable()
     })
         .strict(),
-    ownerUserId: z.number().int().positive(),
+    execution: restartExecutionSchema.optional(),
     paused: z.boolean(),
     plan: z.boolean(),
     awaitingGoal: z.boolean(),
@@ -68,7 +70,7 @@ const sessionSchema = z
     .strict();
 export const plannedRestartSchema = z
     .object({
-    schemaVersion: z.literal(2),
+    schemaVersion: z.literal(3),
     id: identifier,
     nodeId: identifier,
     serverUrl: z.string().min(1),
@@ -76,14 +78,44 @@ export const plannedRestartSchema = z
     sessions: z.array(sessionSchema)
 })
     .strict();
-const legacyPlannedRestartSchema = plannedRestartSchema.extend({
-    schemaVersion: z.literal(1),
-    sessions: z.array(sessionSchema.extend({
-        session: sessionSchema.shape.session.omit({ modelId: true }).extend({
-            model: z.string().nullable()
-        })
-    }))
-});
+// Only this producer can associate log-safe metadata with an original failure.
+const captureDiagnostics = new WeakMap();
+const captureFields = new Set([
+    ...Object.keys(plannedRestartSchema.shape),
+    ...Object.keys(sessionSchema.shape),
+    ...Object.keys(sessionSchema.shape.session.shape),
+    ...Object.keys(goalSchema.shape),
+    ...Object.keys(goalSchema.shape.goal.shape),
+    ...Object.keys(messageSchema.shape),
+    ...Object.keys(attachmentSchema.shape)
+]);
+export function plannedRestartCaptureDiagnostic(error) {
+    return error instanceof Error ? captureDiagnostics.get(error) : undefined;
+}
+function parseCapture(schema, input, reason) {
+    const result = schema.safeParse(input);
+    if (result.success)
+        return result.data;
+    captureDiagnostics.set(result.error, {
+        reason,
+        issues: result.error.issues.slice(0, 12).map((issue) => ({
+            code: issue.code,
+            // Only schema-owned fields and array offsets, never unknown keys or input values.
+            path: issue.path
+                .slice(0, 8)
+                .map((part) => typeof part === 'number'
+                ? `[${part}]`
+                : captureFields.has(String(part))
+                    ? String(part)
+                    : '*')
+                .join('.')
+                .replaceAll('.[', '[')
+                .slice(0, 160)
+        })),
+        issuesTruncated: result.error.issues.length > 12
+    });
+    throw result.error;
+}
 export const RESTART_NOTICE = 'The previous execution was interrupted by a system restart. Check the session history and current workspace, then continue unfinished work. Verify completed or uncertain actions before proceeding; do not blindly repeat actions with external side effects.';
 /** A one-shot orderly-shutdown handoff, not a crash-recovery journal. */
 export class PlannedRestartHandoff {
@@ -91,7 +123,6 @@ export class PlannedRestartHandoff {
     pending;
     blocked = new Set();
     recovery;
-    owners = new Map();
     constructor(options) {
         this.options = options;
     }
@@ -120,9 +151,6 @@ export class PlannedRestartHandoff {
                 'session.metadata.update'
             ].includes(operation));
     }
-    rememberUser(sessionId, userId) {
-        this.owners.set(sessionId, userId);
-    }
     async load() {
         this.recovery = undefined;
         this.pending = undefined;
@@ -137,18 +165,7 @@ export class PlannedRestartHandoff {
             return;
         }
         try {
-            const saved = JSON.parse(text);
-            const legacy = legacyPlannedRestartSchema.safeParse(saved);
-            const value = plannedRestartSchema.parse(legacy.success
-                ? {
-                    ...legacy.data,
-                    schemaVersion: 2,
-                    sessions: legacy.data.sessions.map((entry) => {
-                        const { model, ...session } = entry.session;
-                        return { ...entry, session: { ...session, modelId: model } };
-                    })
-                }
-                : saved);
+            const value = plannedRestartSchema.parse(openRestartState(text, this.options.credential()));
             const identity = this.options.identity();
             if (value.nodeId !== identity.nodeId || value.serverUrl !== identity.serverUrl)
                 throw new Error('RESTART_HANDOFF_IDENTITY_MISMATCH');
@@ -174,12 +191,23 @@ export class PlannedRestartHandoff {
             const awaitingGoal = goal === undefined && this.options.commandActive(session.id, 'goal');
             const currentId = active && (runtime.currentExecutionId(active.id) ?? active.id);
             const pending = currentId === undefined ? undefined : coordinator.pending(currentId);
-            const toMessage = (id, clientMessageId, content, attachments, owner, suppressNotifications) => ({
+            const checkpoint = (execution, activeInput = false) => {
+                if (execution !== undefined && activeInput)
+                    execution.configuration = {
+                        modelId: session.modelId,
+                        effort: session.effort,
+                        access: session.access
+                    };
+                if (execution !== undefined && this.options.executionContext !== undefined)
+                    execution.executionContext = this.options.executionContext(session.id, execution.executionContext, execution.configuration?.modelId);
+                return execution;
+            };
+            const toMessage = (id, clientMessageId, content, attachments, originatingUser, suppressNotifications, activeInput = false) => ({
                 id,
                 clientMessageId,
                 content: withoutAttachmentTags(content),
                 attachments,
-                initiatedByUserId: owner,
+                execution: checkpoint(captureRestartExecution(coordinator.pending(id), originatingUser), activeInput),
                 immediate: coordinator.isImmediate(id),
                 ...(suppressNotifications === true ? { suppressNotifications: true } : {})
             });
@@ -194,16 +222,20 @@ export class PlannedRestartHandoff {
             });
             const current = pending?.restartMessage === undefined || pending.goal !== undefined
                 ? undefined
-                : toMessage(currentId, pending.clientMessageId ?? active.clientMessageId, pending.restartMessage.content, [...pending.restartMessage.attachments], pending.restartMessage.initiatedByUserId ?? active?.initiatedByUserId, active?.suppressNotifications);
+                : toMessage(currentId, pending.clientMessageId ?? active.clientMessageId, pending.restartMessage.content, [...pending.restartMessage.attachments], pending.restartMessage.initiatedByUserId ?? active?.initiatedByUserId, active?.suppressNotifications, true);
             if (current === undefined && items.length === 0 && goal === undefined && !awaitingGoal)
                 continue;
-            if (session.externalSessionId === null)
-                throw new Error('RESTART_SESSION_NOT_READY');
-            const ownerUserId = active?.initiatedByUserId ??
-                items[0]?.initiatedByUserId ??
-                this.owners.get(session.id) ??
-                runtime.listRunsForSession(session.id).find((run) => run.initiatedByUserId !== undefined)
-                    ?.initiatedByUserId;
+            if (session.externalSessionId === null) {
+                const error = Object.assign(new Error('RESTART_SESSION_NOT_READY'), {
+                    code: 'RESTART_SESSION_NOT_READY'
+                });
+                captureDiagnostics.set(error, { reason: 'session_not_ready' });
+                throw error;
+            }
+            const goalItem = goalItemId === undefined ? undefined : runtime.getQueueItem(goalItemId);
+            const execution = captureRestartExecution(goalItem === undefined ? undefined : coordinator.pending(goalItem.id), goalItem?.initiatedByUserId) ??
+                captureRestartExecution(pending, active?.initiatedByUserId) ??
+                this.options.goalExecution?.(session.id);
             sessions.push({
                 session: {
                     id: session.externalSessionId,
@@ -213,25 +245,29 @@ export class PlannedRestartHandoff {
                     effort: session.effort,
                     access: session.access
                 },
-                ownerUserId: ownerUserId,
+                ...(execution === undefined
+                    ? {}
+                    : { execution: checkpoint(execution, goalItem === undefined) }),
                 paused: queue.paused,
                 plan: this.options.commandActive(session.id, 'plan'),
                 awaitingGoal,
                 ...(notificationSource?.suppressNotifications === true
                     ? { suppressNotifications: true }
                     : {}),
-                ...(goal === undefined ? {} : { goal: goalSchema.parse(goal) }),
+                ...(goal === undefined
+                    ? {}
+                    : { goal: parseCapture(goalSchema, goal, 'goal_schema_invalid') }),
                 ...(current === undefined ? {} : { current }),
                 queue: items
             });
         }
-        return plannedRestartSchema.parse({
-            schemaVersion: 2,
+        return parseCapture(plannedRestartSchema, {
+            schemaVersion: 3,
             id: randomUUID(),
             ...this.options.identity(),
             createdAt: Date.now(),
             sessions
-        });
+        }, 'snapshot_schema_invalid');
     }
     async publish(snapshot) {
         for (const entry of snapshot.sessions) {
@@ -251,7 +287,7 @@ export class PlannedRestartHandoff {
         const temporary = `${this.path()}.${process.pid}.tmp`;
         await mkdir(this.options.directory(), { recursive: true, mode: 0o700 });
         try {
-            await writeFile(temporary, JSON.stringify(plannedRestartSchema.parse(snapshot)), {
+            await writeFile(temporary, sealRestartState(plannedRestartSchema.parse(snapshot), this.options.credential()), {
                 mode: 0o600
             });
             await rename(temporary, this.path());
@@ -276,12 +312,12 @@ export class PlannedRestartHandoff {
             await rename(this.path(), this.path(true));
             for (const entry of value.sessions) {
                 try {
-                    this.rememberUser(entry.session.id, entry.ownerUserId);
                     await this.options.restore(entry, value.id);
                 }
-                catch {
+                catch (error) {
                     failed = true;
-                    this.options.diagnose('RESTART_SESSION_RESTORE_FAILED', entry.session.id);
+                    const errorCode = safeErrorCode(error, 'RESTART_SESSION_RESTORE_FAILED');
+                    this.options.diagnose('RESTART_SESSION_RESTORE_FAILED', entry.session.id, errorCode === 'RESTART_SESSION_RESTORE_FAILED' ? undefined : errorCode);
                 }
                 finally {
                     this.blocked.delete(entry.session.id);

package/dist/service/restart-execution-state.js

@@ -0,0 +1,77 @@
+import { createCipheriv, createDecipheriv, createHash, randomBytes } from 'node:crypto';
+import { modelUsageGrantSchema } from '@myagentroam/protocol';
+import { z } from 'zod';
+export const restartExecutionSchema = z
+    .object({
+    configuration: z
+        .object({
+        modelId: z.string().nullable(),
+        effort: z.string().nullable(),
+        access: z.string().nullable()
+    })
+        .strict()
+        .optional(),
+    executionContext: z
+        .object({ runner: z.literal('mar-agent'), runnerInput: z.unknown().optional() })
+        .strict(),
+    secretEnvironment: z.record(z.string(), z.string()),
+    personalInstructions: z.string().optional(),
+    usageGrant: z
+        .custom((value) => modelUsageGrantSchema.safeParse(value).success)
+        .optional(),
+    initiatedByUserId: z.number().int().positive().optional()
+})
+    .strict();
+export function captureRestartExecution(input, initiatedByUserId) {
+    if (input === undefined)
+        return;
+    return restartExecutionSchema.parse({
+        ...(input.modelId === undefined || input.effort === undefined || input.access === undefined
+            ? {}
+            : { configuration: { modelId: input.modelId, effort: input.effort, access: input.access } }),
+        executionContext: structuredClone(input.executionContext),
+        secretEnvironment: { ...input.secretEnvironment },
+        ...(input.personalInstructions === undefined
+            ? {}
+            : { personalInstructions: input.personalInstructions }),
+        ...(input.usageGrant === undefined ? {} : { usageGrant: { ...input.usageGrant } }),
+        ...(initiatedByUserId === undefined ? {} : { initiatedByUserId })
+    });
+}
+const sealedSchema = z
+    .object({
+    format: z.literal('mar-node-restart'),
+    version: z.literal(1),
+    nonce: z.string().length(16),
+    tag: z.string().length(24),
+    ciphertext: z.string().min(1)
+})
+    .strict();
+function encryptionKey(credential) {
+    if (!credential)
+        throw new Error('RESTART_HANDOFF_KEY_UNAVAILABLE');
+    return createHash('sha256').update('mar-node:orderly-restart:v1\0').update(credential).digest();
+}
+/** The existing local Node credential protects this one-shot execution checkpoint. */
+export function sealRestartState(value, credential) {
+    const nonce = randomBytes(12);
+    const cipher = createCipheriv('aes-256-gcm', encryptionKey(credential), nonce);
+    const ciphertext = Buffer.concat([cipher.update(JSON.stringify(value), 'utf8'), cipher.final()]);
+    return JSON.stringify({
+        format: 'mar-node-restart',
+        version: 1,
+        nonce: nonce.toString('base64'),
+        tag: cipher.getAuthTag().toString('base64'),
+        ciphertext: ciphertext.toString('base64')
+    });
+}
+export function openRestartState(text, credential) {
+    const sealed = sealedSchema.parse(JSON.parse(text));
+    const decipher = createDecipheriv('aes-256-gcm', encryptionKey(credential), Buffer.from(sealed.nonce, 'base64'));
+    decipher.setAuthTag(Buffer.from(sealed.tag, 'base64'));
+    const plaintext = Buffer.concat([
+        decipher.update(Buffer.from(sealed.ciphertext, 'base64')),
+        decipher.final()
+    ]);
+    return JSON.parse(plaintext.toString('utf8'));
+}

package/dist/service/restart-session-restorer.js

@@ -1,6 +1,7 @@
 import { parseComposerTags, serializeComposerTag } from '@myagentroam/protocol';
 import { parseMessageAttachments } from '../session/attachments.js';
 import { RUNNER_EXECUTION_CONTEXT } from '../runner/execution-context.js';
+import { resolvedPersonalInstructions } from '../runner/personal-instructions.js';
 import { RESTART_NOTICE } from './planned-restart-handoff.js';
 /** Rebuild inputs through the existing preparation and FIFO boundary. */
 export class RestartSessionRestorer {
@@ -9,24 +10,24 @@ export class RestartSessionRestorer {
         this.options = options;
     }
     async restore(entry, handoffId) {
-        const contexts = new Map();
-        const authorize = async (ownerUserId) => {
-            if (!contexts.has(ownerUserId))
-                contexts.set(ownerUserId, await this.options.authorize({
-                    handoffId,
-                    sessionId: entry.session.id,
-                    workspaceId: entry.session.workspaceId,
-                    ownerUserId,
-                    runner: 'mar-agent',
-                    modelId: entry.session.modelId
-                }));
-            return contexts.get(ownerUserId);
+        const execution = (context) => {
+            if (context === undefined)
+                throw new Error('RESTART_EXECUTION_CONTEXT_UNAVAILABLE');
+            return context;
         };
-        await authorize(entry.ownerUserId);
-        for (const input of [...entry.queue, ...(entry.current ? [entry.current] : [])]) {
+        const current = entry.current &&
+            entry.goal?.goal.status !== 'active' &&
+            !entry.queue.some((item) => item.immediate)
+            ? entry.current
+            : undefined;
+        const currentState = current && (await this.options.inputState(entry, current));
+        const inputs = [...entry.queue, ...(current && currentState !== 'completed' ? [current] : [])];
+        for (const input of inputs)
             parseMessageAttachments(input.attachments);
-            await authorize(input.initiatedByUserId);
-        }
+        for (const input of inputs)
+            execution(input.execution);
+        if (entry.goal?.goal.status === 'active')
+            execution(entry.execution);
         let session = await this.options.resolve(entry.session.id);
         if (session.runner !== 'mar-agent' ||
             session.workspaceId !== entry.session.workspaceId ||
@@ -66,7 +67,7 @@ export class RestartSessionRestorer {
                 closeInput: '/goal --clear'
             });
         const submit = async (input, content = input.content) => {
-            const context = contexts.get(input.initiatedByUserId);
+            const context = execution(input.execution);
             await this.options.withGrant(context, () => this.options.messages.restoreQueued({
                 sessionId: session.id,
                 content,
@@ -76,28 +77,31 @@ export class RestartSessionRestorer {
                     : {}),
                 attachments: input.attachments,
                 __queueItemId: input.id,
-                __requestUserId: input.initiatedByUserId,
+                ...(context.initiatedByUserId === undefined
+                    ? {}
+                    : { __requestUserId: context.initiatedByUserId }),
                 __suppressNotifications: input.suppressNotifications === true,
                 secretEnvironment: context.secretEnvironment,
-                personalInstructions: context.personalInstructions,
+                ...(context.personalInstructions === undefined
+                    ? {}
+                    : {
+                        personalInstructions: resolvedPersonalInstructions(context.personalInstructions)
+                    }),
                 [RUNNER_EXECUTION_CONTEXT]: context.executionContext,
                 __usageGrant: context.usageGrant
-            }));
+            }, context.configuration));
             if (input.immediate)
                 coordinator.restoreImmediate(input.id);
         };
         try {
-            if (entry.current &&
-                entry.goal?.goal.status !== 'active' &&
-                !entry.queue.some((item) => item.immediate)) {
-                const state = await this.options.inputState(entry, entry.current);
-                if (state === 'paused')
+            if (current) {
+                if (currentState === 'paused')
                     entry.paused = true;
-                if (state === 'missing')
-                    await submit(entry.current);
-                else if (state !== 'completed')
+                if (currentState === 'missing')
+                    await submit(current);
+                else if (currentState !== 'completed')
                     await submit({
-                        ...entry.current,
+                        ...current,
                         id: `restart:${handoffId}:${session.id}`,
                         clientMessageId: `restart:${handoffId}:${session.id}`,
                         attachments: []
@@ -106,7 +110,7 @@ export class RestartSessionRestorer {
             for (const input of entry.queue)
                 await submit(input);
             if (entry.goal?.goal.status === 'active') {
-                const context = contexts.get(entry.ownerUserId);
+                const context = execution(entry.execution);
                 await this.options.withGrant(context, () => this.options.messages.submitGoal({
                     sessionId: session.id,
                     kind: 'continue',
@@ -114,10 +118,15 @@ export class RestartSessionRestorer {
                     content: `${goals.prompt(session.id, 'continue')}
 ${RESTART_NOTICE}`,
                     goal: this.options.goalReference(session.id),
-                    initiatedByUserId: entry.ownerUserId,
+                    ...(context.initiatedByUserId === undefined
+                        ? {}
+                        : { initiatedByUserId: context.initiatedByUserId }),
                     suppressNotifications: entry.suppressNotifications === true,
                     secretEnvironment: context.secretEnvironment,
                     restoreQueued: true,
+                    ...(context.configuration === undefined
+                        ? {}
+                        : { restartConfiguration: context.configuration }),
                     ...(context.usageGrant === undefined ? {} : { usageGrant: context.usageGrant }),
                     ...(typeof context.personalInstructions === 'string'
                         ? { personalInstructions: context.personalInstructions }

package/dist/service/run-authorization-control.js

@@ -1,17 +1,15 @@
-import { createEnvelope, scheduledRunAuthorizeRequestSchema, scheduledRunAuthorizeResponseSchema, restartRunAuthorizeRequestSchema } from '@myagentroam/protocol';
+import { createEnvelope, scheduledRunAuthorizeRequestSchema, scheduledRunAuthorizeResponseSchema } from '@myagentroam/protocol';
 export class RunAuthorizationControl {
     send;
-    purpose;
     #pending = new Map();
     #generation = 0;
     #connected = false;
     #closed = false;
-    constructor(send, purpose = 'schedule') {
+    constructor(send) {
         this.send = send;
-        this.purpose = purpose;
     }
     code(suffix) {
-        return `${this.purpose.toUpperCase()}_${suffix}`;
+        return `SCHEDULE_${suffix}`;
     }
     connected() {
         this.disconnected();
@@ -28,7 +26,7 @@ export class RunAuthorizationControl {
         this.disconnected();
     }
     handle(envelope) {
-        if (envelope.type !== `${this.purpose}.authorize.response`)
+        if (envelope.type !== 'schedule.authorize.response')
             return false;
         const pending = envelope.replyTo === undefined ? undefined : this.#pending.get(envelope.replyTo);
         if (pending === undefined || pending.generation !== this.#generation)
@@ -43,9 +41,7 @@ export class RunAuthorizationControl {
     authorize(request) {
         if (!this.#connected || this.#closed)
             return Promise.reject(new Error(this.code('SERVER_UNAVAILABLE')));
-        const envelope = createEnvelope(`${this.purpose}.authorize`, (this.purpose === 'schedule'
-            ? scheduledRunAuthorizeRequestSchema
-            : restartRunAuthorizeRequestSchema).parse(request));
+        const envelope = createEnvelope('schedule.authorize', scheduledRunAuthorizeRequestSchema.parse(request));
         return new Promise((resolve, reject) => {
             const settle = (action) => {
                 const pending = this.#pending.get(envelope.id);

package/dist/service/session-recent-activity.js

@@ -81,6 +81,9 @@ export function marctlSessionProgress(runtime, sessionId) {
     const { latestActivity: _latest, ...progress } = activity(runtime, sessionId);
     return { ...progress, ...pendingApprovals(runtime, sessionId) };
 }
+export function sessionActivityStatus(runtime, sessionId) {
+    return activity(runtime, sessionId).status;
+}
 /** Summarizes current approval facts without exposing tool input or native payloads. */
 function pendingApprovals(runtime, sessionId) {
     const run = runtime.activeSessionRun(sessionId);

package/dist/session/runtime/work-process.js

@@ -12,6 +12,7 @@ const boundaries = new Set([
     'approval_request',
     'user_input_request',
     'plan',
+    'context_compaction',
     'turn_summary'
 ]);
 function record(value) {
@@ -64,12 +65,9 @@ export function projectConversationWorkProcesses(turn) {
     let current;
     const assigned = new Map();
     const items = ordered.map((item) => {
-        const payload = record(item.payload);
         let group;
         let isStart = false;
-        const independent = boundaries.has(item.kind) ||
-            (item.kind === 'context_compaction' && payload.mode !== 'BACKGROUND') ||
-            (item.kind === 'error' && item.parentItemId === null);
+        const independent = boundaries.has(item.kind) || (item.kind === 'error' && item.parentItemId === null);
         if (visible(item)) {
             if (independent) {
                 current = undefined;

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

@@ -5,7 +5,7 @@ import { nodeLog } from '../operational.js';
 import { isTerminalRunStatus } from './runtime/type-guards.js';
 import { sessionPage } from './pagination.js';
 import { latestSessionActivityAt } from './session-presentation-service.js';
-import { marctlSessionSummary } from '../service/session-recent-activity.js';
+import { marctlSessionSummary, sessionActivityStatus } from '../service/session-recent-activity.js';
 import { WorkspaceSessionCleanupBudget, WorkspaceSessionCleanupDeadline } from '../service/workspace-session-cleanup-budget.js';
 export class SessionCatalogService {
     options;
@@ -92,7 +92,8 @@ export class SessionCatalogService {
                     session.metadata.runnerTitle ??
                     'Untitled session',
                 runner: session.runner,
-                activity: live && 'activity' in live ? live.activity : 'IDLE'
+                activity: live && 'activity' in live ? live.activity : 'IDLE',
+                status: sessionActivityStatus(this.options.runtime, session.id)
             });
             const children = [...database.listChildSessionRecords(input.workspaceId, session.id)];
             if (input.includeAncestors === true)

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

@@ -14,6 +14,7 @@ import { prepareComposerResourceInput, composerResourceInputTags, withSessionMes
 const INTERNAL_GOAL = Symbol('internalGoal');
 const INTERNAL_SCHEDULE = Symbol('internalSchedule');
 const INTERNAL_RESTORE = Symbol('internalRestore');
+const RESTORE_CONFIGURATION = Symbol('restoreConfiguration');
 export class SessionMessageService {
     options;
     pendingMessages = new Map();
@@ -28,8 +29,12 @@ export class SessionMessageService {
     setAccepting(accepting) {
         this.accepting = accepting;
     }
-    restoreQueued(input) {
-        return this.message({ ...input, [INTERNAL_RESTORE]: true });
+    restoreQueued(input, configuration) {
+        return this.message({
+            ...input,
+            [INTERNAL_RESTORE]: true,
+            ...(configuration === undefined ? {} : { [RESTORE_CONFIGURATION]: configuration })
+        });
     }
     operations() {
         return {
@@ -42,6 +47,9 @@ export class SessionMessageService {
         return this.message({
             [INTERNAL_GOAL]: true,
             [INTERNAL_RESTORE]: input.restoreQueued === true,
+            ...(input.restoreQueued !== true || input.restartConfiguration === undefined
+                ? {}
+                : { [RESTORE_CONFIGURATION]: input.restartConfiguration }),
             sessionId: input.sessionId,
             __suppressNotifications: input.suppressNotifications === true ||
                 (input.kind === 'continue' &&
@@ -146,10 +154,11 @@ export class SessionMessageService {
             };
         const executionContext = input[RUNNER_EXECUTION_CONTEXT] ??
             this.options.runners.require(session.runner).prepareExecutionContext(input);
+        const restoredConfiguration = input[RESTORE_CONFIGURATION];
         if (session.parentSessionId != null)
             this.options.runners
                 .require(session.runner)
-                .assertChildModel(session.modelId, executionContext);
+                .assertChildModel((restoredConfiguration ?? session).modelId, executionContext);
         const sourceContent = withSessionMessageOrigin(content, input.__marctlOrigin, session.parentSessionId);
         const goalMessage = internalGoal || internalSchedule || internalRestore
             ? undefined
@@ -297,9 +306,9 @@ export class SessionMessageService {
                         cwd,
                         workspacePath,
                         externalSessionId: currentSession.externalSessionId,
-                        modelId: currentSession.modelId,
-                        effort: currentSession.effort,
-                        access: currentSession.access,
+                        modelId: (restoredConfiguration ?? currentSession).modelId,
+                        effort: (restoredConfiguration ?? currentSession).effort,
+                        access: (restoredConfiguration ?? currentSession).access,
                         collaborationMode: planActive ? 'plan' : 'default',
                         secretEnvironment,
                         ...(personalInstructions === undefined ? {} : { personalInstructions }),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/node",
-  "version": "0.11.48",
+  "version": "0.11.50",
   "description": "MyAgentRoam Node runtime CLI.",
   "license": "Apache-2.0 AND GPL-2.0-or-later",
   "type": "module",
@@ -38,10 +38,10 @@
     "sharp": "0.35.5",
     "ws": "^8.21.3",
     "zod": "4.4.3",
-    "@myagentroam/agent": "0.11.48",
+    "@myagentroam/agent": "0.11.50",
+    "@myagentroam/marctl": "0.11.10",
     "@myagentroam/code-navigation": "0.11.1",
-    "@myagentroam/protocol": "0.11.48",
-    "@myagentroam/marctl": "0.11.9"
+    "@myagentroam/protocol": "0.11.50"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"