@myagentroam/node 0.11.42 → 0.11.44

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

@@ -1,4 +1,4 @@
-import { marAgentNodeModelSummarySchema, parseComposerTags, resolveMarAgentDefaultReasoningEffort, serializeComposerTag } from '@myagentroam/protocol';
+import { marAgentNodeModelSummarySchema, marAgentRuntimeModelConfigurationSchema, parseComposerTags, resolveMarAgentDefaultReasoningEffort, serializeComposerTag } from '@myagentroam/protocol';
 import { nodeLog } from '../operational.js';
 import { runnerErrorProjection } from './runner-error.js';
 import { AgentError, openAgentSessionCatalog } from '@myagentroam/agent';
@@ -7,7 +7,7 @@ import { resolve } from 'node:path';
 import { AbstractRunner } from './abstract-runner.js';
 import { marAgentGeneratedImageSources, marAgentGeneratedImagesDirectory } from './mar-agent/generated-images.js';
 import { projectMarAgentHistory } from './mar-agent/history-projection.js';
-import { captureMarAgentExecutionInput } from './mar-agent/execution-input.js';
+import { captureMarAgentExecutionInput, marAgentEnvelopeInput } from './mar-agent/execution-input.js';
 export class MarAgentRunner extends AbstractRunner {
     homeDirectory;
     name = 'mar-agent';
@@ -31,6 +31,7 @@ export class MarAgentRunner extends AbstractRunner {
         return { runner: this.name, runnerInput: captureMarAgentExecutionInput(input) };
     }
     discoveryScope = 'ALL_WORKSPACES';
+    // Display and usage hints only; request admission/defaults use captured resources.
     #models = [];
     #releaseSessionResources;
     #generatedImageRegistrar;
@@ -45,6 +46,7 @@ export class MarAgentRunner extends AbstractRunner {
                 return parsed.success ? [parsed.data] : [];
             })
             : [];
