nextclaw 0.16.31 → 0.16.33

package/dist/cli/index.js

@@ -698,11 +698,11 @@ function collectFiles(rootDir) {
 }
 function installBuiltinSkill(workdir, destinationDir, skillName) {
   const loader = new SkillsLoader(workdir);
-  const builtin = loader.listSkills(false).find((skill) => skill.name === skillName && skill.source === "builtin");
-  if (!builtin) {
-    throw new Error(`Builtin skill not found in local core bundle: ${skillName}`);
+  const workspaceSkill = loader.listSkills(false).find((skill) => skill.name === skillName && skill.source === "workspace");
+  if (!workspaceSkill) {
+    throw new Error(`Workspace skill not found in local installation: ${skillName}`);
   }
-  cpSync(dirname(builtin.path), destinationDir, { recursive: true, force: true });
+  cpSync(dirname(workspaceSkill.path), destinationDir, { recursive: true, force: true });
 }
 async function fetchMarketplaceSkillItem(apiBase, slug) {
   return runWithMarketplaceNetworkRetry(async () => {
@@ -5261,6 +5261,8 @@ import {
   InputBudgetPruner,
   getWorkspacePath as getWorkspacePath7,
   parseThinkingLevel as parseThinkingLevel2,
+  readSessionProjectRoot,
+  resolveSessionWorkspacePath,
   resolveThinkingLevel
 } from "@nextclaw/core";
 
@@ -5638,14 +5640,230 @@ import {
   SessionsHistoryTool,
   SessionsListTool,
   SessionsSendTool,
-  SpawnTool,
-  SubagentManager,
-  SubagentsTool,
   ToolRegistry,
   WebFetchTool,
   WebSearchTool,
   WriteFileTool
 } from "@nextclaw/core";
+
+// src/cli/commands/ncp/session-request/session-request.tool.ts
+import { Tool } from "@nextclaw/core";
+function readRequiredString(params, key) {
+  const value = params[key];
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(`${key} must be a non-empty string.`);
+  }
+  return value.trim();
+}
+function readOptionalString2(params, key) {
+  const value = params[key];
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+var SpawnChildSessionTool = class extends Tool {
+  constructor(broker) {
+    super();
+    this.broker = broker;
+  }
+  sourceSessionId = "";
+  sourceSessionMetadata = {};
+  agentId;
+  handoffDepth = 0;
+  get name() {
+    return "spawn";
+  }
+  get description() {
+    return "Create a child session, delegate a task to it, and continue this session when it finishes.";
+  }
+  get parameters() {
+    return {
+      type: "object",
+      properties: {
+        task: { type: "string", description: "Task to run inside the child session." },
+        label: { type: "string", description: "Optional child session title." },
+        model: { type: "string", description: "Optional model override for the child session." }
+      },
+      required: ["task"]
+    };
+  }
+  setContext = (params) => {
+    this.sourceSessionId = params.sourceSessionId;
+    this.sourceSessionMetadata = structuredClone(params.sourceSessionMetadata);
+    this.agentId = params.agentId;
+    this.handoffDepth = params.handoffDepth ?? 0;
+  };
+  execute = async (params, toolCallId) => {
+    const task = readRequiredString(params, "task");
+    return this.broker.spawnChildSessionAndRequest({
+      sourceSessionId: this.sourceSessionId,
+      sourceToolCallId: toolCallId,
+      sourceSessionMetadata: this.sourceSessionMetadata,
+      task,
+      title: readOptionalString2(params, "label"),
+      model: readOptionalString2(params, "model"),
+      handoffDepth: this.handoffDepth,
+      agentId: this.agentId
+    });
+  };
+};
+var SessionRequestTool = class extends Tool {
+  constructor(broker) {
+    super();
+    this.broker = broker;
+  }
+  sourceSessionId = "";
+  handoffDepth = 0;
+  get name() {
+    return "sessions_request";
+  }
+  get description() {
+    return "Send one task to another session. Use this after sessions_spawn or to reuse an existing session, and optionally resume this session when the target final reply is ready.";
+  }
+  get parameters() {
+    return {
+      type: "object",
+      properties: {
+        target: {
+          type: "object",
+          description: 'Target session reference. Pass an object like {"session_id":"..."}, not a bare string.',
+          properties: {
+            session_id: {
+              type: "string",
+              description: "Existing target session id."
+            }
+          },
+          required: ["session_id"]
+        },
+        task: {
+          type: "string",
+          description: "Task to send to the target session."
+        },
+        await: {
+          type: "string",
+          enum: ["final_reply"],
+          description: "Phase 1 requires waiting for the target final reply."
+        },
+        delivery: {
+          type: "string",
+          enum: ["none", "resume_source"],
+          description: "How the completion should be delivered back to the source session."
+        },
+        title: {
+          type: "string",
+          description: "Optional card title override."
+        }
+      },
+      required: ["target", "task", "await", "delivery"]
+    };
+  }
+  setContext = (params) => {
+    this.sourceSessionId = params.sourceSessionId;
+    this.handoffDepth = params.handoffDepth ?? 0;
+  };
+  execute = async (params, toolCallId) => {
+    const target = params.target;
+    if (!target || typeof target !== "object" || Array.isArray(target)) {
+      throw new Error("target must be an object.");
+    }
+    const task = readRequiredString(params, "task");
+    const awaitMode = readRequiredString(params, "await");
+    const deliveryMode = readRequiredString(params, "delivery");
+    if (awaitMode !== "final_reply") {
+      throw new Error('Phase 1 only supports await="final_reply".');
+    }
+    return this.broker.requestSession({
+      sourceSessionId: this.sourceSessionId,
+      sourceToolCallId: toolCallId,
+      targetSessionId: readRequiredString(target, "session_id"),
+      task,
+      title: readOptionalString2(params, "title"),
+      awaitMode: "final_reply",
+      deliveryMode,
+      handoffDepth: this.handoffDepth
+    });
+  };
+};
+
+// src/cli/commands/ncp/session-request/session-spawn.tool.ts
+import { Tool as Tool2 } from "@nextclaw/core";
+function readRequiredString2(value, key) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(`${key} must be a non-empty string.`);
+  }
+  return value.trim();
+}
+function readOptionalString3(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+var SessionSpawnTool = class extends Tool2 {
+  constructor(sessionCreationService) {
+    super();
+    this.sessionCreationService = sessionCreationService;
+  }
+  sourceSessionId = "";
+  sourceSessionMetadata = {};
+  agentId;
+  get name() {
+    return "sessions_spawn";
+  }
+  get description() {
+    return "Create a standalone session. Usually follow this with sessions_request if you want the new session to start working immediately.";
+  }
+  get parameters() {
+    return {
+      type: "object",
+      properties: {
+        task: {
+          type: "string",
+          description: "Seed text used to title the new session."
+        },
+        title: {
+          type: "string",
+          description: "Optional explicit session title."
+        },
+        model: {
+          type: "string",
+          description: "Optional model override for the new session."
+        }
+      },
+      required: ["task"]
+    };
+  }
+  setContext = (params) => {
+    this.sourceSessionId = params.sourceSessionId;
+    this.sourceSessionMetadata = structuredClone(params.sourceSessionMetadata);
+    this.agentId = params.agentId;
+  };
+  execute = async (params) => {
+    const task = readRequiredString2(params.task, "task");
+    const session = this.sessionCreationService.createSession({
+      task,
+      title: readOptionalString3(params.title),
+      sourceSessionMetadata: this.sourceSessionMetadata,
+      agentId: this.agentId,
+      model: readOptionalString3(params.model)
+    });
+    return {
+      kind: "nextclaw.session",
+      sessionId: session.sessionId,
+      ...session.parentSessionId ? { parentSessionId: session.parentSessionId } : {},
+      isChildSession: false,
+      lifecycle: session.lifecycle,
+      title: session.title,
+      sessionType: session.sessionType,
+      createdAt: session.createdAt
+    };
+  };
+};
+
+// src/cli/commands/ncp/nextclaw-ncp-tool-registry.ts
 function toToolParams(args) {
   if (isRecord3(args)) {
     return args;
@@ -5695,46 +5913,11 @@ var CoreToolNcpAdapter = class {
 var NextclawNcpToolRegistry = class {
   constructor(options) {
     this.options = options;
-    const initialConfig = this.options.getConfig();
-    this.subagents = new SubagentManager({
-      providerManager: this.options.providerManager,
-      workspace: initialConfig.agents.defaults.workspace,
-      bus: this.options.bus,
-      model: initialConfig.agents.defaults.model,
-      contextTokens: initialConfig.agents.defaults.contextTokens,
-      searchConfig: initialConfig.search,
-      execConfig: initialConfig.tools.exec,
-      restrictToWorkspace: initialConfig.tools.restrictToWorkspace,
-      completionSink: async (params) => {
-        const sessionId = params.origin.sessionKey?.trim();
-        if (!sessionId || !this.options.writeSubagentCompletionToSession) {
-          return;
-        }
-        await this.options.writeSubagentCompletionToSession({
-          sessionId,
-          runId: params.runId,
-          toolCallId: params.origin.toolCallId,
-          label: params.label,
-          task: params.task,
-          result: params.result,
-          status: params.status
-        });
-      }
-    });
   }
-  subagents;
   registry = new ToolRegistry();
   tools = /* @__PURE__ */ new Map();
   currentExtensionToolContext = {};
-  prepareForRun(context) {
-    this.subagents.updateRuntimeOptions({
-      model: context.model,
-      maxTokens: context.maxTokens,
-      contextTokens: context.contextTokens,
-      searchConfig: context.searchConfig,
-      execConfig: { timeout: context.execTimeoutSeconds },
-      restrictToWorkspace: context.restrictToWorkspace
-    });
+  prepareForRun = (context) => {
     this.currentExtensionToolContext = {
       config: context.config,
       workspaceDir: context.workspace,
@@ -5748,30 +5931,30 @@ var NextclawNcpToolRegistry = class {
     this.registerDefaultTools(context);
     this.registerExtensionTools(context);
     this.registerAdditionalTools(context);
-  }
-  listTools() {
+  };
+  listTools = () => {
     return [...this.tools.values()].filter((tool) => this.isToolAvailable(tool.name));
-  }
-  getTool(name) {
+  };
+  getTool = (name) => {
     if (!this.isToolAvailable(name)) {
       return void 0;
     }
     return this.tools.get(name);
-  }
-  getToolDefinitions() {
+  };
+  getToolDefinitions = () => {
     return this.listTools().map((tool) => ({
       name: tool.name,
       description: tool.description,
       parameters: tool.parameters
     }));
-  }
-  async execute(toolCallId, toolName, args) {
+  };
+  execute = async (toolCallId, toolName, args) => {
     if (this.registry.has(toolName)) {
       return this.registry.executeRaw(toolName, toToolParams(args), toolCallId);
     }
     return this.tools.get(toolName)?.execute(args);
-  }
-  registerDefaultTools(context) {
+  };
+  registerDefaultTools = (context) => {
     const allowedDir = context.restrictToWorkspace ? context.workspace : void 0;
     this.registerTool(new ReadFileTool(allowedDir));
     this.registerTool(new WriteFileTool(allowedDir));
@@ -5791,15 +5974,31 @@ var NextclawNcpToolRegistry = class {
     this.registerTool(new WebSearchTool(context.searchConfig));
     this.registerTool(new WebFetchTool());
     this.registerMessagingTools(context);
-    const spawnTool = new SpawnTool(this.subagents);
-    spawnTool.setContext(
-      context.channel,
-      context.chatId,
-      context.model,
-      context.sessionId,
-      context.agentId
-    );
+    const spawnTool = new SpawnChildSessionTool(this.options.sessionRequestBroker);
+    spawnTool.setContext({
+      sourceSessionId: context.sessionId,
+      sourceSessionMetadata: context.metadata,
+      agentId: context.agentId,
+      handoffDepth: context.handoffDepth
+    });
     this.registerTool(spawnTool);
+    const sessionsSpawnTool = new SessionSpawnTool(
+      this.options.sessionCreationService
+    );
+    sessionsSpawnTool.setContext({
+      sourceSessionId: context.sessionId,
+      sourceSessionMetadata: context.metadata,
+      agentId: context.agentId
+    });
+    this.registerTool(sessionsSpawnTool);
+    const sessionsRequestTool = new SessionRequestTool(
+      this.options.sessionRequestBroker
+    );
+    sessionsRequestTool.setContext({
+      sourceSessionId: context.sessionId,
+      handoffDepth: context.handoffDepth
+    });
+    this.registerTool(sessionsRequestTool);
     this.registerTool(new SessionsListTool(this.options.sessionManager));
     this.registerTool(new SessionsHistoryTool(this.options.sessionManager));
     const sessionsSendTool = new SessionsSendTool(this.options.sessionManager, this.options.bus);
@@ -5814,12 +6013,11 @@ var NextclawNcpToolRegistry = class {
     this.registerTool(sessionsSendTool);
     this.registerTool(new MemorySearchTool(context.workspace));
     this.registerTool(new MemoryGetTool(context.workspace));
-    this.registerTool(new SubagentsTool(this.subagents));
     const gatewayTool = new GatewayTool(this.options.gatewayController);
     gatewayTool.setContext({ sessionKey: context.sessionId });
     this.registerTool(gatewayTool);
-  }
-  registerMessagingTools(context) {
+  };
+  registerMessagingTools = (context) => {
     const accountId = readMetadataAccountId(context.metadata, {});
     const messageTool = new MessageTool((message) => this.options.bus.publishOutbound(message));
     messageTool.setContext(context.channel, context.chatId, accountId ?? null);
@@ -5829,8 +6027,8 @@ var NextclawNcpToolRegistry = class {
       cronTool.setContext(context.channel, context.chatId, accountId ?? null);
       this.registerTool(cronTool);
     }
-  }
-  registerExtensionTools(context) {
+  };
+  registerExtensionTools = (context) => {
     const extensionRegistry = this.options.getExtensionRegistry?.();
     if (!extensionRegistry || extensionRegistry.tools.length === 0) {
       return;
@@ -5854,15 +6052,15 @@ var NextclawNcpToolRegistry = class {
         );
       }
     }
-  }
-  registerTool(tool) {
+  };
+  registerTool = (tool) => {
     this.registry.register(tool);
     this.tools.set(
       tool.name,
       new CoreToolNcpAdapter(tool, async (toolName, args) => this.registry.execute(toolName, toToolParams(args)))
     );
-  }
-  registerAdditionalTools(context) {
+  };
+  registerAdditionalTools = (context) => {
     const tools = this.options.getAdditionalTools?.(context) ?? [];
     for (const tool of tools) {
       if (this.tools.has(tool.name)) {
@@ -5870,11 +6068,11 @@ var NextclawNcpToolRegistry = class {
       }
       this.tools.set(tool.name, tool);
     }
-  }
-  isToolAvailable(name) {
+  };
+  isToolAvailable = (name) => {
     const coreTool = this.registry.get(name);
     return coreTool ? coreTool.isAvailable() : true;
-  }
+  };
 };
 function resolveAgentHandoffDepth(metadata) {
   const rawDepth = Number(metadata.agent_handoff_depth ?? 0);
@@ -5982,6 +6180,19 @@ function prependRequestedSkills(content, requestedSkillNames) {
 
 ${content}`;
 }
+function buildSessionOrchestrationSection() {
+  return [
+    "## Session Orchestration",
+    "- `spawn` creates a child session for delegated sub-work that should report completion back into the current session.",
+    "- Use `spawn` when the work is a subtask of the current flow and the user expects this session to continue after that child finishes.",
+    "- `sessions_spawn` creates a standalone session. Use it when the work should live in its own thread, remain independently reviewable later, or continue outside the current flow.",
+    "- `sessions_request` sends one task to another session. Use it to reuse an existing session, or immediately after `sessions_spawn` when a new standalone session should start working right away.",
+    "- If the goal is 'open a new session and have it do something now', the usual sequence is: 1) call `sessions_spawn`; 2) call `sessions_request` with that returned `sessionId`.",
+    '- `sessions_request.target` must be an object shaped like `{ "session_id": "<target-session-id>" }`. Do not pass a bare string.',
+    '- Prefer `delivery="resume_source"` when the current session should continue after the target session produces its final reply. Use `delivery="none"` when you only want the target session to run independently.',
+    "- Do not use `spawn` for long-lived independent threads when `sessions_spawn` plus `sessions_request` would match the user's intent better."
+  ].join("\n");
+}
 function filterTools(toolDefinitions, requestedToolNames) {
   if (toolDefinitions.length === 0) {
     return void 0;
@@ -6011,7 +6222,7 @@ var NextclawNcpContextBuilder = class {
     this.options = options;
   }
   inputBudgetPruner = new InputBudgetPruner();
-  prepare(input, _options) {
+  prepare = (input, _options) => {
     const config2 = this.options.getConfig();
     const profile = resolvePrimaryAgentProfile(config2);
     const requestMetadata = mergeInputMetadata(input);
@@ -6021,6 +6232,10 @@ var NextclawNcpContextBuilder = class {
       requestMetadata,
       fallbackModel: profile.model
     });
+    const effectiveWorkspace = resolveSessionWorkspacePath({
+      sessionMetadata: session.metadata,
+      workspace: profile.workspace
+    });
     syncSessionThinkingPreference({ session, requestMetadata });
     const { channel, chatId } = resolveSessionChannelContext({
       session,
@@ -6058,7 +6273,7 @@ var NextclawNcpContextBuilder = class {
       model: effectiveModel,
       restrictToWorkspace: profile.restrictToWorkspace,
       searchConfig: profile.searchConfig,
-      workspace: profile.workspace
+      workspace: effectiveWorkspace
     });
     const accountId = readAccountIdForHints(requestMetadata, session.metadata);
     const messageToolHints = this.options.resolveMessageToolHints?.({
@@ -6068,7 +6283,15 @@ var NextclawNcpContextBuilder = class {
       accountId: accountId ?? null
     });
     const toolDefinitions = this.options.toolRegistry.getToolDefinitions();
-    const contextBuilder = new ContextBuilder(profile.workspace, config2.agents.context);
+    const additionalSystemSections = [buildSessionOrchestrationSection()];
+    const contextBuilder = new ContextBuilder(
+      effectiveWorkspace,
+      config2.agents.context,
+      {
+        hostWorkspace: profile.workspace,
+        sessionProjectRoot: readSessionProjectRoot(session.metadata)
+      }
+    );
     const sessionMessages = _options?.sessionMessages ?? [];
     const messages = contextBuilder.buildMessages({
       history: toLegacyMessages([...sessionMessages], {
@@ -6082,7 +6305,8 @@ var NextclawNcpContextBuilder = class {
       thinkingLevel: runtimeThinking,
       skillNames: requestedSkillNames,
       messageToolHints,
-      availableTools: buildToolCatalogEntries(toolDefinitions)
+      availableTools: buildToolCatalogEntries(toolDefinitions),
+      additionalSystemSections
     });
     messages[messages.length - 1] = {
       role: currentTurn.currentRole,
@@ -6098,11 +6322,20 @@ var NextclawNcpContextBuilder = class {
       model: effectiveModel,
       thinkingLevel: runtimeThinking
     };
-  }
+  };
 };
 
 // src/cli/commands/ncp/nextclaw-agent-session-store.ts
 import { sanitizeAssistantReplyTags as sanitizeAssistantReplyTags2 } from "@nextclaw/ncp";
+
+// src/cli/commands/ncp/nextclaw-agent-session-metadata.utils.ts
+function resolvePersistedSessionMetadata(params) {
+  const messageMetadata = extractMessageMetadata(params.sessionRecord.messages);
+  const nextMetadata = params.preserveExistingMetadata ? mergeSessionMetadata(params.currentMetadata, messageMetadata) : mergeSessionMetadata({}, messageMetadata);
+  return mergeSessionMetadata(nextMetadata, cloneMetadata(params.sessionRecord.metadata));
+}
+
+// src/cli/commands/ncp/nextclaw-agent-session-store.ts
 function tryParseJson(value) {
   try {
     return JSON.parse(value);
@@ -6182,8 +6415,7 @@ function parseLegacyToolCalls(value) {
   }).filter((entry) => entry !== null);
 }
 function createMessageId(sessionId, index, role, timestamp) {
-  const safeRole = role.trim().toLowerCase() || "message";
-  return `${sessionId}:${safeRole}:${index}:${timestamp}`;
+  return `${sessionId}:${role.trim().toLowerCase() || "message"}:${index}:${timestamp}`;
 }
 function isNcpMessagePart(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value) && typeof value.type === "string";
@@ -6360,19 +6592,14 @@ var NextclawAgentSessionStore = class {
     this.sessionManager = sessionManager;
     this.options = options;
   }
-  async getSession(sessionId) {
+  getSession = async (sessionId) => {
     const session = this.sessionManager.getIfExists(sessionId);
     if (!session) {
       return null;
     }
-    return {
-      sessionId,
-      messages: toNcpMessages(sessionId, session.messages),
-      updatedAt: session.updatedAt.toISOString(),
-      metadata: structuredClone(session.metadata)
-    };
-  }
-  async listSessions() {
+    return { sessionId, messages: toNcpMessages(sessionId, session.messages), updatedAt: session.updatedAt.toISOString(), metadata: structuredClone(session.metadata) };
+  };
+  listSessions = async () => {
     const records = this.sessionManager.listSessions();
     const sessions = [];
     for (const record of records) {
@@ -6384,27 +6611,22 @@ var NextclawAgentSessionStore = class {
       if (!session) {
         continue;
       }
-      sessions.push({
-        sessionId,
-        messages: toNcpMessages(sessionId, session.messages),
-        updatedAt: session.updatedAt.toISOString(),
-        metadata: structuredClone(session.metadata)
-      });
+      sessions.push({ sessionId, messages: toNcpMessages(sessionId, session.messages), updatedAt: session.updatedAt.toISOString(), metadata: structuredClone(session.metadata) });
     }
     sessions.sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
     return sessions;
-  }
-  async saveSession(sessionRecord) {
+  };
+  persistSession = async (sessionRecord, options) => {
     if (this.options.writeMode === "runtime-owned") {
       return;
     }
     const session = this.sessionManager.getIfExists(sessionRecord.sessionId) ?? this.sessionManager.getOrCreate(sessionRecord.sessionId);
     const legacyMessages = toLegacyMessages(sessionRecord.messages);
-    const nextMetadata = mergeSessionMetadata(
-      session.metadata,
-      extractMessageMetadata(sessionRecord.messages)
-    );
-    session.metadata = mergeSessionMetadata(nextMetadata, cloneMetadata(sessionRecord.metadata));
+    session.metadata = resolvePersistedSessionMetadata({
+      currentMetadata: session.metadata,
+      sessionRecord,
+      preserveExistingMetadata: options.preserveExistingMetadata
+    });
     this.sessionManager.clear(session);
     for (const message of legacyMessages) {
       this.sessionManager.appendEvent(session, {
@@ -6420,8 +6642,18 @@ var NextclawAgentSessionStore = class {
     }
     this.sessionManager.save(session);
     this.options.onSessionUpdated?.(sessionRecord.sessionId);
-  }
-  async deleteSession(sessionId) {
+  };
+  saveSession = async (sessionRecord) => {
+    await this.persistSession(sessionRecord, {
+      preserveExistingMetadata: true
+    });
+  };
+  replaceSession = async (sessionRecord) => {
+    await this.persistSession(sessionRecord, {
+      preserveExistingMetadata: false
+    });
+  };
+  deleteSession = async (sessionId) => {
     const existing = await this.getSession(sessionId);
     if (!existing) {
       return null;
@@ -6429,104 +6661,8 @@ var NextclawAgentSessionStore = class {
     this.sessionManager.delete(sessionId);
     this.options.onSessionUpdated?.(sessionId);
     return existing;
-  }
-};
-
-// src/cli/commands/ncp/ncp-subagent-completion-message.ts
-import {
-  NCP_INTERNAL_VISIBILITY_METADATA_KEY
-} from "@nextclaw/ncp";
-function escapeXml(value) {
-  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
-}
-function buildSubagentCompletionFollowUpMessage(params) {
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-  const statusLabel = params.status === "ok" ? "completed" : "failed";
-  return {
-    id: `${params.sessionId}:system:subagent-follow-up:${timestamp}`,
-    sessionId: params.sessionId,
-    role: "user",
-    status: "final",
-    timestamp,
-    parts: [
-      {
-        type: "text",
-        text: [
-          "<task-notification>",
-          "<source>subagent_completion</source>",
-          `<label>${escapeXml(params.label)}</label>`,
-          `<status>${statusLabel}</status>`,
-          `<delegated-task>${escapeXml(params.task)}</delegated-task>`,
-          `<result>${escapeXml(params.result)}</result>`,
-          "<instructions>This is an internal worker completion notification, not a new end-user message. Continue the parent task using this result. If the user's request is complete, answer directly. If more work is needed, continue reasoning and use tools. Do not mention this hidden notification unless the user explicitly asks about internal behavior.</instructions>",
-          "</task-notification>"
-        ].join("\n")
-      }
-    ],
-    metadata: {
-      [NCP_INTERNAL_VISIBILITY_METADATA_KEY]: "hidden",
-      system_event_kind: "subagent_completion_follow_up",
-      subagent_label: params.label,
-      subagent_status: params.status,
-      subagent_task: params.task
-    }
   };
-}
-
-// src/cli/commands/ncp/ncp-subagent-completion-follow-up.ts
-async function consumeAgentRun(events) {
-  for await (const _event of events) {
-    void _event;
-  }
-}
-async function sleep(ms) {
-  await new Promise((resolve16) => setTimeout(resolve16, ms));
-}
-async function waitForSessionToBecomeIdle(params) {
-  const timeoutMs = params.timeoutMs ?? 15e3;
-  const intervalMs = params.intervalMs ?? 150;
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() <= deadline) {
-    const summary = await params.backend.getSession(params.sessionId);
-    if (!summary) {
-      return false;
-    }
-    if (summary.status !== "running") {
-      return true;
-    }
-    await sleep(intervalMs);
-  }
-  return false;
-}
-async function persistSubagentCompletionAndResumeParent(params) {
-  const isIdle = await waitForSessionToBecomeIdle({
-    backend: params.backend,
-    sessionId: params.completion.sessionId
-  });
-  if (!isIdle) {
-    return;
-  }
-  if (params.completion.toolCallId?.trim()) {
-    await params.backend.updateToolCallResult(
-      params.completion.sessionId,
-      params.completion.toolCallId.trim(),
-      {
-        kind: "nextclaw.subagent_run",
-        runId: params.completion.runId,
-        label: params.completion.label,
-        task: params.completion.task,
-        status: params.completion.status === "ok" ? "completed" : "failed",
-        result: params.completion.result
-      }
-    );
-  }
-  await consumeAgentRun(
-    params.backend.send({
-      sessionId: params.completion.sessionId,
-      message: buildSubagentCompletionFollowUpMessage(params.completion)
-    })
-  );
-}
+};
 
 // src/cli/commands/ncp/provider-manager-ncp-llm-api.ts
 import { parseThinkingLevel as parseThinkingLevel3 } from "@nextclaw/core";
@@ -6645,6 +6781,569 @@ var ProviderManagerNcpLLMApi = class {
   }
 };
 
+// src/cli/commands/ncp/session-request/session-creation.service.ts
+import { randomUUID } from "crypto";
+var DEFAULT_SESSION_TYPE = "native";
+var DEFAULT_LIFECYCLE = "persistent";
+var SESSION_METADATA_LABEL_KEY = "label";
+var CHILD_SESSION_PARENT_METADATA_KEY = "parent_session_id";
+var CHILD_SESSION_REQUEST_METADATA_KEY = "spawned_by_request_id";
+var CHILD_SESSION_LIFECYCLE_METADATA_KEY = "session_lifecycle";
+var CHILD_SESSION_PROMOTED_METADATA_KEY = "child_session_promoted";
+function readOptionalString4(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function summarizeTask(task) {
+  const normalized = task.trim().replace(/\s+/g, " ");
+  if (!normalized) {
+    return "Session";
+  }
+  if (normalized.length <= 72) {
+    return normalized;
+  }
+  return `${normalized.slice(0, 69)}...`;
+}
+function cloneInheritedMetadata(sourceMetadata) {
+  const nextMetadata = {};
+  const inheritedKeys = [
+    "session_type",
+    "preferred_model",
+    "preferred_thinking",
+    "project_root",
+    "requested_skill_refs",
+    "codex_runtime_backend",
+    "reasoningNormalizationMode",
+    "reasoning_normalization_mode"
+  ];
+  for (const key of inheritedKeys) {
+    if (!Object.prototype.hasOwnProperty.call(sourceMetadata, key)) {
+      continue;
+    }
+    nextMetadata[key] = structuredClone(sourceMetadata[key]);
+  }
+  return nextMetadata;
+}
+function buildSessionId(agentId) {
+  void agentId;
+  return `ncp-${Date.now().toString(36)}-${randomUUID().replace(/-/g, "").slice(0, 8)}`;
+}
+var SessionCreationService = class {
+  constructor(sessionManager, onSessionUpdated) {
+    this.sessionManager = sessionManager;
+    this.onSessionUpdated = onSessionUpdated;
+  }
+  createSession = (params) => {
+    const sessionId = buildSessionId(params.agentId);
+    const now3 = (/* @__PURE__ */ new Date()).toISOString();
+    const session = this.sessionManager.getOrCreate(sessionId);
+    const title = readOptionalString4(params.title) ?? summarizeTask(params.task);
+    const metadata = cloneInheritedMetadata(params.sourceSessionMetadata);
+    const parentSessionId = readOptionalString4(params.parentSessionId);
+    const requestId = readOptionalString4(params.requestId);
+    const sessionType = readOptionalString4(params.sessionType) ?? readOptionalString4(metadata.session_type) ?? DEFAULT_SESSION_TYPE;
+    metadata.session_type = sessionType;
+    metadata[SESSION_METADATA_LABEL_KEY] = title;
+    metadata[CHILD_SESSION_LIFECYCLE_METADATA_KEY] = DEFAULT_LIFECYCLE;
+    if (parentSessionId) {
+      metadata[CHILD_SESSION_PARENT_METADATA_KEY] = parentSessionId;
+      metadata[CHILD_SESSION_PROMOTED_METADATA_KEY] = false;
+    }
+    if (requestId) {
+      metadata[CHILD_SESSION_REQUEST_METADATA_KEY] = requestId;
+    }
+    if (readOptionalString4(params.model)) {
+      metadata.model = params.model?.trim();
+      metadata.preferred_model = params.model?.trim();
+    }
+    if (readOptionalString4(params.thinkingLevel)) {
+      metadata.thinking = params.thinkingLevel?.trim();
+      metadata.preferred_thinking = params.thinkingLevel?.trim();
+    }
+    if (readOptionalString4(params.projectRoot)) {
+      metadata.project_root = params.projectRoot?.trim();
+    }
+    session.metadata = metadata;
+    session.updatedAt = new Date(now3);
+    this.sessionManager.save(session);
+    this.onSessionUpdated?.(sessionId);
+    return {
+      sessionId,
+      sessionType,
+      runtimeFamily: "native",
+      ...parentSessionId ? { parentSessionId } : {},
+      ...requestId ? { spawnedByRequestId: requestId } : {},
+      lifecycle: DEFAULT_LIFECYCLE,
+      title,
+      metadata,
+      createdAt: session.createdAt.toISOString(),
+      updatedAt: session.updatedAt.toISOString()
+    };
+  };
+  createChildSession = (params) => {
+    return this.createSession(params);
+  };
+  promoteChildSession = (params) => {
+    const session = this.sessionManager.getIfExists(params.sessionId);
+    if (!session) {
+      return false;
+    }
+    session.metadata = {
+      ...session.metadata,
+      [CHILD_SESSION_PROMOTED_METADATA_KEY]: params.promoted
+    };
+    session.updatedAt = /* @__PURE__ */ new Date();
+    this.sessionManager.save(session);
+    this.onSessionUpdated?.(params.sessionId);
+    return true;
+  };
+  isChildSessionRecord = (metadata) => {
+    return Boolean(readOptionalString4(metadata?.[CHILD_SESSION_PARENT_METADATA_KEY]));
+  };
+};
+
+// src/cli/commands/ncp/session-request/session-request-broker.ts
+import {
+  NcpEventType
+} from "@nextclaw/ncp";
+import { randomUUID as randomUUID2 } from "crypto";
+function readOptionalString5(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function summarizeTask2(task) {
+  const normalized = task.trim().replace(/\s+/g, " ");
+  if (!normalized) {
+    return "Session request";
+  }
+  if (normalized.length <= 72) {
+    return normalized;
+  }
+  return `${normalized.slice(0, 69)}...`;
+}
+function buildUserMessage(params) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    id: `${params.sessionId}:user:session-request:${params.requestId}`,
+    sessionId: params.sessionId,
+    role: "user",
+    status: "final",
+    timestamp,
+    parts: [{ type: "text", text: params.task }],
+    metadata: {
+      session_request_id: params.requestId
+    }
+  };
+}
+function extractMessageText(message) {
+  if (!message) {
+    return void 0;
+  }
+  const parts = message.parts.flatMap((part) => {
+    if (part.type === "text" || part.type === "rich-text") {
+      return [part.text];
+    }
+    return [];
+  }).map((part) => part.trim()).filter((part) => part.length > 0);
+  if (parts.length === 0) {
+    return void 0;
+  }
+  return parts.join("\n\n");
+}
+function findLatestAssistantMessage(messages) {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index];
+    if (message?.role === "assistant") {
+      return message;
+    }
+  }
+  return void 0;
+}
+function readParentSessionId(metadata) {
+  return readOptionalString5(metadata?.[CHILD_SESSION_PARENT_METADATA_KEY]) ?? void 0;
+}
+function buildToolResult(params) {
+  return {
+    kind: "nextclaw.session_request",
+    requestId: params.request.requestId,
+    sessionId: params.request.targetSessionId,
+    targetKind: params.isChildSession ? "child" : "session",
+    ...params.parentSessionId ? { parentSessionId: params.parentSessionId } : {},
+    ...params.spawnedByRequestId ? { spawnedByRequestId: params.spawnedByRequestId } : {},
+    isChildSession: params.isChildSession,
+    lifecycle: "persistent",
+    ...params.title.trim() ? { title: params.title } : {},
+    task: params.task,
+    status: params.request.status,
+    awaitMode: params.request.awaitMode,
+    deliveryMode: params.request.deliveryMode,
+    ...params.request.finalResponseText ? { finalResponseText: params.request.finalResponseText } : {},
+    ...params.request.error ? { error: params.request.error } : {},
+    ...params.message ? { message: params.message } : {}
+  };
+}
+var SessionRequestBroker = class {
+  constructor(sessionManager, sessionCreationService, deliveryService, resolveBackend, onSessionUpdated) {
+    this.sessionManager = sessionManager;
+    this.sessionCreationService = sessionCreationService;
+    this.deliveryService = deliveryService;
+    this.resolveBackend = resolveBackend;
+    this.onSessionUpdated = onSessionUpdated;
+  }
+  spawnChildSessionAndRequest = async (params) => {
+    const requestId = randomUUID2();
+    const childSession = this.sessionCreationService.createChildSession({
+      parentSessionId: params.sourceSessionId,
+      task: params.task,
+      title: params.title,
+      sourceSessionMetadata: params.sourceSessionMetadata,
+      agentId: params.agentId,
+      model: params.model,
+      thinkingLevel: params.thinkingLevel,
+      sessionType: params.sessionType,
+      projectRoot: params.projectRoot,
+      requestId
+    });
+    return this.dispatchRequest({
+      requestId,
+      sourceSessionId: params.sourceSessionId,
+      sourceToolCallId: params.sourceToolCallId,
+      targetSessionId: childSession.sessionId,
+      task: params.task,
+      title: childSession.title ?? summarizeTask2(params.task),
+      handoffDepth: params.handoffDepth ?? 0,
+      awaitMode: "final_reply",
+      deliveryMode: "resume_source",
+      isChildSession: true,
+      parentSessionId: params.sourceSessionId,
+      spawnedByRequestId: requestId
+    });
+  };
+  requestSession = async (params) => {
+    if (params.targetSessionId.trim() === params.sourceSessionId.trim()) {
+      throw new Error("sessions_request cannot target the current session.");
+    }
+    const backend = this.resolveBackend();
+    if (!backend) {
+      throw new Error("NCP backend is not ready for session requests.");
+    }
+    const targetSummary = await backend.getSession(params.targetSessionId.trim());
+    if (!targetSummary) {
+      throw new Error(`Target session not found: ${params.targetSessionId}`);
+    }
+    const parentSessionId = readParentSessionId(targetSummary.metadata);
+    return this.dispatchRequest({
+      requestId: randomUUID2(),
+      sourceSessionId: params.sourceSessionId,
+      sourceToolCallId: params.sourceToolCallId,
+      targetSessionId: params.targetSessionId.trim(),
+      task: params.task,
+      title: readOptionalString5(params.title) ?? readOptionalString5(targetSummary.metadata?.label) ?? summarizeTask2(params.task),
+      handoffDepth: params.handoffDepth ?? 0,
+      awaitMode: params.awaitMode,
+      deliveryMode: params.deliveryMode,
+      isChildSession: Boolean(parentSessionId),
+      parentSessionId: parentSessionId ?? void 0,
+      spawnedByRequestId: void 0
+    });
+  };
+  dispatchRequest = async (params) => {
+    const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+    const request = {
+      requestId: params.requestId,
+      sourceSessionId: params.sourceSessionId,
+      targetSessionId: params.targetSessionId,
+      sourceToolCallId: params.sourceToolCallId,
+      rootRequestId: params.requestId,
+      handoffDepth: params.handoffDepth,
+      awaitMode: params.awaitMode,
+      deliveryMode: params.deliveryMode,
+      status: "running",
+      createdAt,
+      startedAt: createdAt,
+      metadata: {
+        title: params.title,
+        task: params.task,
+        is_child_session: params.isChildSession,
+        ...params.parentSessionId ? { parent_session_id: params.parentSessionId } : {}
+      }
+    };
+    void this.runRequest({
+      request,
+      task: params.task,
+      title: params.title,
+      isChildSession: params.isChildSession,
+      parentSessionId: params.parentSessionId
+    }).catch((error) => {
+      console.error(
+        `[session-request] Background request ${params.requestId} crashed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    });
+    return buildToolResult({
+      request,
+      task: params.task,
+      title: params.title,
+      isChildSession: params.isChildSession,
+      parentSessionId: params.parentSessionId,
+      spawnedByRequestId: params.spawnedByRequestId,
+      message: `Session request started. You'll receive the final reply when it finishes.`
+    });
+  };
+  runRequest = async (params) => {
+    let completedMessage;
+    try {
+      const backend = this.resolveBackend();
+      if (!backend) {
+        throw new Error("NCP backend is not ready for session request execution.");
+      }
+      const message = buildUserMessage({
+        sessionId: params.request.targetSessionId,
+        requestId: params.request.requestId,
+        task: params.task
+      });
+      for await (const event of backend.send({
+        sessionId: params.request.targetSessionId,
+        message
+      })) {
+        if (event.type === NcpEventType.MessageAccepted) {
+          this.handleRequestEvent(params.request, event);
+          continue;
+        }
+        if (event.type === NcpEventType.MessageFailed) {
+          throw new Error(event.payload.error.message);
+        }
+        if (event.type === NcpEventType.RunError) {
+          throw new Error(event.payload.error ?? "Session request failed.");
+        }
+        if (event.type === NcpEventType.MessageCompleted) {
+          completedMessage = event.payload.message;
+        }
+      }
+      if (!completedMessage) {
+        const targetMessages = await backend.listSessionMessages(
+          params.request.targetSessionId
+        );
+        completedMessage = findLatestAssistantMessage(targetMessages);
+      }
+      if (!completedMessage) {
+        throw new Error("Session request completed without a final reply.");
+      }
+      const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const finalResponseText = extractMessageText(completedMessage);
+      const completedRequest = {
+        ...params.request,
+        status: "completed",
+        completedAt,
+        finalResponseMessageId: completedMessage?.id,
+        finalResponseText
+      };
+      this.appendRequestEvent(params.request.sourceSessionId, "session.request.completed", completedRequest);
+      this.appendRequestEvent(params.request.targetSessionId, "session.request.completed", completedRequest);
+      const result = buildToolResult({
+        request: completedRequest,
+        task: params.task,
+        title: params.title,
+        isChildSession: params.isChildSession,
+        parentSessionId: params.parentSessionId,
+        spawnedByRequestId: params.spawnedByRequestId
+      });
+      await this.deliveryService.publishToolResult({
+        request: completedRequest,
+        result
+      });
+      if (completedRequest.deliveryMode === "resume_source") {
+        await this.deliveryService.resumeSourceSession({
+          request: completedRequest,
+          result
+        });
+      }
+    } catch (error) {
+      const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const failedRequest = {
+        ...params.request,
+        status: "failed",
+        completedAt,
+        error: error instanceof Error ? error.message : String(error)
+      };
+      this.appendRequestEvent(params.request.sourceSessionId, "session.request.failed", failedRequest);
+      this.appendRequestEvent(params.request.targetSessionId, "session.request.failed", failedRequest);
+      const result = buildToolResult({
+        request: failedRequest,
+        task: params.task,
+        title: params.title,
+        isChildSession: params.isChildSession,
+        parentSessionId: params.parentSessionId,
+        spawnedByRequestId: params.spawnedByRequestId
+      });
+      await this.deliveryService.publishToolResult({
+        request: failedRequest,
+        result
+      });
+      if (failedRequest.deliveryMode === "resume_source") {
+        await this.deliveryService.resumeSourceSession({
+          request: failedRequest,
+          result
+        });
+      }
+    }
+  };
+  handleRequestEvent = (request, event) => {
+    if (event.type === NcpEventType.MessageAccepted) {
+      const acceptedRequest = {
+        ...request,
+        targetMessageId: event.payload.messageId
+      };
+      this.appendRequestEvent(request.sourceSessionId, "session.request.accepted", acceptedRequest);
+      this.appendRequestEvent(request.targetSessionId, "session.request.accepted", acceptedRequest);
+    }
+  };
+  appendRequestEvent = (sessionId, type, request) => {
+    const session = this.sessionManager.getOrCreate(sessionId);
+    this.sessionManager.appendEvent(session, {
+      type,
+      data: {
+        request: structuredClone(request)
+      }
+    });
+    this.sessionManager.save(session);
+    this.onSessionUpdated?.(sessionId);
+  };
+};
+
+// src/cli/commands/ncp/session-request/session-request-delivery.service.ts
+import {
+  NCP_INTERNAL_VISIBILITY_METADATA_KEY
+} from "@nextclaw/ncp";
+function escapeXml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+}
+async function consumeAgentRun(events) {
+  for await (const _event of events) {
+    void _event;
+  }
+}
+function runDetached(task, label) {
+  void task.catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`[session-request] ${label} failed: ${message}`);
+  });
+}
+function scheduleDetached(taskFactory, label) {
+  setTimeout(() => {
+    runDetached(taskFactory(), label);
+  }, 0);
+}
+async function sleep(ms) {
+  await new Promise((resolve16) => setTimeout(resolve16, ms));
+}
+async function waitForSessionToBecomeIdle(params) {
+  const timeoutMs = params.timeoutMs ?? 15e3;
+  const intervalMs = params.intervalMs ?? 150;
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() <= deadline) {
+    const summary = await params.backend.getSession(params.sessionId);
+    if (!summary) {
+      return false;
+    }
+    if (summary.status !== "running") {
+      return true;
+    }
+    await sleep(intervalMs);
+  }
+  return false;
+}
+function buildSessionRequestCompletionMessage(params) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const status = params.result.status === "completed" ? "completed" : "failed";
+  const responseText = params.result.finalResponseText ?? params.result.error ?? "";
+  const targetKind = params.result.targetKind;
+  const title = params.result.title ?? params.result.task;
+  return {
+    id: `${params.request.sourceSessionId}:system:session-request:${params.request.requestId}:${timestamp}`,
+    sessionId: params.request.sourceSessionId,
+    role: "user",
+    status: "final",
+    timestamp,
+    parts: [
+      {
+        type: "text",
+        text: [
+          "<session-request-completion>",
+          `<request-id>${escapeXml(params.request.requestId)}</request-id>`,
+          `<target-session-id>${escapeXml(params.request.targetSessionId)}</target-session-id>`,
+          `<target-kind>${escapeXml(targetKind)}</target-kind>`,
+          `<title>${escapeXml(title)}</title>`,
+          `<status>${escapeXml(status)}</status>`,
+          `<final-response>${escapeXml(responseText)}</final-response>`,
+          "<instructions>This is an internal delegated session completion notification. Continue the current task using this result. Do not mention this hidden notification unless the user explicitly asks about internal behavior.</instructions>",
+          "</session-request-completion>"
+        ].join("\n")
+      }
+    ],
+    metadata: {
+      [NCP_INTERNAL_VISIBILITY_METADATA_KEY]: "hidden",
+      system_event_kind: "session_request_completion",
+      session_request_id: params.request.requestId,
+      target_session_id: params.request.targetSessionId,
+      session_request_status: params.result.status
+    }
+  };
+}
+var SessionRequestDeliveryService = class {
+  constructor(resolveBackend) {
+    this.resolveBackend = resolveBackend;
+  }
+  publishToolResult = async (params) => {
+    if (!params.request.sourceToolCallId?.trim()) {
+      return;
+    }
+    const backend = this.resolveBackend();
+    if (!backend) {
+      throw new Error("NCP backend is not ready for session request delivery.");
+    }
+    const isIdle = await waitForSessionToBecomeIdle({
+      backend,
+      sessionId: params.request.sourceSessionId
+    });
+    if (!isIdle) {
+      return;
+    }
+    await backend.updateToolCallResult(
+      params.request.sourceSessionId,
+      params.request.sourceToolCallId.trim(),
+      params.result
+    );
+  };
+  resumeSourceSession = async (params) => {
+    const backend = this.resolveBackend();
+    if (!backend) {
+      throw new Error("NCP backend is not ready for source session resume.");
+    }
+    const isIdle = await waitForSessionToBecomeIdle({
+      backend,
+      sessionId: params.request.sourceSessionId
+    });
+    if (!isIdle) {
+      return;
+    }
+    scheduleDetached(
+      async () => consumeAgentRun(
+        backend.send({
+          sessionId: params.request.sourceSessionId,
+          message: buildSessionRequestCompletionMessage(params)
+        })
+      ),
+      `resume source session ${params.request.sourceSessionId}`
+    );
+  };
+};
+
 // src/cli/commands/ncp/ui-ncp-runtime-registry.ts
 import { toDisposable } from "@nextclaw/core";
 var DEFAULT_UI_NCP_RUNTIME_KIND = "native";
@@ -6799,10 +7498,13 @@ async function createMcpRuntimeSupport(getConfig) {
           console.warn(`[mcp] Failed to warm ${warmResult.name}: ${warmResult.error}`);
         }
       }
+    },
+    dispose: async () => {
+      await mcpRegistryService.close();
     }
   };
 }
