@myagentroam/agent 0.11.38 → 0.11.40

package/dist/sdk/session-execution.js

@@ -15,6 +15,10 @@ export class SessionExecution {
     kind;
     source;
     snapshot;
+    #observedTerminal;
+    get observedTerminal() {
+        return this.#observedTerminal;
+    }
     #contextInvalid = false;
     #contextFailure;
     #bindings;
@@ -227,10 +231,15 @@ export class SessionExecution {
                     full.type === 'execution.cancelled')
                     committedTerminal = this.persistedTerminal = true;
             }
+            if (full.type === 'execution.completed' ||
+                full.type === 'execution.failed' ||
+                full.type === 'execution.cancelled')
+                this.#observedTerminal = structuredClone(full);
             if (full.type === 'tool.output')
                 this.events.pushIfWaiting(full);
             else
                 this.events.push(full);
+            ports.observe?.(full);
             this.compactRequests.publish(full);
             try {
                 await ports.publish?.(full);
@@ -363,7 +372,7 @@ export class SessionExecution {
     join() {
         return this.resultPromise;
     }
-    handle(enqueueMessage) {
+    handle() {
         const owner = this;
         return {
             get persistedEvents() {
@@ -376,8 +385,7 @@ export class SessionExecution {
                 this.events.discardIfUnobserved();
                 return this.resultPromise;
             },
-            cancel: () => owner.cancel(new AgentError('MAR_AGENT_CANCELLED', 'Execution was cancelled.')),
-            enqueueMessage
+            cancel: () => owner.cancel(new AgentError('MAR_AGENT_CANCELLED', 'Execution was cancelled.'))
         };
     }
     cancel(reason) {

package/dist/sdk/session-extension-messages.d.ts

@@ -1,13 +1,11 @@
 import type { ExtensionSessionBackend } from '../extensions/session-input.js';
-import type { ExtensionAgentsBackend } from '../extensions/agents.js';
 import type { SessionStore } from '../session/store/contracts.js';
 import type { SessionRuntime } from './session-runtime.js';
 import type { ResolvedModelConfiguration } from './model-runtime.js';
 /** Reads either a live request snapshot or the authoritative Session history. */
 export declare function createSessionExtensionMessages(ports: {
     sessionId: string;
-    store: Pick<SessionStore, 'readResource' | 'readInputImages' | 'readExecutionState' | 'readContextualWorldState'>;
-    agents(): Pick<ExtensionAgentsBackend, 'inspect'> | undefined;
+    store: Pick<SessionStore, 'getSession' | 'executionConfiguration' | 'readResource' | 'readInputImages' | 'readExecutionState' | 'readContextualWorldState'>;
     runtime(id: string): Pick<SessionRuntime, 'execution' | 'contextualWorldState'> | undefined;
     models(): {
         models: ReadonlyMap<string, ResolvedModelConfiguration>;

package/dist/sdk/session-extension-messages.js

@@ -5,19 +5,20 @@ import { latestContextualWorldStateGeneration, parsePersistedContextualWorldStat
 import { projectSessionRequestMessages } from './request-preparation.js';
 /** Reads either a live request snapshot or the authoritative Session history. */
 export function createSessionExtensionMessages(ports) {
-    const { sessionId, store, agents, runtime, models } = ports;
+    const { sessionId, store, runtime, models } = ports;
     return async (input, call) => {
         const selection = normalizeSessionMessagesInput(input);
         call.signal.throwIfAborted();
         let target = sessionId;
-        let targetModelId;
         if (selection.agentId !== undefined) {
-            const backend = agents();
-            if (!backend)
-                throw new AgentError('MAR_AGENT_SESSION_INPUT_UNAVAILABLE', 'Session child message access is unavailable.');
-            const child = await backend.inspect({ agentId: selection.agentId }, call);
-            target = child.agentId;
-            targetModelId = child.modelId;
+            const child = await store.getSession(selection.agentId).catch((error) => {
+                if (error instanceof AgentError && error.code === 'MAR_AGENT_SESSION_NOT_FOUND')
+                    throw new AgentError('MAR_AGENT_SUBAGENT_NOT_FOUND', 'Direct child Session not found.');
+                throw error;
+            });
+            if (child.source.parentSessionId !== sessionId)
+                throw new AgentError('MAR_AGENT_SUBAGENT_NOT_FOUND', 'Direct child Session not found.');
+            target = child.id;
         }
         call.signal.throwIfAborted();
         const targetRuntime = runtime(target);
@@ -36,8 +37,12 @@ export function createSessionExtensionMessages(ports) {
             return sessionMessagesPage(restored, selection);
         }
         const modelState = models();
+        const targetConfiguration = selection.view === 'request' && target !== sessionId
+            ? await store.executionConfiguration(target)
+            : undefined;
+        call.signal.throwIfAborted();
         const requestModel = selection.view === 'request'
-            ? modelState.models.get(targetModelId ?? modelState.defaultModelId)
+            ? modelState.models.get(targetConfiguration?.modelId ?? modelState.defaultModelId)
             : undefined;
         if (selection.view === 'request' && !requestModel)
             throw new AgentError('MAR_AGENT_MODEL_DISABLED', 'Selected model is unavailable.');

package/dist/sdk/session-extension-prompt.js

@@ -19,9 +19,7 @@ export function createSessionExtensionPrompt(ports) {
             .filter((binding) => binding.available?.(call) !== false)
             .map((binding) => binding.definition)
             .filter((tool) => !(ports.source === 'subagent' &&
-            (tool.agentScope === 'ROOT_ONLY' ||
-                tool.name.startsWith('agent_') ||
-                tool.name === 'question')) &&
+            (tool.agentScope === 'ROOT_ONLY' || tool.name === 'question')) &&
             !(tool.name === 'question' && mode !== 'plan') &&
             !(tool.name === 'view_image' && !model.inputCapabilities.includes('IMAGE')) &&
             !(['code_exec', 'code_exec_wait'].includes(tool.name) &&

package/dist/sdk/session-maintenance.d.ts

@@ -20,6 +20,7 @@ export declare class SessionMaintenanceCoordinator {
     join(): Promise<void>;
     clear(id: string): Promise<void>;
     delete(id: string): Promise<void>;
+    deleteMembers(members: readonly string[]): Promise<void>;
 }
 /** Complete all independent stages, reporting the first authoritative failure. */
 export declare function completeAgentCleanup(steps: readonly (() => unknown | Promise<unknown>)[]): Promise<void>;

package/dist/sdk/session-maintenance.js

@@ -57,7 +57,6 @@ export class SessionMaintenanceCoordinator {
                     () => this.extensions.retireSession(id),
                     () => this.extensions.clearSession(id),
                     () => runtime?.retireInputs(),
-                    () => runtime?.disposeSubagents(),
                     () => closeModelAdapters(runtime === undefined
                         ? []
                         : runtime
@@ -84,8 +83,19 @@ export class SessionMaintenanceCoordinator {
         });
     }
     delete(id) {
+        return this.deleteMembers([id]);
+    }
+    deleteMembers(members) {
+        const requestedIds = [...members];
+        if (requestedIds.length === 0 ||
+            requestedIds.some((id) => typeof id !== 'string' || id.length === 0) ||
+            new Set(requestedIds).size !== requestedIds.length)
+            return Promise.reject(new AgentError('MAR_AGENT_SESSION_INVALID', 'Invalid Session maintenance members.'));
+        requestedIds.sort();
+        const id = requestedIds[0];
+        const signature = JSON.stringify(requestedIds);
         return this.#track(id, 'delete', async () => {
-            const maintenance = await this.store.acquireSessionMaintenance(id, 'delete', this.writerOwner);
+            const maintenance = await this.store.acquireSessionMaintenance(id, 'delete', this.writerOwner, requestedIds);
             let failed = false;
             const ids = maintenance.sessionIds;
             for (const sessionId of ids)
@@ -119,7 +129,6 @@ export class SessionMaintenanceCoordinator {
                     ...ids.map((sessionId) => () => this.extensions.retireSession(sessionId)),
                     ...ids.map((sessionId) => () => this.extensions.clearSession(sessionId)),
                     () => completeAgentCleanup(runtimes.map((runtime) => () => runtime.retireInputs())),
-                    () => completeAgentCleanup(runtimes.map((runtime) => () => runtime.disposeSubagents())),
                     () => Promise.all(runtimes.map((runtime) => runtime.joinExecutions())),
                     () => {
                         for (const sessionId of ids) {
@@ -157,25 +166,25 @@ export class SessionMaintenanceCoordinator {
                     }
                 }
             }
-        });
+        }, signature);
     }
     #invalidate(ids) {
         for (const id of ids)
             this.#epochs.set(id, this.epoch(id) + 1);
     }
-    #track(id, kind, operation) {
+    #track(id, kind, operation, signature = '') {
         if (this.disposed())
             return Promise.reject(new AgentError('MAR_AGENT_DISPOSED', 'Agent is disposed.'));
         const current = this.#operations.get(id);
         if (current)
-            return current.kind === kind
+            return current.kind === kind && current.signature === signature
                 ? current.pending
                 : Promise.reject(new AgentError('MAR_AGENT_SESSION_CLOSING', 'Session is closing.'));
         if (this.#treeAdmissions.has(id))
             return Promise.reject(new AgentError('MAR_AGENT_SESSION_CLOSING', 'Session is closing.'));
         const completion = Promise.withResolvers();
         const pending = completion.promise.finally(() => this.#operations.delete(id));
-        this.#operations.set(id, { kind, pending });
+        this.#operations.set(id, { kind, signature, pending });
         void pending.catch(() => undefined);
         try {
             completion.resolve(operation());

package/dist/sdk/session-open.d.ts

@@ -1,8 +1,7 @@
 import type { ModelAdapter } from '../model/contracts.js';
 import type { SessionStore } from '../session/store/contracts.js';
-import type { SubagentSessionController } from '../subagent/session-controller.js';
 import type { ResolvedModelConfiguration } from './model-runtime.js';
-import { type SessionRegistry } from './session-registry.js';
+import type { SessionRegistry } from './session-registry.js';
 import { SessionRuntime } from './session-runtime.js';
 type StoredSession = Awaited<ReturnType<SessionStore['getSession']>>;
 interface SessionOpenPorts<Handle> {
@@ -11,7 +10,7 @@ interface SessionOpenPorts<Handle> {
     readonly generation: () => number;
     readonly createAdapter: (id: string, models: ReadonlyMap<string, ResolvedModelConfiguration>) => ModelAdapter;
     readonly hasCustomAdapters: boolean;
-    readonly openSubagents: (id: string, workspace: string) => Promise<SubagentSessionController>;
+    readonly onExecutionRegistered: (runtime: SessionRuntime) => void;
     readonly assertAdmission: (id: string) => void;
     readonly epoch: (id: string) => number;
     readonly canPublish: (id: string, epoch: number) => boolean;

package/dist/sdk/session-open.js

@@ -1,5 +1,4 @@
 import { AgentError } from '../error.js';
-import { SessionOpenCleanupError } from './session-registry.js';
 import { SessionRuntime } from './session-runtime.js';
 /** The open flow owns unpublished candidates; the registry owns only identity and barriers. */
 export function createSessionOpen(ports) {
@@ -9,35 +8,17 @@ export function createSessionOpen(ports) {
         return ports.registry.trackOpen(id, async () => {
             const runtime = await ports.registry.getOrCreate(id, epoch, () => ports.canPublish(id, epoch), async (publish) => {
                 const stored = await ports.getSession(id);
-                const candidate = new SessionRuntime(stored, ports.generation(), ports.createAdapter, ports.hasCustomAdapters);
-                try {
-                    if (stored.source.type === 'user')
-                        await candidate.ensureSubagents(() => ports.openSubagents(id, stored.workspace));
-                    ports.createHandle(id, candidate, stored, workspace);
-                    if (!publish(candidate))
-                        throw new AgentError('MAR_AGENT_SESSION_CLOSING', 'Session is closing.');
-                    return candidate;
-                }
-                catch (error) {
-                    try {
-                        await candidate.disposeSubagents();
-                    }
-                    catch (cleanupError) {
-                        throw new SessionOpenCleanupError(cleanupError);
-                    }
-                    throw error;
-                }
+                const candidate = new SessionRuntime(stored, ports.generation(), ports.createAdapter, ports.hasCustomAdapters, ports.onExecutionRegistered);
+                ports.createHandle(id, candidate, stored, workspace);
+                if (!publish(candidate))
+                    throw new AgentError('MAR_AGENT_SESSION_CLOSING', 'Session is closing.');
+                return candidate;
             });
             ports.assertAdmission(id);
             const stored = await ports.getSession(id);
             ports.assertAdmission(id);
             if (!ports.canPublish(id, epoch))
                 throw new AgentError('MAR_AGENT_SESSION_CLOSING', 'Session is closing.');
-            if (stored.source.type === 'user' && runtime.subagents === undefined) {
-                await runtime.ensureSubagents(() => ports.openSubagents(id, stored.workspace));
-                if (!ports.canPublish(id, epoch))
-                    throw new AgentError('MAR_AGENT_SESSION_CLOSING', 'Session is closing.');
-            }
             return ports.createHandle(id, runtime, stored, workspace);
         });
     };

package/dist/sdk/session-runtime.d.ts

@@ -1,21 +1,21 @@
 import { ExtensionRequestSnapshots, type ExtensionRequestSnapshot } from '../extensions/model-request.js';
 import type { ExtensionSessionBackend, SessionInputCoordinator } from '../extensions/session-input.js';
-import type { ExtensionAgentsBackend } from '../extensions/agents.js';
 import type { ModelAdapter } from '../model/contracts.js';
 import type { ModelCredentialProvider } from '../model/configuration.js';
 import type { SessionModelRequest as ModelRequest } from '../session/model-request.js';
 import type { SessionStore } from '../session/store/contracts.js';
 import { type ContextualWorldState } from '../runtime/context/world-state.js';
-import type { SubagentSessionController } from '../subagent/session-controller.js';
 import { TodoStore } from '../tools/agent/todo.js';
 import type { ExecutionResult } from './types.js';
+import type { AgentEvent } from '../runtime/events.js';
 import type { ResolvedModelConfiguration } from './model-runtime.js';
 import type { SessionExecution, SessionExecutionContext } from './session-execution.js';
 export declare class SessionRuntime {
     #private;
     readonly storedSession: Awaited<ReturnType<SessionStore['getSession']>>;
+    readonly onExecutionRegistered: (runtime: SessionRuntime) => void;
     readonly scheduleTool: <T>(definition: import("../host.js").ClientToolDefinition | undefined, run: () => Promise<T>) => Promise<T>;
-    constructor(storedSession: Awaited<ReturnType<SessionStore['getSession']>>, generation: number, createAdapter: (modelId: string, models: ReadonlyMap<string, ResolvedModelConfiguration>) => ModelAdapter, hasCustomAdapters: boolean);
+    constructor(storedSession: Awaited<ReturnType<SessionStore['getSession']>>, generation: number, createAdapter: (modelId: string, models: ReadonlyMap<string, ResolvedModelConfiguration>) => ModelAdapter, hasCustomAdapters: boolean, onExecutionRegistered?: (runtime: SessionRuntime) => void);
     adapter(modelId: string, models: ReadonlyMap<string, ResolvedModelConfiguration>): ModelAdapter;
     refreshAdapters(generation: number, retained: ReadonlySet<ModelAdapter>): Promise<void>;
     static stageModelReconfiguration(sessions: readonly SessionRuntime[], models: ReadonlyMap<string, ResolvedModelConfiguration>, active: ReadonlySet<ModelAdapter>, assertOpen: () => void): Promise<(generation: number) => void>;
@@ -26,9 +26,6 @@ export declare class SessionRuntime {
     static closeModelAdapters(sessions: readonly SessionRuntime[]): Promise<void>;
     retireInputs(): Promise<unknown> | undefined;
     getOrCreateInputs(create: () => SessionInputCoordinator): SessionInputCoordinator;
-    disposeSubagents(): Promise<unknown> | undefined;
-    get subagents(): SubagentSessionController | undefined;
-    ensureSubagents(open: () => Promise<SubagentSessionController>): Promise<SubagentSessionController>;
     resetAfterClear(generation: number): void;
     recordRequest(modelId: string, request: ModelRequest): ExtensionRequestSnapshot;
     completeRequest(snapshot: ExtensionRequestSnapshot): void;
@@ -54,19 +51,33 @@ export declare class SessionRuntime {
     ensureSessionBackend(create: () => ExtensionSessionBackend & {
         kick(): void;
     }): void;
-    get agentsBackend(): ExtensionAgentsBackend | undefined;
-    ensureAgentsBackend(create: () => ExtensionAgentsBackend): void;
     get execution(): SessionExecutionContext | undefined;
     bindExecutionContext(context: SessionExecutionContext): void;
     unbindExecutionContext(context: SessionExecutionContext): void;
     get contextualWorldState(): ContextualWorldState | undefined;
     updateContextualWorldState(state: ContextualWorldState): void;
     get activeExecutionId(): string | undefined;
+    subscribe(listener: (event: AgentEvent) => void): {
+        unsubscribe: () => void;
+        terminalEvent?: (import("./types.js").AgentEventBase & {
+            type: "execution.completed";
+            permissionStop?: import("../host.js").PermissionStop;
+        }) | (import("./types.js").AgentEventBase & {
+            type: "execution.failed";
+            code: string;
+            message?: string;
+        }) | (import("./types.js").AgentEventBase & {
+            type: "execution.cancelled";
+        });
+        activeExecutionId?: string;
+    };
+    publishEvent(event: AgentEvent): void;
     assertCanExecute(): void;
     registerExecution(execution: SessionExecution): void;
     deactivateExecution(execution: SessionExecution): void;
     unregisterExecution(execution: SessionExecution): void;
     cancelExecution(executionId: string): void;
+    joinExecution(executionId: string): Promise<ExecutionResult> | undefined;
     cancelExecutions(): void;
     joinExecutions(): Promise<PromiseSettledResult<ExecutionResult>[]>;
 }

package/dist/sdk/session-runtime.js

@@ -6,22 +6,22 @@ import { createSessionToolScheduler } from '../tools/scheduler.js';
 import { SessionModelAdapters } from './session-model-adapters.js';
 export class SessionRuntime {
     storedSession;
+    onExecutionRegistered;
     #executionContext;
     #todo;
     scheduleTool = createSessionToolScheduler();
     #modelAdapters;
     #contextualWorldState;
-    #subagents;
-    #subagentsOpening;
     #inputs;
     #requestSnapshots;
     #recordProjection;
     #sessionBackend;
-    #agentsBackend;
     #executions = new Map();
     #activeExecutionId;
-    constructor(storedSession, generation, createAdapter, hasCustomAdapters) {
+    #eventObservers = new Set();
+    constructor(storedSession, generation, createAdapter, hasCustomAdapters, onExecutionRegistered = () => { }) {
         this.storedSession = storedSession;
+        this.onExecutionRegistered = onExecutionRegistered;
         this.#modelAdapters = new SessionModelAdapters(generation, createAdapter, hasCustomAdapters);
     }
     adapter(modelId, models) {
@@ -54,29 +54,9 @@ export class SessionRuntime {
     getOrCreateInputs(create) {
         return (this.#inputs ??= create());
     }
-    disposeSubagents() {
-        return this.#subagents?.dispose();
-    }
-    get subagents() {
-        return this.#subagents;
-    }
-    async ensureSubagents(open) {
-        if (this.#subagents)
-            return this.#subagents;
-        const pending = (this.#subagentsOpening ??= open());
-        try {
-            return (this.#subagents = await pending);
-        }
-        finally {
-            if (this.#subagentsOpening === pending)
-                this.#subagentsOpening = undefined;
-        }
-    }
     resetAfterClear(generation) {
         this.#modelAdapters.setGeneration(generation);
         this.#todo = undefined;
-        this.#subagents = undefined;
-        this.#subagentsOpening = undefined;
         this.#contextualWorldState = undefined;
         this.#inputs = undefined;
         this.#requestSnapshots = undefined;
@@ -146,12 +126,6 @@ export class SessionRuntime {
     ensureSessionBackend(create) {
         this.#sessionBackend ??= create();
     }
-    get agentsBackend() {
-        return this.#agentsBackend;
-    }
-    ensureAgentsBackend(create) {
-        this.#agentsBackend ??= create();
-    }
     get execution() {
         return this.#executionContext;
     }
@@ -171,6 +145,34 @@ export class SessionRuntime {
     get activeExecutionId() {
         return this.#activeExecutionId;
     }
+    subscribe(listener) {
+        const observer = (event) => listener(structuredClone(event));
+        this.#eventObservers.add(observer);
+        const terminal = this.#activeExecutionId === undefined
+            ? undefined
+            : this.#executions.get(this.#activeExecutionId)?.observedTerminal;
+        return {
+            ...(this.#activeExecutionId === undefined
+                ? {}
+                : { activeExecutionId: this.#activeExecutionId }),
+            ...(terminal === undefined ? {} : { terminalEvent: structuredClone(terminal) }),
+            unsubscribe: () => {
+                this.#eventObservers.delete(observer);
+            }
+        };
+    }
+    publishEvent(event) {
+        for (const listener of [...this.#eventObservers]) {
+            if (!this.#eventObservers.has(listener))
+                continue;
+            try {
+                listener(event);
+            }
+            catch {
+                /* Observers cannot change the owning Execution. */
+            }
+        }
+    }
     assertCanExecute() {
         if (this.#activeExecutionId !== undefined)
             throw new AgentError('MAR_AGENT_EXECUTION_ACTIVE', 'Session already has an active execution.');
@@ -179,6 +181,7 @@ export class SessionRuntime {
         this.assertCanExecute();
         this.#executions.set(execution.executionId, execution);
         this.#activeExecutionId = execution.executionId;
+        this.onExecutionRegistered(this);
     }
     deactivateExecution(execution) {
         if (this.#executions.get(execution.executionId) === execution &&
@@ -192,6 +195,9 @@ export class SessionRuntime {
     cancelExecution(executionId) {
         this.#executions.get(executionId)?.cancel();
     }
+    joinExecution(executionId) {
+        return this.#executions.get(executionId)?.join();
+    }
     cancelExecutions() {
         for (const execution of this.#executions.values())
             execution.cancel();

package/dist/sdk/session.d.ts

@@ -1,3 +1,4 @@
-import type { InternalAgentSession, SessionServices } from './session-composition.js';
+import type { SessionServices } from './session-composition.js';
+import type { AgentSession } from './types.js';
 /** SDK Session orchestration owns warm resources; Runtime owns only the model/tool loop. */
-export declare function createSessionOpener(services: SessionServices): (id: string, workspace?: string) => Promise<InternalAgentSession>;
+export declare function createSessionOpener(services: SessionServices): (id: string, workspace?: string) => Promise<AgentSession>;

package/dist/sdk/session.js

@@ -2,21 +2,15 @@ import { createExtensionSessionLaunch, extensionInputSource } from './extension-
 import { createSessionExecutionFactory } from './session-execution-factory.js';
 import { createSessionExtensionMessages } from './session-extension-messages.js';
 import { createSessionExtensionPrompt } from './session-extension-prompt.js';
-import { createSubagentBackend } from './subagent-backend.js';
 import { AgentError } from '../error.js';
 import { SessionInputCoordinator, recordSessionInputCommit } from '../extensions/session-input.js';
 import { buildSystemPromptSections } from '../prompts/index.js';
 import { childSubagentInstruction } from '../prompts/subagent.js';
 import { DEFAULT_COMPACTION_FOCUS } from '../runtime/compaction/history.js';
 import { restoreEnvironmentState } from '../runtime/context/environment.js';
-import { SubagentSessionController } from '../subagent/session-controller.js';
 import { allowsDirectTool } from '../tools/callers.js';
-import { createExtensionAgentsBackend } from './extension-agents.js';
 import { createExtensionSessionBackend } from './extension-session.js';
 import { createSessionOpen } from './session-open.js';
-function restoreSubagentOrigin(origin) {
-    return { ...origin.correlation, signal: origin.signal };
-}
 /** SDK Session orchestration owns warm resources; Runtime owns only the model/tool loop. */
 export function createSessionOpener(services) {
     const { host, description, settings, store, createAdapter, activeAdaptersExcept } = services;
@@ -27,11 +21,7 @@ export function createSessionOpener(services) {
         generation: () => services.modelState().generation,
         createAdapter,
         hasCustomAdapters: services.hasCustomAdapters,
-        openSubagents: (id, workspace) => SubagentSessionController.open({
-            parentSessionId: id,
-            rootSessionId: id,
-            backend: createSubagentBackend(store, workspace)
-        }),
+        onExecutionRegistered: services.agentResources.onExecutionRegistered,
         assertAdmission: services.assertSessionAdmission,
         epoch: services.openEpoch,
         canPublish: services.canPublishSession,
@@ -149,8 +139,7 @@ export function createSessionOpener(services) {
             refreshSessionAdapters,
             sessionInputs,
             withRecordProjection,
-            appendExtensionMessage,
-            startSubagentTurn: async (id, input) => (await openSession(id)).startSubagentTurn(input)
+            appendExtensionMessage
         });
         sessionRuntime.ensureSessionBackend(() => createExtensionSessionBackend({
             describe: async (call) => {
@@ -200,70 +189,32 @@ export function createSessionOpener(services) {
             messages: createSessionExtensionMessages({
                 sessionId,
                 store,
-                agents: () => sessionRuntime.agentsBackend,
                 runtime: (id) => sessionRuntimes.get(id),
                 models: () => services.modelState()
             }),
-            launch: createExtensionSessionLaunch(sessionSource.type, execution),
+            launch: createExtensionSessionLaunch(execution),
             diagnose: (code, operationId) => services.extensions.session(sessionId)?.diagnose({ code, operationId, sessionId })
         }));
-        if (sessionSource.type === 'user')
-            sessionRuntime.ensureAgentsBackend(() => createExtensionAgentsBackend({
-                existingController: () => sessionRuntime.subagents,
-                controller: async () => {
-                    // Access to managed children is not a new Execution admission for their parent.
-                    services.assertCanStart();
-                    if (sessionRuntime.subagents === undefined)
-                        await openSession(sessionId);
-                    if (!sessionRuntime.subagents)
-                        throw new AgentError('MAR_AGENT_SUBAGENT_FAILED', 'Session task controller is unavailable.');
-                    return sessionRuntime.subagents;
-                },
-                parent: (controller, call) => {
-                    const current = call.executionId === undefined
-                        ? undefined
-                        : controller.parentExecution(call.executionId);
-                    if (call.executionId !== undefined && !current)
-                        throw new AgentError('MAR_AGENT_SUBAGENT_FAILED', 'Parent Execution source is unavailable.');
-                    const state = services.modelState();
-                    const selected = state.models.get(state.defaultModelId);
-                    return {
-                        ...(current ?? {
-                            modelId: selected.id,
-                            reasoningEffort: selected.defaultReasoningEffort,
-                            models: state.models,
-                            emitTerminal: async () => { },
-                            startTurn: async (turn) => {
-                                const child = await openSession(turn.sessionId);
-                                return child.startSubagentTurn({
-                                    prompt: turn.prompt,
-                                    modelId: turn.modelId,
-                                    reasoningEffort: turn.reasoningEffort,
-                                    role: turn.role,
-                                    initialMailbox: turn.initialMailbox,
-                                    turnId: turn.turnId,
-                                    ...(turn.origin === undefined
-                                        ? {}
-                                        : { origin: restoreSubagentOrigin(turn.origin) }),
-                                    ...(turn.delivery === undefined ? {} : { delivery: turn.delivery })
-                                });
-                            }
-                        }),
-                        operationId: call.operationId,
-                        origin: { signal: call.signal, correlation: call },
-                        signal: call.signal,
-                        ...(call.ownerInstanceId === undefined
-                            ? {}
-                            : { ownerInstanceId: call.ownerInstanceId }),
-                        ...(call.extensionId === undefined ? {} : { extensionId: call.extensionId })
-                    };
-                }
-            }));
+        const inputSource = () => {
+            const current = services.extensions.operations.current();
+            return current && current.sessionId !== sessionId && current.extensionId
+                ? extensionInputSource(current)
+                : undefined;
+        };
+        const inputOptions = () => {
+            const source = inputSource();
+            return source ? { extensionSource: source } : {};
+        };
         return {
             id: sessionId,
-            run: (input) => execution('run', input),
-            plan: (input) => execution('plan', input),
-            steer: (input) => sessionRuntime.execution?.steer?.(input) ?? Promise.resolve({ status: 'notAccepted' }),
+            subscribe: (listener) => {
+                services.assertSessionAdmission(sessionId);
+                return sessionRuntime.subscribe(listener);
+            },
+            run: (input) => execution('run', input, input.clientMessageId ? inputOptions() : undefined),
+            plan: (input) => execution('plan', input, input.clientMessageId ? inputOptions() : undefined),
+            steer: (input) => sessionRuntime.execution?.steer?.(input, inputSource()) ??
+                Promise.resolve({ status: 'notAccepted' }),
             compact: (input = {}) => {
                 const requests = sessionRuntime.execution?.compactRequests;
                 if (requests) {
@@ -276,25 +227,7 @@ export function createSessionOpener(services) {
                 });
             },
             cancel: async (executionId) => sessionRuntime.cancelExecution(executionId),
-            startSubagentTurn: (turn) => execution(turn.role === 'explore' ? 'plan' : 'run', {
-                prompt: turn.prompt,
-                modelId: turn.modelId,
-                reasoningEffort: turn.reasoningEffort,
-                ...(turn.permissionMode === undefined ? {} : { permissionMode: turn.permissionMode })
-            }, {
-                publishHostEvents: false,
-                ...(turn.origin === undefined ? {} : { signal: turn.origin.signal }),
-                inputSource: turn.origin === undefined ? 'parent_agent' : 'extension',
-                ...(turn.origin === undefined
-                    ? {}
-                    : { extensionSource: extensionInputSource(turn.origin) }),
-                initialMailbox: turn.initialMailbox,
-                turnId: turn.turnId,
-                ...(turn.mcpExecutionScopeId === undefined
-                    ? {}
-                    : { mcpExecutionScopeId: turn.mcpExecutionScopeId }),
-                ...(turn.delivery ? { delivery: turn.delivery } : {})
-            })
+            joinExecution: (executionId) => sessionRuntime.joinExecution(executionId)
         };
     };
     return openSession;