+        return this.profileForValidation();
     }
     setSessionResourceReleaser(release) {
         this.#releaseSessionResources = release;
@@ -114,8 +116,9 @@ export class MarAgentRunner extends AbstractRunner {
     available(capabilities) {
         return capabilities.marAgent?.available === true;
     }
-    profileForValidation() {
-        const models = this.#models.filter((model) => model.enabled && model.conversationModel !== false);
+    profileForValidation(catalog = this
+        .#models) {
+        const models = catalog.filter((model) => model.enabled && model.conversationModel !== false);
         return {
             runner: 'mar-agent',
             models: models.map((model, index) => ({
@@ -202,10 +205,29 @@ export class MarAgentRunner extends AbstractRunner {
             .map((model) => model.id));
         return this.profileForValidation().models.filter((model) => eligible.has(model.id));
     }
-    assertChildModel(modelId) {
-        if (!this.childModels().some((model) => model.id === modelId))
+    assertChildModel(modelId, context) {
+        if (!this.executionModels(context).some((model) => model.id === modelId && model.enabled && model.conversationModel && model.subagentModel))
             throw new Error('MAR_AGENT_SUBAGENT_MODEL_UNAVAILABLE');
     }
+    executionModels(context, purpose = 'admission') {
+        if (context.runner !== this.name)
+            return [];
+        const input = marAgentEnvelopeInput({ runnerInput: context.runnerInput });
+        const candidates = purpose === 'defaults' && Array.isArray(input?.models) && input.models.length > 0
+            ? input.models
+            : input?.model !== undefined
+                ? [input.model]
+                : Array.isArray(input?.models)
+                    ? input.models
+                    : [];
+        return candidates.flatMap((value) => {
+            const runtime = marAgentRuntimeModelConfigurationSchema.safeParse(value);
+            if (runtime.success)
+                return [runtime.data];
+            const summary = marAgentNodeModelSummarySchema.safeParse(value);
+            return summary.success ? [summary.data] : [];
+        });
+    }
     supportsConfiguration(configuration) {
         if (configuration.runner !== this.name)
             return false;
@@ -217,8 +239,10 @@ export class MarAgentRunner extends AbstractRunner {
                 : model.supportedEfforts.includes(configuration.effort)) &&
             profile.accessOptions.some((candidate) => candidate.id === configuration.access));
     }
-    defaultConfiguration() {
-        const profile = this.profileForValidation();
+    defaultConfiguration(_workspace, _environment, executionContext) {
+        const profile = this.profileForValidation(executionContext === undefined
+            ? this.#models
+            : this.executionModels(executionContext, 'defaults'));
         const model = profile.models[0];
         return {
             runner: 'mar-agent',

package/dist/runner/normalization.js

@@ -1,6 +1,14 @@
 export function compactRunnerText(value, limit) {
     return value.length <= limit ? value : `${value.slice(0, Math.max(0, limit - 1))}…`;
 }
+export function publicOutputSnapshot(value, truncated = false) {
+    const text = typeof value === 'string' ? value : compactRunnerValue(value, Number.MAX_SAFE_INTEGER).text;
+    let bounded = text.slice(-10_000);
+    const first = bounded.charCodeAt(0);
+    if (text.length > 10_000 && first >= 0xdc00 && first <= 0xdfff)
+        bounded = bounded.slice(1);
+    return { text: bounded, truncated: truncated || text.length > 10_000 };
+}
 export function compactRunnerValue(value, limit) {
     if (value === undefined || value === null)
         return { text: '', truncated: false };

package/dist/runner/opencode/tool-normalizer.js

@@ -1,5 +1,5 @@
-import { compactRunnerText, compactRunnerValue } from '../normalization.js';
-import { publicOutputSnapshot, shellExecution } from '../execution-presentation.js';
+import { compactRunnerText, compactRunnerValue, publicOutputSnapshot } from '../normalization.js';
+import { shellExecution } from '../execution-presentation.js';
 export function normalizeOpenCodeTool(toolName, state) {
     const status = state?.status === 'completed'
         ? 'COMPLETED'
@@ -14,6 +14,7 @@ export function normalizeOpenCodeTool(toolName, state) {
         return {
             kind: 'command_execution',
             payload: {
+                toolName: publicToolName,
                 command: compactRunnerText(typeof input?.command === 'string'
                     ? input.command
                     : typeof input?.cmd === 'string'
@@ -21,7 +22,6 @@ export function normalizeOpenCodeTool(toolName, state) {
                         : publicToolName, 10_000),
                 cwd: typeof input?.cwd === 'string' ? compactRunnerText(input.cwd, 4_096) : null,
                 outputPreview: typeof state?.output === 'string' ? compactRunnerText(state.output, 10_000) : '',
-                outputRef: null,
                 exitCode: typeof state?.exitCode === 'number' ? state.exitCode : null,
                 durationMs: null,
                 truncated: typeof state?.output === 'string' && state.output.length > 10_000,
@@ -53,6 +53,7 @@ export function normalizeOpenCodeTool(toolName, state) {
                     }
                 }
                 : {}),
+            ...(typeof state?.output === 'string' ? { output: publicOutputSnapshot(state.output) } : {}),
             ...subagent
         }
     };
@@ -75,7 +76,10 @@ function openCodeSubagentProjection(toolName, input, output) {
         ...(title.length === 0 ? {} : { title }),
         ...(nativeResult === undefined
             ? {}
-            : { outputSummary: compactRunnerText(nativeResult.result, 10_000) || null })
+            : {
+                outputSummary: compactRunnerText(nativeResult.result, 10_000) || null,
+                output: publicOutputSnapshot(nativeResult.result)
+            })
     };
 }
 function openCodeTaskResult(value) {

package/dist/runtime-state.js

@@ -1046,7 +1046,6 @@ export class NodeRuntimeState {
                 command: input.command,
                 cwd: input.cwd,
                 outputPreview: input.outputPreview.slice(0, 10_000),
-                outputRef: null,
                 exitCode: input.failed ? 1 : 0,
                 durationMs: 0,
                 truncated: false

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

@@ -3,10 +3,8 @@ import { resolvedPersonalInstructions } from '../runner/personal-instructions.js
 import { AgentNetworkService } from './agent-network-service.js';
 import { isPlainRecord } from '../util/records.js';
 import { safeErrorCode } from '../util/safe-error.js';
-import { withSessionMessageOrigin } from './composer-message-input.js';
 import { SESSION_ADMISSION_SIGNAL } from '../session/operation-admission.js';
 import { assertSessionControlOwner } from './run-ownership-policy.js';
-const approvedCalls = new WeakMap();
 const terminalCalls = new WeakMap();
 /** Bind a terminal actor only after the Node request boundary has authenticated its caller. */
 export function actorForAuthenticatedTerminal(actor, workspaceId) {
@@ -14,14 +12,6 @@ export function actorForAuthenticatedTerminal(actor, workspaceId) {
     terminalCalls.set(authenticated, { workspaceId });
     return authenticated;
 }
-/** Bind a Host-approved invocation to its exact target and domain operations. */
-export function actorForApprovedAgentCall(actor, context, agentIds, operations) {
-    if (context.permission?.decision !== 'approved')
-        return actor;
-    const approved = Object.freeze({ ...actor });
-    approvedCalls.set(approved, { agentIds: [...agentIds], operations: [...operations] });
-    return approved;
-}
 import { sessionPage } from '../session/pagination.js';
 import { marctlSessionSummary, marctlSessionDetail } from './session-recent-activity.js';
 /** Bind the collaboration use case to the existing Session, Run and Goal owners. */
@@ -50,7 +40,7 @@ export function createNodeAgentNetwork(options) {
         const parent = terminal ? undefined : await actorSession(actor);
         const workspaceId = terminal?.workspaceId ?? parent?.workspaceId;
         const session = options.runtime.getAgentSession(id) ?? (await options.projection.resolve(id, true));
-        if (!session || session.workspaceId !== workspaceId || session.id === parent?.id)
+        if (!session || session.workspaceId !== workspaceId)
             throw new Error('SESSION_NOT_FOUND');
         return session;
     }
@@ -93,11 +83,8 @@ export function createNodeAgentNetwork(options) {
         return result;
     }
     async function validateApproval(actor, session, input) {
-        if (!terminalCalls.has(actor)) {
-            const parent = await actorSession(actor);
-            if (session.parentSessionId !== parent.id)
-                throw new Error('AGENT_TARGET_NOT_AUTHORIZED');
-        }
+        if (!terminalCalls.has(actor))
+            await actorSession(actor);
         assertSessionControlOwner(options.runtime, session.id, actor.requestUserId);
         const approval = options.runtime.getApproval(input.approvalId);
         if (!approval)
@@ -118,19 +105,10 @@ export function createNodeAgentNetwork(options) {
     return new AgentNetworkService({
         observations: options.observations,
         target,
-        authorize: async (actor, session, operation) => {
+        authorize: async (actor, session) => {
+            if (!terminalCalls.has(actor))
+                await actorSession(actor);
             assertSessionControlOwner(options.runtime, session.id, actor.requestUserId);
-            if (terminalCalls.has(actor))
-                return;
-            const source = await actorSession(actor);
-            if (session.parentSessionId === source.id)
-                return;
-            if (source.parentSessionId === session.id && operation === 'send')
-                return;
-            const approved = approvedCalls.get(actor);
-            if (approved?.agentIds.includes(session.id) && approved.operations.includes(operation))
-                return;
-            throw new Error('AGENT_TARGET_NOT_AUTHORIZED');
         },
         children: async (actor) => {
             if (terminalCalls.has(actor))
@@ -141,27 +119,8 @@ export function createNodeAgentNetwork(options) {
                 options.projection.resolve(record.id, true)));
             return resolved.filter((session) => session !== undefined);
         },
-        observe: (actor, session) => options.ensureObservations(actor).observe(session.id),
-        isUpward: async (actor, session) => !terminalCalls.has(actor) && (await actorSession(actor)).parentSessionId === session.id,
-        reportUpward: async (actor, session, input, signal) => {
-            const child = await actorSession(actor);
-            const runId = actor.runId;
-            const executionId = actor.executionId;
-            if (!runId ||
-                !executionId ||
-                options.runtime.currentExecutionId(runId) !== executionId ||
-                child.parentSessionId !== session.id)
-                throw new Error('AGENT_ACTOR_NOT_ACTIVE');
-            signal?.throwIfAborted();
-            const parent = options.observations.get(session.id);
-            if (!parent?.report({
-                childId: child.id,
-                runId,
-                executionId,
-                value: withSessionMessageOrigin(input.content, origin(child), session.parentSessionId)
-            }))
-                throw new Error('AGENT_PARENT_NOT_WARM');
-            return { delivery: 'reported', clientMessageId: input.clientMessageId };
+        observe: (actor) => {
+            options.ensureObservations(actor);
         },
         freezeExecution: (session) => {
             const snapshot = options.runtime.latestSessionExecution(session.id);
@@ -210,7 +169,7 @@ export function createNodeAgentNetwork(options) {
                 throw new Error('SESSION_INVALID');
             const model = input.model ??
                 database.getRunnerDefaults().find((entry) => entry.runner === runner)?.model ??
-                runnerAdapter.defaultConfiguration(workspace, actor.secretEnvironment ?? {}).model;
+                runnerAdapter.defaultConfiguration(workspace, actor.secretEnvironment ?? {}, runnerAdapter.prepareExecutionContext(actor.runnerConfiguration ?? {})).model;
             const request = {
                 ...executionInput(actor, runner, model, parent !== undefined),
                 workspaceId: workspace.id,

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

@@ -1,4 +1,4 @@
-import { actorForApprovedAgentCall, actorForAuthenticatedTerminal } from './agent-network-bindings.js';
+import { actorForAuthenticatedTerminal } from './agent-network-bindings.js';
 import { isPlainRecord } from '../util/records.js';
 import { randomUUID } from 'node:crypto';
 import { modelUsageGrantSchema } from '@myagentroam/protocol';
@@ -11,11 +11,14 @@ export function agentNetworkInvoke(input) {
 }
 /** Read actor resources from the current Node-owned Execution, not caller arguments. */
 export function executionAgentActor(input) {
-    const { sessionId, executionId } = input;
+    const { executionId } = input;
+    // Warm runtimes and execution credentials may retain the bootstrap Session ID.
+    const sessionId = input.runtime.getAgentSessionById(input.sessionId)?.id;
     const execution = input.runtime.executionSnapshot(executionId);
     const prepared = input.coordinator.pending(executionId);
     const run = execution && input.runtime.getRun(execution.runId);
-    if (!execution ||
+    if (!sessionId ||
+        !execution ||
         !prepared ||
         !run ||
         execution.sessionId !== sessionId ||
@@ -49,21 +52,6 @@ export function executionAgentActor(input) {
 }
 /** Shared command dispatch; callers must bind actor authority at their trusted boundary. */
 export async function invokeAgentNetwork(service, actor, action, payload, context, requestSignal) {
-    const targets = typeof payload.agentId === 'string'
-        ? [payload.agentId]
-        : Array.isArray(payload.agentIds)
-            ? payload.agentIds.filter((id) => typeof id === 'string')
-            : [];
-    const operations = action === 'send'
-        ? ['send', 'goal']
-        : action === 'stop'
-            ? ['stop']
-            : action === 'wait'
-                ? ['wait']
-                : [];
-    const authorized = context
-        ? actorForApprovedAgentCall(actor, context, targets, operations)
-        : actor;
     const signal = context?.signal ?? requestSignal;
     switch (action) {
         case 'start':
@@ -82,11 +70,11 @@ export async function invokeAgentNetwork(service, actor, action, payload, contex
                 ...(typeof payload.title === 'string' ? { title: payload.title.trim() } : {})
             }, signal);
         case 'send':
-            return service.send(authorized, payload, signal);
+            return service.send(actor, payload, signal);
         case 'stop':
-            return service.stop(authorized, payload);
+            return service.stop(actor, payload);
         case 'wait':
-            return service.wait(authorized, {
+            return service.wait(actor, {
                 ...payload,
                 ...(context
                     ? { signal: context.signal, interrupt: context.waitInterrupt }

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

@@ -32,6 +32,7 @@ export function agentObservationFromRunEvent(input) {
 /** Volatile, session-owned delivery of live direct-child observations. */
 export class AgentNetworkObservations {
     #parents = new Map();
+    #waiters = new Map();
     attach(parentId) {
         if (this.#parents.has(parentId))
             throw new Error('AGENT_NETWORK_PARENT_ALREADY_ATTACHED');
@@ -49,11 +50,21 @@ export class AgentNetworkObservations {
     publish(input) {
         this.#parents.get(input.parentId)?.publish(input);
     }
-    /** Direct children are automatic; other Sessions are watched only when explicitly targeted. */
+    /** Call-local observations never enter a Session's automatic context or wake channel. */
+    watchExecutions(targets) {
+        const observations = new ParentObservations(() => this.#waiters.delete(observations));
+        this.#waiters.set(observations, targets);
+        return observations;
+    }
+    /** Only direct children are automatic; other targets reach active, execution-scoped waits. */
     publishChild(input) {
-        for (const [parentId, parent] of this.#parents) {
-            if (parentId === input.parentId || parent.observes(input.childId))
-                parent.publish(input);
+        if (input.parentId != null)
+            this.#parents.get(input.parentId)?.publish(input);
+        for (const [waiter, targets] of this.#waiters) {
+            if (targets.some((target) => target.agentId === input.childId &&
+                target.runId === input.runId &&
+                target.executionId === input.executionId))
+                waiter.publish(input);
         }
     }
     promote(previousId, nextId) {
@@ -74,19 +85,11 @@ export class ParentObservations {
     #results = new Map();
     #listeners = new Set();
     #wakeListeners = new Set();
-    #targets = new Set();
     #revision = 0;
     #closed = false;
     constructor(detach) {
         this.detach = detach;
     }
-    observe(childId) {
-        if (!this.#closed)
-            this.#targets.add(childId);
-    }
-    observes(childId) {
-        return this.#targets.has(childId);
-    }
     wake = {
         pending: () => [...this.#items.values()].some((item) => item.kind === 'message' && item.wakes !== false),
         subscribe: (listener) => {
@@ -302,7 +305,6 @@ export class ParentObservations {
         this.#results.clear();
         this.#listeners.clear();
         this.#wakeListeners.clear();
-        this.#targets.clear();
         this.detach();
     }
 }

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

@@ -41,7 +41,8 @@ export class AgentNetworkService {
             goal
         }, signal);
         try {
-            this.options.observe(actor, created.session);
+            if (created.session.parentSessionId === actor.sessionId)
+                this.options.observe(actor, created.session);
             return { agentId: created.session.id, start: created.result };
         }
         catch (error) {
@@ -90,23 +91,8 @@ export class AgentNetworkService {
         if (input.approval !== undefined)
             await this.options.validateApproval(actor, session, input.approval);
         signal?.throwIfAborted();
-        if (hasMessage && (await this.options.isUpward(actor, session))) {
-            signal?.throwIfAborted();
-            if (goal.kind !== 'unchanged' ||
-                input.approval !== undefined ||
-                input.deliveryIntent === 'REPLACE_CURRENT' ||
-                input.deliveryIntent === 'QUEUE' ||
-                input.attachments?.length ||
-                input.attachmentIds?.length)
-                throw new Error('AGENT_UPWARD_REPORT_INVALID');
-            const result = await this.options.reportUpward(actor, session, {
-                clientMessageId: input.clientMessageId ?? randomUUID(),
-                content
-            }, signal);
-            return { agentId: session.id, message: { status: 'accepted', result } };
-        }
-        signal?.throwIfAborted();
-        this.options.observe(actor, session);
+        if (session.parentSessionId === actor.sessionId)
+            this.options.observe(actor, session);
         const approvalResult = input.approval === undefined
             ? undefined
             : await this.options.approval(actor, session, input.approval, signal);
@@ -281,22 +267,44 @@ export class AgentNetworkService {
         if (!targets.length)
             throw new Error('AGENT_EXECUTION_NOT_FOUND');
         const selected = new Set(targets.map((target) => target.agentId));
+        const directChildren = new Set();
         for (const session of sessions)
-            if (selected.has(session.id))
+            if (selected.has(session.id) && session.parentSessionId === actor.sessionId) {
                 this.options.observe(actor, session);
-        const observations = this.options.observations.get(actor.observationId ?? actor.sessionId);
-        if (!observations)
+                directChildren.add(session.id);
+            }
+        const parent = this.options.observations.get(actor.observationId ?? actor.sessionId);
+        if (directChildren.size && !parent)
             throw new Error('AGENT_OBSERVATION_UNAVAILABLE');
-        return waitForAgentTargets({
-            targets,
-            observations,
-            single: input.agentIds === undefined,
-            waitMs: input.waitMs ?? 30_000,
-            ...(input.mode === undefined ? {} : { mode: input.mode }),
-            ...(input.waitFor === undefined ? {} : { waitFor: input.waitFor }),
-            ...(input.signal === undefined ? {} : { signal: input.signal }),
-            ...(input.interrupt === undefined ? {} : { interrupt: input.interrupt })
-        });
+        const otherTargets = targets.filter((target) => !directChildren.has(target.agentId));
+        const temporary = otherTargets.length && input.waitMs !== 0
+            ? this.options.observations.watchExecutions(otherTargets)
+            : undefined;
+        try {
+            return await waitForAgentTargets({
+                targets,
+                observations: {
+                    capture: (id, executionId) => (directChildren.has(id) ? parent : temporary)?.capture(id, executionId),
+                    subscribe: (listener) => {
+                        const unsubscribeParent = directChildren.size ? parent?.subscribe(listener) : undefined;
+                        const unsubscribeTemporary = temporary?.subscribe(listener);
+                        return () => {
+                            unsubscribeParent?.();
+                            unsubscribeTemporary?.();
+                        };
+                    }
+                },
+                single: input.agentIds === undefined,
+                waitMs: input.waitMs ?? 30_000,
+                ...(input.mode === undefined ? {} : { mode: input.mode }),
+                ...(input.waitFor === undefined ? {} : { waitFor: input.waitFor }),
+                ...(input.signal === undefined ? {} : { signal: input.signal }),
+                ...(input.interrupt === undefined ? {} : { interrupt: input.interrupt })
+            });
+        }
+        finally {
+            temporary?.close();
+        }
     }
 }
 function sameGoal(left, right) {

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

@@ -180,6 +180,11 @@ export class GoalContinuationCoordinator {
         };
     }
     async start({ session, objective, initiatedByUserId, suppressNotifications, secretEnvironment, personalInstructions, executionContext, usageGrant, preserveActiveRun, messageIntent, messageContent, clientMessageId, messageOrigin, attachments, attachmentIds }) {
+        if (session.parentSessionId != null)
+            this.options
+                .runners()
+                .require(session.runner)
+                .assertChildModel(session.model, executionContext);
         this.invalidateGoalContinuation(session.id);
         const prepared = this.prepareGoalSession(session);
         const goalSession = prepared.session;

package/dist/service/marctl-caller.js

@@ -21,7 +21,7 @@ const executionManagementOperations = new Set([
     'session.config.update',
     'session.schedule.agent.save'
 ]);
-/** Prevent execution credentials from reaching legacy writes outside their Session tree. */
+/** Keep execution management within its authenticated Workspace and Run ownership. */
 export async function authorizeMarctlExecutionOperation(input) {
     if (!isPlainRecord(input.caller))
         throw new Error('MARCTL_EXECUTION_CREDENTIAL_INVALID');
@@ -31,19 +31,27 @@ export async function authorizeMarctlExecutionOperation(input) {
         throw new Error('MARCTL_EXECUTION_CREDENTIAL_INVALID');
     if (executionReadOperations.has(input.operation))
         return;
-    if (!executionManagementOperations.has(input.operation) ||
-        !isPlainRecord(input.data) ||
-        typeof input.data.sessionId !== 'string' ||
-        typeof input.data.workspaceId !== 'string')
+    if (!isPlainRecord(input.data) || typeof input.data.workspaceId !== 'string')
         throw new Error('MARCTL_AGENT_NETWORK_REQUIRED');
+    let sessionId;
+    if (input.operation === 'run.approval.decide') {
+        const run = typeof input.data.runId === 'string' ? input.runtime.getRun(input.data.runId) : undefined;
+        if (!run)
+            throw new Error('RUN_NOT_FOUND');
+        sessionId = run.sessionId;
+    }
+    else {
+        if (!executionManagementOperations.has(input.operation) ||
+            typeof input.data.sessionId !== 'string')
+            throw new Error('MARCTL_AGENT_NETWORK_REQUIRED');
+        sessionId = input.data.sessionId;
+    }
     const source = input.runtime.getAgentSession(input.caller.sessionId);
-    const target = input.runtime.getAgentSession(input.data.sessionId) ??
-        (await input.resolveSession(input.data.sessionId));
+    const target = input.runtime.getAgentSession(sessionId) ?? (await input.resolveSession(sessionId));
     if (!source ||
         !target ||
         source.workspaceId !== input.data.workspaceId ||
-        target.workspaceId !== source.workspaceId ||
-        (target.id !== source.id && target.parentSessionId !== source.id))
+        target.workspaceId !== source.workspaceId)
         throw new Error('AGENT_TARGET_NOT_AUTHORIZED');
     assertSessionControlOwner(input.runtime, target.id, input.userId);
 }

package/dist/service/runner-service.js

@@ -44,10 +44,14 @@ export class RunnerService {
     async listProfiles(data) {
         const input = data;
         const marAgent = this.runners.optional('mar-agent');
+        let marAgentProfile;
         if (marAgent !== undefined &&
             'configureModels' in marAgent &&
             typeof marAgent.configureModels === 'function')
-            marAgent.configureModels(input.marAgentModels);
+            marAgentProfile = marAgent.configureModels(input.marAgentModels);
+        // Capture the request's display catalog before any asynchronous Runner refresh.
+        // This cache is not used for model admission.
+        const requestProfiles = (profiles) => profiles.map((profile) => profile.runner === 'mar-agent' && marAgentProfile !== undefined ? marAgentProfile : profile);
         const environment = parseSecretEnvironment(input.secretEnvironment);
         const defaults = this.database()
             .getRunnerDefaults()
@@ -71,12 +75,12 @@ export class RunnerService {
         if (cacheOnly) {
             void refresh.catch(() => undefined);
             return {
-                profiles: this.profiles(environment),
+                profiles: requestProfiles(this.profiles(environment)),
                 defaults
             };
         }
         return {
-            profiles: await refresh,
+            profiles: requestProfiles(await refresh),
             defaults
         };
     }

package/dist/session/runtime/conversation-projection.js

@@ -1,4 +1,4 @@
-import { permissionStopSchema } from '@myagentroam/protocol';
+import { appendExecutionPresentation, permissionStopSchema } from '@myagentroam/protocol';
 import { projectConversationWorkProcesses } from './work-process.js';
 function isRecord(value) {
     return typeof value === 'object' && value !== null;
@@ -293,6 +293,8 @@ export function mergeConversationItemPayload(existing, next) {
     if (next.append === 'output' &&
         isRecord(next.payload.output) &&
         typeof next.payload.output.text === 'string') {
+        if (next.payload.toolPresentation !== undefined)
+            value.toolPresentation = appendExecutionPresentation(base.toolPresentation, next.payload.toolPresentation);
         const prior = isRecord(base.output) && typeof base.output.text === 'string' ? base.output : undefined;
         const text = `${prior?.text ?? ''}${next.payload.output.text}`;
         value.output = {

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

@@ -168,7 +168,8 @@ export class SessionLifecycleService {
         }
         const environment = parseSecretEnvironment(input.secretEnvironment);
         const saved = database.getRunnerDefaults().find((value) => value.runner === runner.name);
-        const fallback = runner.defaultConfiguration(workspace, environment);
+        const executionContext = runner.prepareExecutionContext(input);
+        const fallback = runner.defaultConfiguration(workspace, environment, executionContext);
         const configuration = {
             runner: runner.name,
             model: typeof input.model === 'string' ? input.model : (saved?.model ?? fallback.model),
@@ -182,7 +183,7 @@ export class SessionLifecycleService {
         if (runner.name === 'mar-agent' && !['auto', 'full-access'].includes(configuration.access))
             throw new Error('SESSION_INVALID');
         if (parentSessionId !== undefined)
-            runner.assertChildModel(configuration.model);
+            runner.assertChildModel(configuration.model, executionContext);
         const session = this.options.runtime.createAgentSession({
             ...(parentSessionId === undefined ? {} : { parentSessionId }),
             workspaceId: input.workspaceId,
@@ -221,8 +222,10 @@ export class SessionLifecycleService {
             input.access !== undefined &&
             !['auto', 'full-access'].includes(input.access))
             throw new Error('SESSION_INVALID');
-        if (current.parentSessionId != null && typeof input.model === 'string')
-            this.options.runners.require(current.runner).assertChildModel(input.model);
+        if (current.parentSessionId != null && typeof input.model === 'string') {
+            const runner = this.options.runners.require(current.runner);
+            runner.assertChildModel(input.model, runner.prepareExecutionContext(input));
+        }
         const session = this.options.runtime.updateAgentSessionConfiguration({
             sessionId: current.id,
             ...(typeof input.model === 'string' ? { model: input.model } : {}),

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

@@ -143,10 +143,12 @@ export class SessionMessageService {
                 idempotent: true,
                 auditReceipt: auditReceipt(session, existing.kind === 'queue' ? 'QUEUE' : 'SEND', existing.kind === 'queue' ? existing.item.id : existing.run.id, existing.kind === 'queue' ? existing.item.id : undefined)
             };
-        if (session.parentSessionId != null)
-            this.options.runners.require(session.runner).assertChildModel(session.model);
         const executionContext = input[RUNNER_EXECUTION_CONTEXT] ??
             this.options.runners.require(session.runner).prepareExecutionContext(input);
+        if (session.parentSessionId != null)
+            this.options.runners
+                .require(session.runner)
+                .assertChildModel(session.model, executionContext);
         const sourceContent = withSessionMessageOrigin(content, input.__marctlOrigin, session.parentSessionId);
         const goalMessage = internalGoal || internalSchedule || internalRestore
             ? undefined