-function createNativeRuntimeFactory(params, mcpToolRegistryAdapter, assetStore, resolveBackend) {
+function createNativeRuntimeFactory(params, mcpToolRegistryAdapter, assetStore, sessionCreationService, sessionRequestBroker) {
   return ({
     stateManager,
     sessionMetadata,
@@ -6828,24 +7530,8 @@ function createNativeRuntimeFactory(params, mcpToolRegistryAdapter, assetStore,
       gatewayController: params.gatewayController,
       getConfig: params.getConfig,
       getExtensionRegistry: params.getExtensionRegistry,
-      writeSubagentCompletionToSession: async (completion) => {
-        const backend = resolveBackend();
-        if (!backend) {
-          throw new Error("NCP backend is not ready for subagent completion persistence.");
-        }
-        await persistSubagentCompletionAndResumeParent({
-          backend,
-          completion: {
-            sessionId: completion.sessionId,
-            runId: completion.runId,
-            toolCallId: completion.toolCallId,
-            label: completion.label,
-            task: completion.task,
-            result: completion.result,
-            status: completion.status
-          }
-        });
-      },
+      sessionCreationService,
+      sessionRequestBroker,
       getAdditionalTools: (context) => [
         ...createAssetTools({
           assetStore
@@ -6882,25 +7568,29 @@ function createCodexAwareRuntimeFactory(params) {
 function resolveRegisteredRuntimeFactory(params) {
   return params.registration.kind === CODEX_RUNTIME_KIND ? createCodexAwareRuntimeFactory(params) : params.registration.createRuntime;
 }
-function createPluginRuntimeRegistrationController(params) {
-  const pluginRuntimeScopes = /* @__PURE__ */ new Map();
-  let pluginRuntimeSnapshotKey = "";
-  let activeExtensionRegistry;
-  const syncPluginRuntimeRegistrations = (extensionRegistry) => {
+var PluginRuntimeRegistrationController = class {
+  constructor(runtimeRegistry, getExtensionRegistry) {
+    this.runtimeRegistry = runtimeRegistry;
+    this.getExtensionRegistry = getExtensionRegistry;
+  }
+  pluginRuntimeScopes = /* @__PURE__ */ new Map();
+  pluginRuntimeSnapshotKey = "";
+  activeExtensionRegistry;
+  syncPluginRuntimeRegistrations = (extensionRegistry) => {
     const nextSnapshotKey = buildPluginRuntimeSnapshotKey(extensionRegistry);
-    if (nextSnapshotKey === pluginRuntimeSnapshotKey) {
+    if (nextSnapshotKey === this.pluginRuntimeSnapshotKey) {
       return;
     }
-    pluginRuntimeSnapshotKey = nextSnapshotKey;
-    for (const scope of pluginRuntimeScopes.values()) {
+    this.pluginRuntimeSnapshotKey = nextSnapshotKey;
+    for (const scope of this.pluginRuntimeScopes.values()) {
       scope.dispose();
     }
-    pluginRuntimeScopes.clear();
+    this.pluginRuntimeScopes.clear();
     for (const registration of extensionRegistry?.ncpAgentRuntimes ?? []) {
       const pluginId = registration.pluginId.trim() || registration.kind;
-      const scope = pluginRuntimeScopes.get(pluginId) ?? new DisposableStore();
-      pluginRuntimeScopes.set(pluginId, scope);
-      scope.add(params.runtimeRegistry.register({
+      const scope = this.pluginRuntimeScopes.get(pluginId) ?? new DisposableStore();
+      this.pluginRuntimeScopes.set(pluginId, scope);
+      scope.add(this.runtimeRegistry.register({
         kind: registration.kind,
         label: registration.label,
         createRuntime: resolveRegisteredRuntimeFactory({
@@ -6910,17 +7600,23 @@ function createPluginRuntimeRegistrationController(params) {
       }));
     }
   };
-  const resolveActiveExtensionRegistry = () => activeExtensionRegistry ?? params.getExtensionRegistry?.();
-  return {
-    refreshPluginRuntimeRegistrations: () => {
-      syncPluginRuntimeRegistrations(resolveActiveExtensionRegistry());
-    },
-    applyExtensionRegistry: (extensionRegistry) => {
-      activeExtensionRegistry = extensionRegistry;
-      syncPluginRuntimeRegistrations(extensionRegistry);
+  resolveActiveExtensionRegistry = () => this.activeExtensionRegistry ?? this.getExtensionRegistry?.();
+  refreshPluginRuntimeRegistrations = () => {
+    this.syncPluginRuntimeRegistrations(this.resolveActiveExtensionRegistry());
+  };
+  applyExtensionRegistry = (extensionRegistry) => {
+    this.activeExtensionRegistry = extensionRegistry;
+    this.syncPluginRuntimeRegistrations(extensionRegistry);
+  };
+  dispose = () => {
+    for (const scope of this.pluginRuntimeScopes.values()) {
+      scope.dispose();
     }
+    this.pluginRuntimeScopes.clear();
+    this.activeExtensionRegistry = void 0;
+    this.pluginRuntimeSnapshotKey = "";
   };
-}
+};
 function createUiNcpAgentHandle(params) {
   return {
     basePath: "/api/ncp/agent",
@@ -6942,7 +7638,8 @@ function createUiNcpAgentHandle(params) {
       resolveContentPath: (uri) => params.assetStore.resolveContentPath(uri)
     },
     applyExtensionRegistry: params.applyExtensionRegistry,
-    applyMcpConfig: params.applyMcpConfig
+    applyMcpConfig: params.applyMcpConfig,
+    dispose: params.dispose
   };
 }
 async function createUiNcpAgent(params) {
@@ -6950,28 +7647,38 @@ async function createUiNcpAgent(params) {
     onSessionUpdated: params.onSessionUpdated
   });
   const runtimeRegistry = new UiNcpRuntimeRegistry();
-  const { toolRegistryAdapter, applyMcpConfig } = await createMcpRuntimeSupport(params.getConfig);
+  const { toolRegistryAdapter, applyMcpConfig, dispose: disposeMcpRuntimeSupport } = await createMcpRuntimeSupport(params.getConfig);
   const assetStore = new LocalAssetStore({
     rootDir: join5(getDataDir7(), "assets")
   });
   let backend = null;
+  const sessionCreationService = new SessionCreationService(
+    params.sessionManager,
+    params.onSessionUpdated
+  );
+  const sessionRequestBroker = new SessionRequestBroker(
+    params.sessionManager,
+    sessionCreationService,
+    new SessionRequestDeliveryService(() => backend),
+    () => backend,
+    params.onSessionUpdated
+  );
   const createNativeRuntime = createNativeRuntimeFactory(
     params,
     toolRegistryAdapter,
     assetStore,
-    () => backend
+    sessionCreationService,
+    sessionRequestBroker
   );
   runtimeRegistry.register({
     kind: "native",
     label: "Native",
     createRuntime: createNativeRuntime
   });
-  const pluginRuntimeRegistrationController = createPluginRuntimeRegistrationController({
+  const pluginRuntimeRegistrationController = new PluginRuntimeRegistrationController(
     runtimeRegistry,
-    getConfig: params.getConfig,
-    getExtensionRegistry: params.getExtensionRegistry,
-    createNativeRuntime
-  });
+    params.getExtensionRegistry
+  );
   pluginRuntimeRegistrationController.refreshPluginRuntimeRegistrations();
   backend = new DefaultNcpAgentBackend({
     endpointId: "nextclaw-ui-agent",
@@ -6989,6 +7696,11 @@ async function createUiNcpAgent(params) {
     refreshPluginRuntimeRegistrations: pluginRuntimeRegistrationController.refreshPluginRuntimeRegistrations,
     applyExtensionRegistry: pluginRuntimeRegistrationController.applyExtensionRegistry,
     applyMcpConfig,
+    dispose: async () => {
+      pluginRuntimeRegistrationController.dispose();
+      await backend?.stop();
+      await disposeMcpRuntimeSupport();
+    },
     assetStore
   });
 }
@@ -8177,9 +8889,17 @@ var DEFERRED_NCP_AGENT_UNAVAILABLE = "ncp agent unavailable during startup";
 function createUnavailableError() {
   return new Error(DEFERRED_NCP_AGENT_UNAVAILABLE);
 }
-function createDeferredUiNcpAgent(basePath = DEFAULT_BASE_PATH) {
-  let activeAgent = null;
-  const endpoint = {
+var DeferredUiNcpAgentControllerOwner = class {
+  constructor(basePath) {
+    this.basePath = basePath;
+    this.agent = {
+      basePath,
+      agentClientEndpoint: this.endpoint
+    };
+  }
+  agent;
+  activeAgent = null;
+  endpoint = {
     manifest: {
       endpointKind: "agent",
       endpointId: "nextclaw-ui-agent-deferred",
@@ -8194,73 +8914,69 @@ function createDeferredUiNcpAgent(basePath = DEFAULT_BASE_PATH) {
         deferred: true
       }
     },
-    async start() {
-      await activeAgent?.agentClientEndpoint.start();
+    start: async () => {
+      await this.activeAgent?.agentClientEndpoint.start();
     },
-    async stop() {
-      await activeAgent?.agentClientEndpoint.stop();
+    stop: async () => {
+      await this.activeAgent?.agentClientEndpoint.stop();
     },
-    async emit(event) {
-      if (!activeAgent) {
+    emit: async (event) => {
+      if (!this.activeAgent) {
         throw createUnavailableError();
       }
-      await activeAgent.agentClientEndpoint.emit(event);
+      await this.activeAgent.agentClientEndpoint.emit(event);
     },
-    subscribe(listener) {
-      if (!activeAgent) {
+    subscribe: (listener) => {
+      if (!this.activeAgent) {
         return () => void 0;
       }
-      return activeAgent.agentClientEndpoint.subscribe(listener);
+      return this.activeAgent.agentClientEndpoint.subscribe(listener);
     },
-    async send(envelope) {
-      if (!activeAgent) {
+    send: async (envelope) => {
+      if (!this.activeAgent) {
         throw createUnavailableError();
       }
-      await activeAgent.agentClientEndpoint.send(envelope);
+      await this.activeAgent.agentClientEndpoint.send(envelope);
     },
-    async stream(payload) {
-      if (!activeAgent) {
+    stream: async (payload) => {
+      if (!this.activeAgent) {
         throw createUnavailableError();
       }
-      await activeAgent.agentClientEndpoint.stream(payload);
+      await this.activeAgent.agentClientEndpoint.stream(payload);
     },
-    async abort(payload) {
-      if (!activeAgent) {
+    abort: async (payload) => {
+      if (!this.activeAgent) {
         throw createUnavailableError();
       }
-      await activeAgent.agentClientEndpoint.abort(payload);
+      await this.activeAgent.agentClientEndpoint.abort(payload);
     }
   };
-  const agent = {
-    basePath,
-    agentClientEndpoint: endpoint
+  activate = (nextAgent) => {
+    this.activeAgent = nextAgent;
+    this.agent.basePath = nextAgent.basePath ?? this.basePath;
+    this.agent.streamProvider = nextAgent.streamProvider;
+    this.agent.listSessionTypes = nextAgent.listSessionTypes;
+    this.agent.assetApi = nextAgent.assetApi;
   };
-  const clear = () => {
-    activeAgent = null;
-    agent.basePath = basePath;
-    agent.streamProvider = void 0;
-    agent.listSessionTypes = void 0;
-    agent.assetApi = void 0;
+  clear = () => {
+    this.activeAgent = null;
+    this.agent.basePath = this.basePath;
+    this.agent.streamProvider = void 0;
+    this.agent.listSessionTypes = void 0;
+    this.agent.assetApi = void 0;
   };
-  return {
-    agent,
-    activate(nextAgent) {
-      activeAgent = nextAgent;
-      agent.basePath = nextAgent.basePath ?? basePath;
-      agent.streamProvider = nextAgent.streamProvider;
-      agent.listSessionTypes = nextAgent.listSessionTypes;
-      agent.assetApi = nextAgent.assetApi;
-    },
-    clear,
-    async close() {
-      const current = activeAgent;
-      clear();
-      await current?.agentClientEndpoint.stop();
-    },
-    isReady() {
-      return activeAgent !== null;
-    }
+  close = async () => {
+    const current = this.activeAgent;
+    this.clear();
+    await current?.agentClientEndpoint.stop();
+    await current?.dispose?.();
   };
+  isReady = () => {
+    return this.activeAgent !== null;
+  };
+};
+function createDeferredUiNcpAgent(basePath = DEFAULT_BASE_PATH) {
+  return new DeferredUiNcpAgentControllerOwner(basePath);
 }
 
 // src/cli/commands/service-gateway-startup.ts
@@ -8448,7 +9164,7 @@ var UiSessionService = class {
       onSessionUpdated: options.onSessionUpdated
     });
   }
-  async listSessions(options) {
+  listSessions = async (options) => {
     const sessions = await this.sessionStore.listSessions();
     return applyLimit(
       sessions.map(
@@ -8462,15 +9178,15 @@ var UiSessionService = class {
       ),
       options?.limit
     );
-  }
-  async listSessionMessages(sessionId, options) {
+  };
+  listSessionMessages = async (sessionId, options) => {
     const session = await this.sessionStore.getSession(sessionId);
     if (!session) {
       return [];
     }
     return applyLimit(session.messages.map((message) => structuredClone(message)), options?.limit);
-  }
-  async getSession(sessionId) {
+  };
+  getSession = async (sessionId) => {
     const session = await this.sessionStore.getSession(sessionId);
     if (!session) {
       return null;
@@ -8482,26 +9198,23 @@ var UiSessionService = class {
       status: "idle",
       metadata: session.metadata
     });
-  }
-  async updateSession(sessionId, patch) {
+  };
+  updateSession = async (sessionId, patch) => {
     const session = await this.sessionStore.getSession(sessionId);
-    if (!session) {
-      return null;
-    }
-    await this.sessionStore.saveSession({
+    await this.sessionStore.replaceSession({
       sessionId,
-      messages: session.messages.map((message) => structuredClone(message)),
+      messages: session ? session.messages.map((message) => structuredClone(message)) : [],
       updatedAt: now(),
       metadata: buildUpdatedMetadata({
-        existingMetadata: session.metadata,
+        existingMetadata: session?.metadata,
         patch
       })
     });
     return await this.getSession(sessionId);
-  }
-  async deleteSession(sessionId) {
+  };
+  deleteSession = async (sessionId) => {
     await this.sessionStore.deleteSession(sessionId);
-  }
+  };
 };
 
 // src/cli/commands/service-deferred-ncp-session-service.ts
@@ -9006,7 +9719,7 @@ function readStringList(value) {
   }
   return value.map((entry) => typeof entry === "string" ? entry.trim() : "").filter(Boolean);
 }
-function readOptionalString2(value) {
+function readOptionalString6(value) {
   if (typeof value !== "string") {
     return void 0;
   }
@@ -9016,10 +9729,10 @@ function readOptionalString2(value) {
 function resolvePluginRuntimeAttachments(ctx) {
   const mediaPaths = readStringList(ctx.MediaPaths);
   const mediaUrls = readStringList(ctx.MediaUrls);
-  const fallbackPath = readOptionalString2(ctx.MediaPath);
-  const fallbackUrl = readOptionalString2(ctx.MediaUrl);
+  const fallbackPath = readOptionalString6(ctx.MediaPath);
+  const fallbackUrl = readOptionalString6(ctx.MediaUrl);
   const mediaTypes = readStringList(ctx.MediaTypes);
-  const fallbackType = readOptionalString2(ctx.MediaType);
+  const fallbackType = readOptionalString6(ctx.MediaType);
   const entryCount = Math.max(
     mediaPaths.length,
     mediaUrls.length,