@ganglion/xacpx 0.10.1 → 0.12.0

package/dist/cli.js

@@ -115,6 +115,14 @@ var init_session = __esm(() => {
     modeModeLabel: (modeId) => `- mode: ${modeId}`,
     modeNotSet: "not set",
     modeSet: (modeId) => `Current session mode set to: ${modeId}`,
+    modelHeader: "Current model:",
+    modelSessionLabel: (alias) => `- Session: ${alias}`,
+    modelModelLabel: (modelId) => `- model: ${modelId}`,
+    modelNotSet: "not set (using agent default)",
+    modelAvailableLabel: (models) => `- available: ${models}`,
+    modelSet: (modelId) => `Current session model switched to: ${modelId}`,
+    modelSetFailed: (modelId, detail) => `Failed to switch model: ${modelId}
+${detail}`,
     replyModeHeader: "Current reply mode:",
     replyModeSessionLabel: (alias) => `- Session: ${alias}`,
     replyModeGlobalDefault: (value) => `- Global default: ${value}`,
@@ -191,6 +199,11 @@ var init_session = __esm(() => {
     modeHelpCmdShowDesc: "Show the saved mode of the current session",
     modeHelpCmdSet: "/mode <id>",
     modeHelpCmdSetDesc: "Set the current session mode",
+    modelHelpSummary: "View or switch the LLM model for the current session.",
+    modelHelpCmdShow: "/model",
+    modelHelpCmdShowDesc: "Show the current session model and the available ones",
+    modelHelpCmdSet: "/model <id>",
+    modelHelpCmdSetDesc: "Switch the current session model (e.g. gpt-5.2[high])",
     replyModeHelpSummary: "View or set the reply output mode for the current logical session.",
     replyModeHelpCmdShow: "/replymode",
     replyModeHelpCmdShowDesc: "Show global default, current override, and effective value",
@@ -1194,6 +1207,14 @@ var init_session2 = __esm(() => {
     modeModeLabel: (modeId) => `- mode：${modeId}`,
     modeNotSet: "未设置",
     modeSet: (modeId) => `已设置当前会话 mode：${modeId}`,
+    modelHeader: "当前 model：",
+    modelSessionLabel: (alias) => `- 会话：${alias}`,
+    modelModelLabel: (modelId) => `- model：${modelId}`,
+    modelNotSet: "未设置（使用 agent 默认）",
+    modelAvailableLabel: (models) => `- 可选：${models}`,
+    modelSet: (modelId) => `已切换当前会话 model：${modelId}`,
+    modelSetFailed: (modelId, detail) => `切换 model 失败：${modelId}
+${detail}`,
     replyModeHeader: "当前 reply mode：",
     replyModeSessionLabel: (alias) => `- 会话：${alias}`,
     replyModeGlobalDefault: (value) => `- 全局默认：${value}`,
@@ -1270,6 +1291,11 @@ var init_session2 = __esm(() => {
     modeHelpCmdShowDesc: "查看当前会话已保存的 mode",
     modeHelpCmdSet: "/mode <id>",
     modeHelpCmdSetDesc: "设置当前会话 mode",
+    modelHelpSummary: "查看或切换当前会话的 LLM model。",
+    modelHelpCmdShow: "/model",
+    modelHelpCmdShowDesc: "查看当前会话 model 及可选项",
+    modelHelpCmdSet: "/model <id>",
+    modelHelpCmdSetDesc: "切换当前会话 model（如 gpt-5.2[high]）",
     replyModeHelpSummary: "查看或设置当前逻辑会话的回复输出模式。",
     replyModeHelpCmdShow: "/replymode",
     replyModeHelpCmdShowDesc: "查看全局默认、当前覆盖和实际生效值",
@@ -4402,6 +4428,53 @@ var init_plugin_renames = __esm(() => {
   ]);
 });
 
+// src/config/local-agent-bin.ts
+import { statSync } from "node:fs";
+import { delimiter, join as join3 } from "node:path";
+function executableExtensions(platform, env) {
+  return platform === "win32" ? (env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM").split(";").filter((e) => e.length > 0) : [""];
+}
+function defaultIsExecutableFile(p) {
+  try {
+    const st = statSync(p);
+    if (!st.isFile())
+      return false;
+    return process.platform === "win32" || (st.mode & 73) !== 0;
+  } catch {
+    return false;
+  }
+}
+function isExecutableOnPath(name, env = process.env, isExecutableFile = defaultIsExecutableFile) {
+  const pathValue = env.PATH ?? env.Path ?? "";
+  if (!pathValue)
+    return false;
+  const exts = executableExtensions(process.platform, env);
+  for (const dir of pathValue.split(delimiter)) {
+    if (!dir)
+      continue;
+    for (const ext of exts) {
+      if (isExecutableFile(join3(dir, name + ext)))
+        return true;
+    }
+  }
+  return false;
+}
+function resolveLocalAgentCommand(driver, onPath = (name) => isExecutableOnPath(name)) {
+  const spec = LOCAL_AGENT_BINS[driver];
+  if (!spec)
+    return;
+  if (!onPath(spec.bin))
+    return;
+  return [spec.bin, ...spec.args].join(" ");
+}
+var LOCAL_AGENT_BINS;
+var init_local_agent_bin = __esm(() => {
+  LOCAL_AGENT_BINS = {
+    opencode: { bin: "opencode", args: ["acp"] },
+    kilocode: { bin: "kilocode", args: ["acp"] }
+  };
+});
+
 // src/config/resolve-agent-command.ts
 function resolveAgentCommand(driver, command) {
   if (!command) {
@@ -4412,10 +4485,20 @@ function resolveAgentCommand(driver, command) {
   }
   return command;
 }
+function resolveRuntimeAgentCommand(driver, command, preferLocal = true) {
+  const explicit = resolveAgentCommand(driver, command);
+  if (explicit) {
+    return explicit;
+  }
+  return preferLocal ? resolveLocalAgentCommand(driver) : undefined;
+}
 function isLegacyCodexCommand(command) {
   const normalized = command.trim().replaceAll("\\", "/").toLowerCase();
   return normalized === "./node_modules/.bin/codex-acp" || normalized === "./node_modules/.bin/codex-acp.exe" || normalized.endsWith("/node_modules/.bin/codex-acp") || normalized.endsWith("/node_modules/.bin/codex-acp.exe") || normalized.includes("/@zed-industries/codex-acp/bin/codex-acp.js") || normalized.includes("@zed-industries/codex-acp/bin/codex-acp.js");
 }
+var init_resolve_agent_command = __esm(() => {
+  init_local_agent_bin();
+});
 
 // src/config/load-config.ts
 import { readFile } from "node:fs/promises";
@@ -4505,6 +4588,9 @@ function parseConfig(raw, options = {}) {
   if ("queueOwnerTtlSeconds" in transport && (typeof transport.queueOwnerTtlSeconds !== "number" || !Number.isFinite(transport.queueOwnerTtlSeconds) || transport.queueOwnerTtlSeconds < 0)) {
     throw new Error("transport.queueOwnerTtlSeconds must be a non-negative number (0 = keep alive forever)");
   }
+  if ("preferLocalAgents" in transport && typeof transport.preferLocalAgents !== "boolean") {
+    throw new Error("transport.preferLocalAgents must be a boolean");
+  }
   if (!isRecord(raw.agents)) {
     throw new Error("agents must be an object");
   }
@@ -4572,9 +4658,11 @@ function parseConfig(raw, options = {}) {
   for (const [name, agent3] of Object.entries(rawAgents)) {
     const driver = agent3.driver;
     const command = typeof agent3.command === "string" ? resolveAgentCommand(driver, agent3.command) : undefined;
+    const model = typeof agent3.model === "string" && agent3.model.trim().length > 0 ? agent3.model.trim() : undefined;
     agents[name] = {
       driver,
-      ...command ? { command } : {}
+      ...command ? { command } : {},
+      ...model ? { model } : {}
     };
   }
   const rawWorkspaces = raw.workspaces;
@@ -4759,6 +4847,7 @@ var DEFAULT_PERF_LOG_CONFIG, DEFAULT_LOGGING_CONFIG, DEFAULT_PERMISSION_MODE = "
 var init_load_config = __esm(() => {
   init_workspace_path();
   init_plugin_renames();
+  init_resolve_agent_command();
   init_resolve_locale();
   DEFAULT_PERF_LOG_CONFIG = {
     enabled: false,
@@ -4836,7 +4925,8 @@ class ConfigStore {
       const agents = ensureRecordAt(raw, "agents");
       agents[name] = {
         driver: agent3.driver,
-        ...agent3.command ? { command: agent3.command } : {}
+        ...agent3.command ? { command: agent3.command } : {},
+        ...agent3.model ? { model: agent3.model } : {}
       };
     });
   }
@@ -5131,6 +5221,7 @@ var init_ensure_config = __esm(() => {
   init_config_store();
   init_default_workspace();
   init_load_config();
+  init_resolve_agent_command();
   BUILTIN_DEFAULT_CONFIG_TEMPLATE = {
     transport: {
       type: "acpx-bridge"
@@ -5647,7 +5738,7 @@ var init_create_daemon_controller = __esm(() => {
 
 // src/orchestration/orchestration-ipc.ts
 import { createHash } from "node:crypto";
-import { join as join3 } from "node:path";
+import { join as join4 } from "node:path";
 function resolveOrchestrationEndpoint(runtimeDir, platform = process.platform) {
   if (platform === "win32") {
     const suffix = createHash("sha256").update(runtimeDir).digest("hex").slice(0, 12);
@@ -5658,7 +5749,7 @@ function resolveOrchestrationEndpoint(runtimeDir, platform = process.platform) {
   }
   return {
     kind: "unix",
-    path: join3(runtimeDir, "orchestration.sock")
+    path: join4(runtimeDir, "orchestration.sock")
   };
 }
 function createOrchestrationEndpoint(path2, platform = process.platform) {
@@ -5678,20 +5769,20 @@ function encodeOrchestrationRpcResponse(response) {
 var init_orchestration_ipc = () => {};
 
 // src/daemon/daemon-files.ts
-import { dirname as dirname3, join as join4 } from "node:path";
+import { dirname as dirname3, join as join5 } from "node:path";
 function resolveDaemonPaths(options) {
-  const runtimeDir = options.runtimeDir ?? (options.configPath ? resolveRuntimeDirFromConfigPath(options.configPath) : join4(coreHomeDir(options.home), "runtime"));
+  const runtimeDir = options.runtimeDir ?? (options.configPath ? resolveRuntimeDirFromConfigPath(options.configPath) : join5(coreHomeDir(options.home), "runtime"));
   return {
     runtimeDir,
-    pidFile: join4(runtimeDir, "daemon.pid"),
-    statusFile: join4(runtimeDir, "status.json"),
-    stdoutLog: join4(runtimeDir, "stdout.log"),
-    stderrLog: join4(runtimeDir, "stderr.log"),
-    appLog: join4(runtimeDir, "app.log")
+    pidFile: join5(runtimeDir, "daemon.pid"),
+    statusFile: join5(runtimeDir, "status.json"),
+    stdoutLog: join5(runtimeDir, "stdout.log"),
+    stderrLog: join5(runtimeDir, "stderr.log"),
+    appLog: join5(runtimeDir, "app.log")
   };
 }
 function resolveRuntimeDirFromConfigPath(configPath) {
-  return join4(dirname3(configPath), "runtime");
+  return join5(dirname3(configPath), "runtime");
 }
 function resolveDaemonOrchestrationSocketPath(runtimeDir, platform = process.platform) {
   return resolveOrchestrationEndpoint(runtimeDir, platform).path;
@@ -13109,6 +13200,14 @@ class ScheduledTaskService {
   listPending(chatKey) {
     return this.listPendingAllChats().filter((task) => task.chat_key === chatKey);
   }
+  listRecentForChat(chatKey, opts) {
+    const terminalLimit = opts?.terminalLimit ?? 20;
+    const mine = Object.values(this.state.scheduled_tasks).filter((task) => task.chat_key === chatKey);
+    const upcoming = mine.filter((task) => task.status === "pending" || task.status === "triggering").sort((left, right) => left.execute_at.localeCompare(right.execute_at));
+    const settledAt = (task) => task.executed_at ?? task.failed_at ?? task.cancelled_at ?? task.missed_at ?? task.triggered_at ?? task.created_at;
+    const terminal = mine.filter((task) => task.status === "executed" || task.status === "failed" || task.status === "missed" || task.status === "cancelled").sort((left, right) => settledAt(right).localeCompare(settledAt(left))).slice(0, terminalLimit);
+    return [...upcoming, ...terminal];
+  }
   listPendingAllChats() {
     return Object.values(this.state.scheduled_tasks).filter((task) => task.status === "pending").sort((left, right) => left.execute_at.localeCompare(right.execute_at));
   }
@@ -13232,14 +13331,14 @@ var init_scheduled_service = () => {};
 import { readFileSync as readFileSync2 } from "node:fs";
 import { copyFile, mkdir as mkdir4, readFile as readFile7, writeFile as writeFile4 } from "node:fs/promises";
 import { homedir as homedir3 } from "node:os";
-import { dirname as dirname4, join as join6 } from "node:path";
+import { dirname as dirname4, join as join7 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function resolveCoreRoot() {
   try {
     let dir = dirname4(fileURLToPath2(import.meta.url));
     for (let depth = 0;depth < 12; depth++) {
       try {
-        const pkg = JSON.parse(readFileSync2(join6(dir, "package.json"), "utf-8"));
+        const pkg = JSON.parse(readFileSync2(join7(dir, "package.json"), "utf-8"));
         if (pkg.name && CORE_ROOT_NAMES.includes(pkg.name))
           return dir;
       } catch {}
@@ -13257,10 +13356,10 @@ async function ensureCoreResolution(pluginHome) {
   const root = resolveCoreRoot();
   if (!root)
     return;
-  const srcJs = join6(root, "dist", "plugin-api.js");
+  const srcJs = join7(root, "dist", "plugin-api.js");
   for (const name of SHIM_SPECIFIERS) {
-    const targetDir = join6(pluginHome, "node_modules", name);
-    const dstJs = join6(targetDir, "plugin-api.js");
+    const targetDir = join7(pluginHome, "node_modules", name);
+    const dstJs = join7(targetDir, "plugin-api.js");
     await mkdir4(targetDir, { recursive: true });
     try {
       await copyFile(srcJs, dstJs);
@@ -13269,7 +13368,7 @@ async function ensureCoreResolution(pluginHome) {
       console.warn(`xacpx: skipped plugin-api resolution shim for "${name}" — could not copy ${srcJs} (${message}). ` + `Channel plugins importing "${name}/plugin-api" at runtime may fail to load.`);
       continue;
     }
-    await writeFile4(join6(targetDir, "package.json"), JSON.stringify({
+    await writeFile4(join7(targetDir, "package.json"), JSON.stringify({
       name,
       type: "module",
       exports: {
@@ -13298,10 +13397,10 @@ function resolvePluginHome(input = {}) {
   if (envOverride)
     return envOverride;
   const home = coerceMissing(input.home) ?? coerceMissing(process.env.HOME) ?? homedir3();
-  return join6(coreHomeDir(home), "plugins");
+  return join7(coreHomeDir(home), "plugins");
 }
 async function normalizePluginHomeManifest(pluginHome) {
-  const manifestPath = join6(pluginHome, "package.json");
+  const manifestPath = join7(pluginHome, "package.json");
   let raw;
   try {
     raw = await readFile7(manifestPath, "utf8");
@@ -13323,7 +13422,7 @@ async function normalizePluginHomeManifest(pluginHome) {
 }
 async function ensurePluginHome(pluginHome) {
   await mkdir4(pluginHome, { recursive: true, mode: 448 });
-  await writeFile4(join6(pluginHome, "package.json"), JSON.stringify({ private: true, type: "module" }, null, 2) + `
+  await writeFile4(join7(pluginHome, "package.json"), JSON.stringify({ private: true, type: "module" }, null, 2) + `
 `, { flag: "wx" }).catch((error2) => {
     if (error2.code !== "EEXIST")
       throw error2;
@@ -17373,7 +17472,7 @@ function normalizeMediaArray(media) {
 
 // src/logging/rotating-file-writer.ts
 import { readdir as readdir2, rename as rename2, rm as rm6, stat as stat2 } from "node:fs/promises";
-import { basename, dirname as dirname5, join as join8 } from "node:path";
+import { basename, dirname as dirname5, join as join9 } from "node:path";
 async function rotateIfNeeded(filePath, incomingSize, maxSizeBytes, maxFiles) {
   let currentSize = 0;
   try {
@@ -17423,7 +17522,7 @@ async function cleanupExpiredRotatedLogs(filePath, retentionDays, now) {
     if (!file.startsWith(prefix) || !/^\d+$/.test(file.slice(prefix.length))) {
       continue;
     }
-    const candidate = join8(parentDir, file);
+    const candidate = join9(parentDir, file);
     let details;
     try {
       details = await stat2(candidate);
@@ -19101,10 +19200,10 @@ var init_scheduled_turn = __esm(() => {
 
 // src/weixin/monitor/consumer-lock.ts
 import { mkdir as mkdir6, open as open3, readFile as readFile8, rm as rm7 } from "node:fs/promises";
-import { dirname as dirname7, join as join9 } from "node:path";
+import { dirname as dirname7, join as join10 } from "node:path";
 import { homedir as homedir4 } from "node:os";
 function createWeixinConsumerLock(options = {}) {
-  const lockFilePath = options.lockFilePath ?? join9(coreHomeDir(homedir4()), "runtime", "weixin-consumer.lock.json");
+  const lockFilePath = options.lockFilePath ?? join10(coreHomeDir(homedir4()), "runtime", "weixin-consumer.lock.json");
   const isProcessRunning = options.isProcessRunning ?? defaultIsProcessRunning4;
   const onDiagnostic = options.onDiagnostic;
   return {
@@ -19778,9 +19877,9 @@ __export(exports_plugin_loader, {
 });
 import { createRequire as createRequire2 } from "node:module";
 import { pathToFileURL } from "node:url";
-import { join as join10 } from "node:path";
+import { join as join11 } from "node:path";
 async function importPluginFromHome(packageName, pluginHome) {
-  const requireFromHome = createRequire2(join10(pluginHome, "package.json"));
+  const requireFromHome = createRequire2(join11(pluginHome, "package.json"));
   const entry = requireFromHome.resolve(packageName);
   return await import(pathToFileURL(entry).href);
 }
@@ -19825,13 +19924,13 @@ var init_plugin_loader = __esm(() => {
 
 // src/plugins/plugin-doctor.ts
 import { readFile as readFile10 } from "node:fs/promises";
-import { join as join12 } from "node:path";
+import { join as join13 } from "node:path";
 function suggestedPluginPackageForChannel(type) {
   return findKnownPluginByChannel(type)?.packageName ?? `<npm-package-that-provides-${type}>`;
 }
 async function readDependencyEntries(pluginHome) {
   try {
-    const raw = await readFile10(join12(pluginHome, "package.json"), "utf8");
+    const raw = await readFile10(join13(pluginHome, "package.json"), "utf8");
     const parsed = JSON.parse(raw);
     const out = {};
     for (const [name, value] of Object.entries(parsed.dependencies ?? {})) {
@@ -20265,6 +20364,8 @@ function parseCommand(input) {
     return { kind: "session.reset" };
   if (command === "/mode" && parts.length === 1)
     return { kind: "mode.show" };
+  if (command === "/model" && parts.length === 1)
+    return { kind: "model.show" };
   if (command === "/replymode" && parts.length === 1)
     return { kind: "replymode.show" };
   if (command === "/config" && parts.length === 1)
@@ -20403,6 +20504,9 @@ function parseCommand(input) {
   if (command === "/mode" && parts[1]) {
     return { kind: "mode.set", modeId: parts[1] };
   }
+  if (command === "/model" && parts[1]) {
+    return { kind: "model.set", modelId: parts.slice(1).join(" ") };
+  }
   if (command === "/replymode" && parts[1] === "reset" && parts.length === 2) {
     return { kind: "replymode.reset" };
   }
@@ -20410,7 +20514,14 @@ function parseCommand(input) {
     return { kind: "replymode.set", replyMode: parts[1] };
   }
   if (command === "/agent" && parts[1] === "add" && parts[2]) {
-    return { kind: "agent.add", template: parts[2] };
+    let model = "";
+    for (let index = 3;index < parts.length; index += 1) {
+      if ((parts[index] === "--model" || parts[index] === "-m") && index + 1 < parts.length) {
+        model = parts[index + 1] ?? "";
+        index += 1;
+      }
+    }
+    return model.trim().length > 0 ? { kind: "agent.add", template: parts[2], model: model.trim() } : { kind: "agent.add", template: parts[2] };
   }
   if (command === "/agent" && parts[1] === "rm" && parts[2]) {
     return { kind: "agent.rm", name: parts[2] };
@@ -20488,6 +20599,7 @@ function parseCommand(input) {
       const alias = parts[2];
       let agent3 = "";
       let workspace3 = "";
+      let model = "";
       let invalid = false;
       for (let index = 3;index < parts.length; index += 1) {
         if (parts[index] === "--agent" || parts[index] === "-a") {
@@ -20506,12 +20618,20 @@ function parseCommand(input) {
           workspace3 = parts[index + 1] ?? "";
           index += 1;
           continue;
+        } else if (parts[index] === "--model" || parts[index] === "-m") {
+          if (index + 1 >= parts.length) {
+            invalid = true;
+            break;
+          }
+          model = parts[index + 1] ?? "";
+          index += 1;
+          continue;
         }
         invalid = true;
         break;
       }
       if (!invalid && alias.trim().length > 0 && agent3.trim().length > 0 && workspace3.trim().length > 0) {
-        return { kind: "session.new", alias, agent: agent3, workspace: workspace3 };
+        return model.trim().length > 0 ? { kind: "session.new", alias, agent: agent3, workspace: workspace3, model: model.trim() } : { kind: "session.new", alias, agent: agent3, workspace: workspace3 };
       }
     }
     const shortcutTarget = readSessionShortcutTarget(parts, 3);
@@ -20967,6 +21087,7 @@ var init_command_policy = __esm(() => {
     "session.tail",
     "status",
     "mode.show",
+    "model.show",
     "replymode.show",
     "config.show",
     "permission.status",
@@ -20986,6 +21107,7 @@ var init_command_policy = __esm(() => {
     "replymode.set": "/replymode",
     "replymode.reset": "/replymode reset",
     "mode.set": "/mode",
+    "model.set": "/model",
     "permission.mode.set": "/permission",
     "permission.auto.set": "/permission auto",
     "config.set": "/config set",
@@ -21772,6 +21894,19 @@ function modeHelp() {
     examples: ["/mode", "/mode plan"]
   };
 }
+function modelHelp() {
+  const s = t().session;
+  return {
+    topic: "model",
+    aliases: [],
+    summary: s.modelHelpSummary,
+    commands: [
+      { usage: s.modelHelpCmdShow, description: s.modelHelpCmdShowDesc },
+      { usage: s.modelHelpCmdSet, description: s.modelHelpCmdSetDesc }
+    ],
+    examples: ["/model", "/model gpt-5.2[high]"]
+  };
+}
 function replyModeHelp() {
   const s = t().session;
   return {
@@ -21845,7 +21980,7 @@ async function handleSessions(context, chatKey) {
 `)
   };
 }
-async function handleSessionNew(context, chatKey, alias, agent3, workspace3) {
+async function handleSessionNew(context, chatKey, alias, agent3, workspace3, model) {
   const channelId = getChannelIdFromChatKey(chatKey);
   const internalAlias = scopeDisplayAliasToInternal(channelId, alias);
   const existing = context.sessions.getResolvedSessionByInternalAlias(internalAlias);
@@ -21853,6 +21988,10 @@ async function handleSessionNew(context, chatKey, alias, agent3, workspace3) {
     return { text: t().session.sessionAlreadyExists(alias, existing.agent, existing.workspace) };
   }
   const session3 = context.lifecycle.resolveSession(internalAlias, agent3, workspace3, `${workspace3}:${internalAlias}`);
+  const normalizedModel = model?.trim();
+  if (normalizedModel) {
+    session3.model = normalizedModel;
+  }
   const releaseTransportReservation = await context.lifecycle.reserveTransportSession(session3.transportSession);
   try {
     try {
@@ -21865,6 +22004,9 @@ async function handleSessionNew(context, chatKey, alias, agent3, workspace3) {
       return context.recovery.renderSessionCreationError(session3, error2);
     }
     await context.sessions.attachSession(internalAlias, agent3, workspace3, session3.transportSession);
+    if (normalizedModel) {
+      await context.sessions.setSessionModel(internalAlias, normalizedModel);
+    }
     await context.sessions.useSession(chatKey, internalAlias);
     await refreshSessionTransportAgentCommandBestEffort(context, internalAlias, "session.agent_command_refresh_failed");
     await context.logger.info("session.created", "created and selected logical session", {
@@ -21991,6 +22133,43 @@ async function handleModeSet(context, chatKey, modeId) {
   await context.sessions.setCurrentSessionMode(chatKey, modeId);
   return { text: t().session.modeSet(modeId) };
 }
+async function handleModelShow(context, chatKey) {
+  const session3 = await context.sessions.getCurrentSession(chatKey);
+  if (!session3) {
+    return { text: t().session.noCurrent };
+  }
+  const s = t().session;
+  let current = session3.model;
+  let available = [];
+  try {
+    const queried = await context.interaction.getModelTransportSession(session3);
+    current = queried.current ?? session3.model;
+    available = queried.available;
+  } catch {}
+  const lines = [
+    s.modelHeader,
+    s.modelSessionLabel(toDisplaySessionAlias(session3.alias)),
+    s.modelModelLabel(current ?? s.modelNotSet)
+  ];
+  if (available.length > 0) {
+    lines.push(s.modelAvailableLabel(available.join(", ")));
+  }
+  return { text: lines.join(`
+`) };
+}
+async function handleModelSet(context, chatKey, modelId) {
+  const session3 = await context.sessions.getCurrentSession(chatKey);
+  if (!session3) {
+    return { text: t().session.noCurrent };
+  }
+  try {
+    await context.interaction.setModelTransportSession(session3, modelId);
+  } catch (error2) {
+    return { text: t().session.modelSetFailed(modelId, error2 instanceof Error ? error2.message : String(error2)) };
+  }
+  await context.sessions.setCurrentSessionModel(chatKey, modelId);
+  return { text: t().session.modelSet(modelId) };
+}
 async function handleReplyModeShow(context, chatKey) {
   const session3 = await context.sessions.getCurrentSession(chatKey);
   if (!session3) {
@@ -22176,7 +22355,7 @@ async function handleSessionRemove(context, chatKey, alias) {
   return { text: lines.join(`
 `) };
 }
-async function promptWithSession(context, session3, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan, metadata) {
+async function promptWithSession(context, session3, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan, metadata, onPlan, onUsage) {
   const effectiveReplyMode = resolveEffectiveReplyMode(context.config, chatKey, session3.replyMode);
   if (!session3.replyMode)
     session3.replyMode = effectiveReplyMode;
@@ -22208,7 +22387,7 @@ async function promptWithSession(context, session3, chatKey, text, reply, replyC
   const { promptText, taskIds, groupIds, claimHumanReply } = await preparePromptWithFallback(context, session3, chatKey, text, replyContextToken, accountId);
   try {
     const replyContext = transportReply && context.quota && getChannelIdFromChatKey(chatKey) === "weixin" ? { chatKey, quota: context.quota } : undefined;
-    const result = await context.interaction.promptTransportSession(session3, promptText, transportReply, replyContext, media, abortSignal, onToolEvent, onThought, perfSpan);
+    const result = await context.interaction.promptTransportSession(session3, promptText, transportReply, replyContext, media, abortSignal, onToolEvent, onThought, perfSpan, onPlan, onUsage);
     if (claimHumanReply) {
       try {
         await context.orchestration?.claimActiveHumanReply?.(claimHumanReply);
@@ -22228,23 +22407,23 @@ async function promptWithSession(context, session3, chatKey, text, reply, replyC
     throw error2;
   }
 }
-async function handlePromptWithSession(context, session3, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan, metadata) {
+async function handlePromptWithSession(context, session3, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan, metadata, onPlan, onUsage) {
   try {
-    return await promptWithSession(context, session3, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan, metadata);
+    return await promptWithSession(context, session3, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan, metadata, onPlan, onUsage);
   } catch (error2) {
     const recovered = await context.recovery.tryRecoverMissingSession(session3, error2);
     if (recovered) {
-      return await promptWithSession(context, recovered, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan, metadata);
+      return await promptWithSession(context, recovered, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan, metadata, onPlan, onUsage);
     }
     return context.recovery.renderTransportError(session3, error2);
   }
 }
-async function handlePrompt(context, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan, metadata) {
+async function handlePrompt(context, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan, metadata, onPlan, onUsage) {
   const session3 = metadata?.boundSessionAlias ? context.sessions.getResolvedSessionByInternalAlias(metadata.boundSessionAlias) : await context.sessions.getCurrentSession(chatKey);
   if (!session3) {
     return { text: t().session.noCurrent };
   }
-  return await handlePromptWithSession(context, session3, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan, metadata);
+  return await handlePromptWithSession(context, session3, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan, metadata, onPlan, onUsage);
 }
 function toCoordinatorRouteChatMetadata(metadata) {
   if (!metadata) {
@@ -22917,7 +23096,7 @@ function agentHelp() {
 function handleAgents(context) {
   return { text: context.config ? renderAgents(context.config) : "No config loaded." };
 }
-async function handleAgentAdd(context, templateName) {
+async function handleAgentAdd(context, templateName, model) {
   const a = t().agent;
   if (!context.config || !context.configStore) {
     return { text: a.noWritableConfig };
@@ -22927,13 +23106,18 @@ async function handleAgentAdd(context, templateName) {
     return { text: a.unsupportedTemplate(listAgentTemplates().join("、")) };
   }
   const existing = context.config.agents[templateName];
+  const normalizedModel = model?.trim();
+  const desired = normalizedModel ? { ...template, model: normalizedModel } : existing?.model ? { ...template, model: existing.model } : template;
   if (existing) {
-    if (sameAgentConfig(existing, template)) {
-      return { text: a.alreadyExists(templateName) };
+    if (sameAgentConfig(existing, desired)) {
+      if ((existing.model ?? undefined) === (desired.model ?? undefined)) {
+        return { text: a.alreadyExists(templateName) };
+      }
+    } else {
+      return { text: a.alreadyExistsDifferent(templateName) };
     }
-    return { text: a.alreadyExistsDifferent(templateName) };
   }
-  const updated = await context.configStore.upsertAgent(templateName, template);
+  const updated = await context.configStore.upsertAgent(templateName, desired);
   context.replaceConfig(updated);
   return { text: a.saved(templateName) };
 }
@@ -23297,6 +23481,7 @@ function buildHelpTopics() {
     configHelp(),
     orchestrationHelp(),
     modeHelp(),
+    modelHelp(),
     replyModeHelp(),
     statusHelp(),
     cancelHelp(),
@@ -23727,7 +23912,7 @@ async function resolveNativeTarget(context, chatKey, input) {
   return {
     agent: agent3,
     agentDisplayName: displayAgentName(agent3),
-    agentCommand: resolveAgentCommand(agentConfig.driver, agentConfig.command),
+    agentCommand: resolveRuntimeAgentCommand(agentConfig.driver, agentConfig.command, context.config?.transport.preferLocalAgents !== false),
     workspace: workspaceResolution.workspace,
     workspaceLabel: workspaceResolution.workspaceLabel,
     cwd: workspaceResolution.cwd,
@@ -23965,6 +24150,7 @@ function displayAgentName(agent3) {
 }
 var NATIVE_SESSION_CACHE_TTL_MS;
 var init_native_session_handler = __esm(() => {
+  init_resolve_agent_command();
   init_channel_scope();
   init_workspace_name();
   init_workspace_path();
@@ -24084,7 +24270,7 @@ import { spawn as spawn5 } from "node:child_process";
 import { createWriteStream } from "node:fs";
 import { mkdir as mkdir8 } from "node:fs/promises";
 import { homedir as homedir6 } from "node:os";
-import { join as join14 } from "node:path";
+import { join as join15 } from "node:path";
 async function autoInstallOptionalDep(pkg, parentPackages, options = {}) {
   const runCli = options.runCli ?? defaultRunCli;
   const openLog = options.openLog ?? defaultLogSink;
@@ -24199,10 +24385,10 @@ ${err.message}`, reason: "spawn" });
     });
   });
 }, defaultLogSink = async () => {
-  const dir = join14(coreHomeDir(homedir6()), "logs");
+  const dir = join15(coreHomeDir(homedir6()), "logs");
   await mkdir8(dir, { recursive: true });
   const timestamp = new Date().toISOString().replace(/[:.]/g, "").replace(/-/g, "");
-  const path14 = join14(dir, `auto-install-${timestamp}.log`);
+  const path14 = join15(dir, `auto-install-${timestamp}.log`);
   const stream = createWriteStream(path14, { flags: "a" });
   return {
     path: path14,
@@ -24229,7 +24415,7 @@ import { spawn as spawn6 } from "node:child_process";
 import { createRequire as createRequire3 } from "node:module";
 import { access as access3 } from "node:fs/promises";
 import { homedir as homedir7 } from "node:os";
-import { dirname as dirname10, join as join15 } from "node:path";
+import { dirname as dirname10, join as join16 } from "node:path";
 function deriveParentPackageName(platformPackage) {
   return platformPackage.replace(/-(?:linux|darwin|win32|windows|freebsd|openbsd|sunos|aix)(?:-(?:x64|arm64|ia32|arm|ppc64|s390x))?(?:-(?:baseline|musl|gnu|gnueabihf|musleabihf|msvc))?$/, "");
 }
@@ -24242,7 +24428,7 @@ async function discoverParentPackagePaths(platformPackage, seedPath, deps = {})
   const queryRoot = deps.queryPackageManagerRoot ?? defaultQueryPackageManagerRoot;
   const parentName = deriveParentPackageName(platformPackage);
   const rawCandidates = [];
-  const bunGlobalRoot = env.BUN_INSTALL ? join15(env.BUN_INSTALL, "install", "global", "node_modules") : join15(home, ".bun", "install", "global", "node_modules");
+  const bunGlobalRoot = env.BUN_INSTALL ? join16(env.BUN_INSTALL, "install", "global", "node_modules") : join16(home, ".bun", "install", "global", "node_modules");
   const [npmRoot, pnpmRoot, yarnRoot] = await Promise.all([
     queryRoot("npm"),
     queryRoot("pnpm"),
@@ -24265,20 +24451,20 @@ async function discoverParentPackagePaths(platformPackage, seedPath, deps = {})
     if (resolved)
       rawCandidates.push({ path: resolved, manager: classify(resolved) });
   }
-  rawCandidates.push({ path: join15(bunGlobalRoot, parentName), manager: "bun" });
+  rawCandidates.push({ path: join16(bunGlobalRoot, parentName), manager: "bun" });
   if (npmRoot)
-    rawCandidates.push({ path: join15(npmRoot, parentName), manager: "npm" });
+    rawCandidates.push({ path: join16(npmRoot, parentName), manager: "npm" });
   if (pnpmRoot)
-    rawCandidates.push({ path: join15(pnpmRoot, parentName), manager: "pnpm" });
+    rawCandidates.push({ path: join16(pnpmRoot, parentName), manager: "pnpm" });
   if (yarnRoot)
-    rawCandidates.push({ path: join15(yarnRoot, parentName), manager: "yarn" });
+    rawCandidates.push({ path: join16(yarnRoot, parentName), manager: "yarn" });
   const seen = new Set;
   const verified = [];
   for (const candidate of rawCandidates) {
     if (seen.has(candidate.path))
       continue;
     seen.add(candidate.path);
-    if (await fsExists(join15(candidate.path, "package.json"))) {
+    if (await fsExists(join16(candidate.path, "package.json"))) {
       verified.push(candidate);
     }
   }
@@ -24349,7 +24535,7 @@ async function defaultQueryPackageManagerRoot(tool) {
       const trimmed = stdout2.trim().split(/\r?\n/).pop()?.trim() ?? "";
       if (!trimmed)
         return done(null);
-      done(spec.postfix ? join15(trimmed, spec.postfix) : trimmed);
+      done(spec.postfix ? join16(trimmed, spec.postfix) : trimmed);
     });
   });
 }
@@ -24496,9 +24682,12 @@ class CommandRouter {
     this.logger = logger2 ?? createNoopAppLogger();
     this.activeTurns = activeTurns;
   }
-  async handle(chatKey, input, reply, replyContextToken, accountId, media, metadata, abortSignal, onToolEvent, onThought, perfSpan) {
+  async handle(chatKey, input, reply, replyContextToken, accountId, media, metadata, abortSignal, onToolEvent, onThought, perfSpan, onPlan, onUsage) {
     const startedAt = Date.now();
-    const command = parseCommand(input);
+    let command = parseCommand(input);
+    if (metadata?.channel === "control" && command.kind !== "prompt") {
+      command = { kind: "prompt", text: input.trim() };
+    }
     await this.logger.debug("command.parsed", "parsed inbound command", {
       chatKey,
       kind: command.kind
@@ -24535,7 +24724,7 @@ class CommandRouter {
         case "agents":
           return handleAgents(this.createHandlerContext());
         case "agent.add":
-          return await handleAgentAdd(this.createHandlerContext(), command.template);
+          return await handleAgentAdd(this.createHandlerContext(), command.template, command.model);
         case "agent.rm":
           return await handleAgentRemove(this.createHandlerContext(), command.name);
         case "permission.status":
@@ -24559,7 +24748,7 @@ class CommandRouter {
         case "sessions":
           return await handleSessions(this.createSessionHandlerContext(undefined, perfSpan), chatKey);
         case "session.new":
-          return await handleSessionNew(this.createSessionHandlerContext(reply, perfSpan), chatKey, command.alias, command.agent, command.workspace);
+          return await handleSessionNew(this.createSessionHandlerContext(reply, perfSpan), chatKey, command.alias, command.agent, command.workspace, command.model);
         case "session.shortcut":
           return await handleSessionShortcut(this.createSessionHandlerContext(reply, perfSpan), chatKey, command.agent, command, false);
         case "session.shortcut.new":
@@ -24580,6 +24769,10 @@ class CommandRouter {
           return await handleModeShow(this.createSessionHandlerContext(undefined, perfSpan), chatKey);
         case "mode.set":
           return await handleModeSet(this.createSessionHandlerContext(undefined, perfSpan), chatKey, command.modeId);
+        case "model.show":
+          return await handleModelShow(this.createSessionHandlerContext(undefined, perfSpan), chatKey);
+        case "model.set":
+          return await handleModelSet(this.createSessionHandlerContext(reply, perfSpan), chatKey, command.modelId);
         case "replymode.show":
           return await handleReplyModeShow(this.createSessionHandlerContext(undefined, perfSpan), chatKey);
         case "replymode.set":
@@ -24649,16 +24842,16 @@ class CommandRouter {
               ...this.sessions.resolveSession(descriptor.alias, descriptor.agent, descriptor.workspace, descriptor.transportSession),
               transient: true
             };
-            return await handlePromptWithSession(sessionContext, transientSession, chatKey, command.text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan, metadata);
+            return await handlePromptWithSession(sessionContext, transientSession, chatKey, command.text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan, metadata, onPlan, onUsage);
           }
           if (metadata?.scheduledSessionAlias) {
             const scheduledSession = await this.sessions.getSession(metadata.scheduledSessionAlias);
             if (!scheduledSession) {
               throw new Error(`session "${metadata.scheduledSessionAlias}" not found for scheduled prompt`);
             }
-            return await handlePromptWithSession(sessionContext, scheduledSession, chatKey, command.text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan, metadata);
+            return await handlePromptWithSession(sessionContext, scheduledSession, chatKey, command.text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan, metadata, onPlan, onUsage);
           }
-          return await handlePrompt(sessionContext, chatKey, command.text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan, metadata);
+          return await handlePrompt(sessionContext, chatKey, command.text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan, metadata, onPlan, onUsage);
         }
       }
     });
@@ -24710,11 +24903,103 @@ class CommandRouter {
       refreshSessionTransportAgentCommand: (alias) => this.refreshSessionTransportAgentCommand(alias)
     };
   }
+  async createSessionWithTransport(internalAlias, agent3, workspace3, model) {
+    const existing = this.sessions.getResolvedSessionByInternalAlias(internalAlias);
+    if (existing) {
+      throw new Error(`session "${internalAlias}" already exists`);
+    }
+    const session3 = this.sessions.resolveSession(internalAlias, agent3, workspace3, `${workspace3}:${internalAlias}`);
+    const normalizedModel = model?.trim();
+    if (normalizedModel) {
+      session3.model = normalizedModel;
+    }
+    const release = await this.reserveLogicalTransportSession(session3.transportSession);
+    try {
+      await this.ensureTransportSession(session3);
+      const exists = await this.checkTransportSession(session3);
+      if (!exists) {
+        throw new Error(`transport session "${session3.transportSession}" could not be verified`);
+      }
+      await this.sessions.attachSession(internalAlias, agent3, workspace3, session3.transportSession);
+      if (normalizedModel) {
+        await this.sessions.setSessionModel(internalAlias, normalizedModel);
+      }
+      try {
+        await this.refreshSessionTransportAgentCommand(internalAlias);
+      } catch (error2) {
+        await this.logger.error("session.agent_command_refresh_failed", "failed to refresh session agent command", {
+          alias: internalAlias,
+          error: error2 instanceof Error ? error2.message : String(error2)
+        });
+      }
+      return session3;
+    } finally {
+      await release();
+    }
+  }
+  async listNativeSessionsForControl(agent3, workspace3) {
+    const listAgentSessions = this.transport.listAgentSessions?.bind(this.transport);
+    if (!listAgentSessions)
+      return [];
+    const agentConfig = this.config?.agents[agent3];
+    const workspaceConfig = this.config?.workspaces[workspace3];
+    if (!agentConfig || !workspaceConfig) {
+      throw new Error(`unknown agent "${agent3}" or workspace "${workspace3}"`);
+    }
+    const agentCommand = resolveRuntimeAgentCommand(agentConfig.driver, agentConfig.command, this.config?.transport.preferLocalAgents !== false);
+    const result = await listAgentSessions({
+      agent: agent3,
+      ...agentCommand ? { agentCommand } : {},
+      cwd: workspaceConfig.cwd,
+      filterCwd: workspaceConfig.cwd
+    });
+    return result?.sessions ?? [];
+  }
+  async attachNativeSessionWithTransport(internalAlias, agent3, workspace3, agentSessionId, nativeMeta) {
+    if (!this.transport.resumeAgentSession) {
+      throw new Error("the active transport does not support native sessions");
+    }
+    const existing = this.sessions.getResolvedSessionByInternalAlias(internalAlias);
+    if (existing) {
+      throw new Error(`session "${internalAlias}" already exists`);
+    }
+    const session3 = this.sessions.resolveSession(internalAlias, agent3, workspace3, `${workspace3}:${internalAlias}`);
+    const release = await this.reserveLogicalTransportSession(session3.transportSession);
+    try {
+      await this.transport.resumeAgentSession(session3, agentSessionId);
+      const exists = await this.checkTransportSession(session3);
+      if (!exists) {
+        throw new Error(`transport session "${session3.transportSession}" could not be verified`);
+      }
+      await this.sessions.attachNativeSession({
+        alias: internalAlias,
+        agent: agent3,
+        workspace: workspace3,
+        transportSession: session3.transportSession,
+        agentSessionId,
+        ...nativeMeta?.title !== undefined ? { title: nativeMeta.title } : {},
+        ...nativeMeta?.updatedAt !== undefined ? { updatedAt: nativeMeta.updatedAt } : {}
+      });
+      try {
+        await this.refreshSessionTransportAgentCommand(internalAlias);
+      } catch (error2) {
+        await this.logger.error("session.native.agent_command_refresh_failed", "failed to refresh native session agent command", {
+          alias: internalAlias,
+          error: error2 instanceof Error ? error2.message : String(error2)
+        });
+      }
+      return session3;
+    } finally {
+      await release();
+    }
+  }
   createSessionInteractionOps(perfSpan) {
     return {
       setModeTransportSession: (session3, modeId) => this.setModeTransportSession(session3, modeId),
+      setModelTransportSession: (session3, modelId) => this.setModelTransportSession(session3, modelId),
+      getModelTransportSession: (session3) => this.getModelTransportSession(session3),
       cancelTransportSession: (session3) => this.cancelTransportSession(session3),
-      promptTransportSession: (session3, text, reply, replyContext, media, abortSignal, onToolEvent, onThought, perfSpanOverride) => this.promptTransportSession(session3, text, reply, replyContext, media, abortSignal, onToolEvent, onThought, perfSpanOverride ?? perfSpan)
+      promptTransportSession: (session3, text, reply, replyContext, media, abortSignal, onToolEvent, onThought, perfSpanOverride, onPlan, onUsage) => this.promptTransportSession(session3, text, reply, replyContext, media, abortSignal, onToolEvent, onThought, perfSpanOverride ?? perfSpan, onPlan, onUsage)
     };
   }
   createSessionRenderRecoveryOps() {
@@ -24893,7 +25178,7 @@ class CommandRouter {
   async checkTransportSession(session3) {
     return await this.measureTransportCall("has_session", session3, () => this.transport.hasSession(session3));
   }
-  async promptTransportSession(session3, text, reply, replyContext, media, abortSignal, onToolEvent, onThought, perfSpan) {
+  async promptTransportSession(session3, text, reply, replyContext, media, abortSignal, onToolEvent, onThought, perfSpan, onPlan, onUsage) {
     session3.mcpCoordinatorSession ??= stableCoordinatorSession(session3.transportSession);
     let done = false;
     let abortRequested = false;
@@ -24950,7 +25235,9 @@ class CommandRouter {
         ...media ? { media } : {},
         ...reply ? { onSegment } : {},
         ...onToolEvent ? { onToolEvent } : {},
-        ...onThought ? { onThought } : {}
+        ...onThought ? { onThought } : {},
+        ...onPlan ? { onPlan } : {},
+        ...onUsage ? { onUsage } : {}
       }));
     } catch (error2) {
       localOutcome = isAbortError2(error2) || abortRequested ? "aborted" : "error";
@@ -24969,6 +25256,20 @@ class CommandRouter {
   async setModeTransportSession(session3, modeId) {
     return await this.measureTransportCall("set_mode", session3, () => this.transport.setMode(session3, modeId));
   }
+  async setModelTransportSession(session3, modelId) {
+    if (!this.transport.setModel) {
+      throw new Error("the active transport does not support switching models");
+    }
+    const setModel = this.transport.setModel.bind(this.transport);
+    return await this.measureTransportCall("set_model", session3, () => setModel(session3, modelId));
+  }
+  async getModelTransportSession(session3) {
+    if (!this.transport.getSessionModel) {
+      return { current: session3.model, available: [] };
+    }
+    const getSessionModel = this.transport.getSessionModel.bind(this.transport);
+    return await this.measureTransportCall("get_model", session3, () => getSessionModel(session3));
+  }
   async cancelTransportSession(session3) {
     return await this.measureTransportCall("cancel", session3, () => this.transport.cancel(session3));
   }
@@ -25028,6 +25329,7 @@ function inferTransportKind(transport) {
 }
 var init_command_router = __esm(() => {
   init_app_logger();
+  init_resolve_agent_command();
   init_acpx_session_index();
   init_prompt_output();
   init_parse_command();
@@ -25121,7 +25423,7 @@ class ConsoleAgent {
       ...m.fileName ? { fileName: m.fileName } : {}
     })) : undefined;
     request.perfSpan?.mark("agent.dispatched");
-    return await this.router.handle(request.conversationId, request.text, request.reply, request.replyContextToken, request.accountId, promptMedia, request.metadata, request.abortSignal, request.onToolEvent, request.onThought, request.perfSpan);
+    return await this.router.handle(request.conversationId, request.text, request.reply, request.replyContextToken, request.accountId, promptMedia, request.metadata, request.abortSignal, request.onToolEvent, request.onThought, request.perfSpan, request.onPlan, request.onUsage);
   }
   isKnownCommand(text) {
     return isKnownXacpxCommandText(text);
@@ -28935,12 +29237,14 @@ class ScheduledTaskScheduler {
   setIntervalFn;
   clearIntervalFn;
   dispatchTask;
+  onSettled;
   logger;
   intervalHandle = null;
   ticking = false;
   constructor(service, deps) {
     this.service = service;
     this.dispatchTask = deps.dispatchTask;
+    this.onSettled = deps.onSettled;
     this.intervalMs = deps.intervalMs ?? 5000;
     this.dispatchTimeoutMs = deps.dispatchTimeoutMs ?? DEFAULT_DISPATCH_TIMEOUT_MS;
     this.setIntervalFn = deps.setIntervalFn ?? ((fn, delay) => setInterval(fn, delay));
@@ -28985,6 +29289,7 @@ class ScheduledTaskScheduler {
           });
           try {
             await this.service.markFailed(task.id, error2);
+            this.notifySettled(task);
           } catch (markError) {
             await this.logger?.error("scheduled.dispatch.mark_failed", "markFailed threw; task state may be stale", {
               taskId: task.id,
@@ -28995,6 +29300,7 @@ class ScheduledTaskScheduler {
         }
         try {
           await this.service.markExecuted(task.id);
+          this.notifySettled(task);
         } catch (markError) {
           await this.logger?.error("scheduled.dispatch.mark_executed_failed", "markExecuted threw after a successful dispatch; leaving task state for startup reconciliation", {
             taskId: task.id,
@@ -29006,6 +29312,18 @@ class ScheduledTaskScheduler {
       this.ticking = false;
     }
   }
+  notifySettled(task) {
+    if (!this.onSettled)
+      return;
+    try {
+      this.onSettled(task);
+    } catch (error2) {
+      this.logger?.error("scheduled.on_settled.failed", "scheduled onSettled listener threw", {
+        taskId: task.id,
+        message: error2 instanceof Error ? error2.message : String(error2)
+      });
+    }
+  }
   async dispatchWithTimeout(task) {
     const controller = new AbortController;
     let timer;
@@ -29041,7 +29359,8 @@ function buildScheduledDispatchTask(deps) {
   };
 }
 async function dispatchBound(task, abortSignal, deps) {
-  const session3 = await deps.getSession(task.session_alias);
+  const internalAlias = deps.resolveAliasForChat ? await deps.resolveAliasForChat(task.chat_key, task.session_alias) : task.session_alias;
+  const session3 = await deps.getSession(internalAlias);
   if (!session3) {
     throw new Error(`session "${task.session_alias}" not found for scheduled task`);
   }
@@ -29050,6 +29369,7 @@ async function dispatchBound(task, abortSignal, deps) {
     chatKey: task.chat_key,
     taskId: task.id,
     sessionAlias: task.session_alias,
+    executeAt: task.execute_at,
     noticeText,
     promptText: task.message,
     abortSignal,
@@ -29070,6 +29390,7 @@ async function dispatchTemp(task, abortSignal, deps) {
       chatKey: task.chat_key,
       taskId: task.id,
       sessionAlias: task.session_alias,
+      executeAt: task.execute_at,
       sessionDescriptor: { alias, agent: task.agent, workspace: task.workspace, transportSession },
       noticeText,
       promptText: task.message,
@@ -29259,6 +29580,7 @@ class SessionService {
       workspace: workspace3,
       transport_session: transportSession,
       transport_agent_command: sameAgentExisting?.transport_agent_command,
+      model: sameAgentExisting?.model,
       created_at: existing?.created_at ?? new Date().toISOString(),
       last_used_at: new Date().toISOString()
     });
@@ -29629,10 +29951,13 @@ class SessionService {
     if (!workspaceConfig) {
       throw new Error(`session "${session3.alias}" references workspace "${session3.workspace}", but that workspace is no longer registered`);
     }
+    const channelId = getChannelIdFromChatKey(session3.alias);
+    const effectiveReplyMode = channelId === "relay" ? "stream" : undefined;
     return {
       alias: session3.alias,
       agent: session3.agent,
-      agentCommand: session3.transport_agent_command ?? resolveAgentCommand(agentConfig.driver, agentConfig.command),
+      agentCommand: session3.transport_agent_command ?? resolveRuntimeAgentCommand(agentConfig.driver, agentConfig.command, this.config.transport.preferLocalAgents !== false),
+      model: session3.model ?? agentConfig.model,
       workspace: session3.workspace,
       transportSession: session3.transport_session,
       source: session3.source,
@@ -29642,9 +29967,46 @@ class SessionService {
       attachedAt: session3.attached_at,
       modeId: session3.mode_id,
       replyMode: session3.reply_mode,
+      effectiveReplyMode,
       cwd: workspaceConfig.cwd
     };
   }
+  async setSessionModel(alias, modelId) {
+    await this.mutate(async () => {
+      const session3 = this.state.sessions[alias];
+      if (!session3) {
+        throw new Error(`session "${alias}" does not exist`);
+      }
+      const normalized = modelId?.trim();
+      if (normalized) {
+        session3.model = normalized;
+      } else {
+        delete session3.model;
+      }
+      session3.last_used_at = new Date(this.now()).toISOString();
+      await this.persist();
+    });
+  }
+  async setCurrentSessionModel(chatKey, modelId) {
+    await this.mutate(async () => {
+      const currentAlias = this.state.chat_contexts[chatKey]?.current_session;
+      if (!currentAlias) {
+        throw new Error("no current session selected");
+      }
+      const session3 = this.state.sessions[currentAlias];
+      if (!session3) {
+        throw new Error("no current session selected");
+      }
+      const normalized = modelId?.trim();
+      if (normalized) {
+        session3.model = normalized;
+      } else {
+        delete session3.model;
+      }
+      session3.last_used_at = new Date(this.now()).toISOString();
+      await this.persist();
+    });
+  }
   async setSessionTransportAgentCommand(alias, transportAgentCommand) {
     await this.mutate(async () => {
       const session3 = this.state.sessions[alias];
@@ -29689,6 +30051,7 @@ class SessionService {
         attached_at: native ? now : undefined,
         ...normalizedTransportAgentCommand ? { transport_agent_command: normalizedTransportAgentCommand } : sameAgentExisting?.transport_agent_command ? { transport_agent_command: sameAgentExisting.transport_agent_command } : {},
         mode_id: sameAgentExisting?.mode_id,
+        model: sameAgentExisting?.model,
         reply_mode: sameAgentExisting?.reply_mode,
         created_at: existingSession?.created_at ?? now,
         last_used_at: now
@@ -29717,6 +30080,7 @@ class SessionService {
   }
 }
 var init_session_service = __esm(() => {
+  init_resolve_agent_command();
   init_i18n();
   init_channel_scope();
 });
@@ -29740,6 +30104,13 @@ function createActiveTurnRegistry() {
     },
     isActive(chatKey, alias) {
       return byChat.get(chatKey)?.has(alias) ?? false;
+    },
+    isActiveAnywhere(alias) {
+      for (const set2 of byChat.values()) {
+        if (set2.has(alias))
+          return true;
+      }
+      return false;
     }
   };
 }
@@ -29848,6 +30219,7 @@ var init_command_hints = __esm(() => {
     config: "/config",
     orchestration: "/delegate",
     mode: "/mode",
+    model: "/model",
     replymode: "/replymode",
     status: "/status",
     cancel: "/cancel",
@@ -29966,7 +30338,8 @@ async function runConsole(paths, deps) {
       perfTracer: runtime.perfTracer,
       commandHints: listXacpxCommandHints(),
       coreVersion: XACPX_CORE_VERSION,
-      locale: getLocale()
+      locale: getLocale(),
+      control: runtime.control
     });
     channelStartPromise.catch(() => {});
     let channelStartSettled = false;
@@ -30102,6 +30475,14 @@ function encodeBridgePromptThoughtEvent(event) {
   return `${JSON.stringify(event)}
 `;
 }
+function encodeBridgePromptPlanEvent(event) {
+  return `${JSON.stringify(event)}
+`;
+}
+function encodeBridgePromptUsageEvent(event) {
+  return `${JSON.stringify(event)}
+`;
+}
 function encodeBridgeSessionProgressEvent(event) {
   return `${JSON.stringify(event)}
 `;
@@ -30111,8 +30492,228 @@ function encodeBridgeSessionNoteEvent(event) {
 `;
 }
 
-// src/transport/acpx-bridge/acpx-bridge-client.ts
+// src/process/spawn-command.ts
+function resolveSpawnCommand(command, args) {
+  if (SCRIPT_FILE_PATTERN.test(command)) {
+    return {
+      command: process.execPath,
+      args: [command, ...args]
+    };
+  }
+  return { command, args };
+}
+var SCRIPT_FILE_PATTERN;
+var init_spawn_command = __esm(() => {
+  SCRIPT_FILE_PATTERN = /\.(c|m)?js$/i;
+});
+
+// src/transport/acpx-queue-owner-launcher.ts
+import { createHash as createHash3 } from "node:crypto";
 import { spawn as spawn7 } from "node:child_process";
+import { readFile as readFile13, unlink } from "node:fs/promises";
+import { homedir as homedir8 } from "node:os";
+import { join as join17 } from "node:path";
+function buildXacpxMcpServerSpec(input) {
+  const { command, args } = splitCommandLine(input.xacpxCommand);
+  return {
+    name: "xacpx",
+    type: "stdio",
+    command,
+    args: [
+      ...args,
+      "mcp-stdio",
+      "--coordinator-session",
+      input.coordinatorSession,
+      ...input.sourceHandle ? ["--source-handle", input.sourceHandle] : ["--internal-session-tools"]
+    ]
+  };
+}
+function buildQueueOwnerPayload(input) {
+  return {
+    sessionId: input.sessionId,
+    permissionMode: input.permissionMode,
+    nonInteractivePermissions: input.nonInteractivePermissions,
+    ttlMs: input.ttlMs ?? 300000,
+    maxQueueDepth: input.maxQueueDepth ?? 16,
+    ...Number.isFinite(input.promptRetries) ? { promptRetries: input.promptRetries } : {},
+    ...input.sessionOptions ? { sessionOptions: input.sessionOptions } : {},
+    mcpServers: input.mcpServers
+  };
+}
+
+class AcpxQueueOwnerLauncher {
+  acpxCommand;
+  xacpxCommand;
+  spawnOwner;
+  terminateOwner;
+  baseEnv;
+  ttlMs;
+  maxQueueDepth;
+  launchLocks = new Map;
+  constructor(options) {
+    this.acpxCommand = options.acpxCommand;
+    this.xacpxCommand = options.xacpxCommand ?? resolveDefaultXacpxCommand(options.baseEnv ?? process.env);
+    this.spawnOwner = options.spawnOwner ?? defaultQueueOwnerSpawner;
+    this.terminateOwner = options.terminateOwner ?? createDefaultQueueOwnerTerminator(options.acpxCommand);
+    this.baseEnv = options.baseEnv ?? process.env;
+    this.ttlMs = options.ttlMs;
+    this.maxQueueDepth = options.maxQueueDepth;
+  }
+  async launch(input) {
+    const key = input.acpxRecordId;
+    const previous = this.launchLocks.get(key) ?? Promise.resolve();
+    const next = previous.then(() => this.doLaunch(input), () => this.doLaunch(input));
+    const tracked = next.catch(() => {});
+    this.launchLocks.set(key, tracked);
+    tracked.finally(() => {
+      if (this.launchLocks.get(key) === tracked) {
+        this.launchLocks.delete(key);
+      }
+    });
+    return next;
+  }
+  async doLaunch(input) {
+    await this.terminateOwner(input.acpxRecordId);
+    const payload = buildQueueOwnerPayload({
+      sessionId: input.acpxRecordId,
+      permissionMode: input.permissionMode,
+      nonInteractivePermissions: input.nonInteractivePermissions,
+      ttlMs: this.ttlMs,
+      maxQueueDepth: this.maxQueueDepth,
+      ...input.sessionOptions ? { sessionOptions: input.sessionOptions } : {},
+      mcpServers: [buildXacpxMcpServerSpec({
+        xacpxCommand: this.xacpxCommand,
+        coordinatorSession: input.coordinatorSession,
+        ...input.sourceHandle ? { sourceHandle: input.sourceHandle } : {}
+      })]
+    });
+    const spawnSpec = resolveSpawnCommand(this.acpxCommand, ["__queue-owner"]);
+    await this.spawnOwner(spawnSpec.command, spawnSpec.args, {
+      env: {
+        ...stringEnv(this.baseEnv),
+        XACPX_LANG: getLocale(),
+        ACPX_QUEUE_OWNER_PAYLOAD: JSON.stringify(payload)
+      }
+    });
+  }
+}
+function splitCommandLine(value) {
+  const parts = [];
+  let current = "";
+  let quote = null;
+  let escaping = false;
+  for (const char of value) {
+    if (escaping) {
+      current += char;
+      escaping = false;
+      continue;
+    }
+    if (char === "\\" && quote !== "'") {
+      escaping = true;
+      continue;
+    }
+    if (quote) {
+      if (char === quote) {
+        quote = null;
+      } else {
+        current += char;
+      }
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      quote = char;
+      continue;
+    }
+    if (/\s/.test(char)) {
+      if (current.length > 0) {
+        parts.push(current);
+        current = "";
+      }
+      continue;
+    }
+    current += char;
+  }
+  if (escaping) {
+    current += "\\";
+  }
+  if (quote) {
+    throw new Error("xacpx MCP command has an unterminated quote");
+  }
+  if (current.length > 0) {
+    parts.push(current);
+  }
+  if (parts.length === 0) {
+    throw new Error("xacpx MCP command must not be empty");
+  }
+  return { command: parts[0], args: parts.slice(1) };
+}
+function stringEnv(env) {
+  return Object.fromEntries(Object.entries(env).filter((entry) => typeof entry[1] === "string"));
+}
+async function defaultQueueOwnerSpawner(command, args, options) {
+  await new Promise((resolve3, reject) => {
+    const child = spawn7(command, args, {
+      detached: true,
+      stdio: "ignore",
+      env: options.env,
+      windowsHide: true
+    });
+    child.once("error", reject);
+    child.once("spawn", () => {
+      child.unref();
+      resolve3();
+    });
+  });
+}
+function createDefaultQueueOwnerTerminator(_acpxCommand) {
+  return async (sessionId) => {
+    await terminateAcpxQueueOwner(sessionId);
+  };
+}
+async function terminateAcpxQueueOwner(sessionId) {
+  const lockPath = queueLockFilePath(sessionId);
+  let owner;
+  try {
+    owner = JSON.parse(await readFile13(lockPath, "utf8"));
+  } catch {
+    return;
+  }
+  if (typeof owner.pid === "number" && Number.isInteger(owner.pid) && owner.pid > 0) {
+    await terminateProcessTree(owner.pid, { detachedProcessGroup: true });
+  }
+  await unlink(lockPath).catch(() => {});
+}
+function queueLockFilePath(sessionId) {
+  return join17(homedir8(), ".acpx", "queues", `${shortHash(sessionId, 24)}.lock`);
+}
+function shortHash(value, length) {
+  return createHash3("sha256").update(value).digest("hex").slice(0, length);
+}
+function resolveDefaultXacpxCommand(env) {
+  const cliCommand = coreEnv("CLI_COMMAND", env);
+  if (cliCommand?.trim()) {
+    return cliCommand.trim();
+  }
+  const daemonArg0 = coreEnv("DAEMON_ARG0", env);
+  if (daemonArg0?.trim()) {
+    return `${quoteCommandPart(process.execPath)} ${quoteCommandPart(daemonArg0.trim())}`;
+  }
+  if (process.argv[1]) {
+    return `${quoteCommandPart(process.execPath)} ${quoteCommandPart(process.argv[1])}`;
+  }
+  return "xacpx";
+}
+function quoteCommandPart(value) {
+  return quoteIfNeeded(value);
+}
+var init_acpx_queue_owner_launcher = __esm(() => {
+  init_spawn_command();
+  init_terminate_process_tree();
+  init_i18n();
+});
+
+// src/transport/acpx-bridge/acpx-bridge-client.ts
+import { spawn as spawn8 } from "node:child_process";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 import { createInterface } from "node:readline";
 
@@ -30179,6 +30780,17 @@ class AcpxBridgeClient {
           type: "prompt.thought",
           text: message.text
         });
+      } else if (message.event === "prompt.plan") {
+        pending.onEvent?.({
+          type: "prompt.plan",
+          entries: message.entries
+        });
+      } else if (message.event === "prompt.usage") {
+        pending.onEvent?.({
+          type: "prompt.usage",
+          used: message.used,
+          size: message.size
+        });
       } else if (message.event === "session.progress") {
         pending.onEvent?.({
           type: "session.progress",
@@ -30228,6 +30840,7 @@ class AcpxBridgeClient {
 function buildBridgeSpawnEnv(options = {}) {
   return {
     XACPX_LANG: getLocale(),
+    XACPX_CLI_COMMAND: options.cliCommand ?? resolveDefaultXacpxCommand(process.env),
     XACPX_BRIDGE_ACPX_COMMAND: options.acpxCommand ?? "acpx",
     XACPX_BRIDGE_PERMISSION_MODE: options.permissionMode ?? "approve-all",
     XACPX_BRIDGE_NON_INTERACTIVE_PERMISSIONS: options.nonInteractivePermissions ?? "deny",
@@ -30254,7 +30867,7 @@ async function spawnAcpxBridgeClient(options = {}) {
     execPath: process.execPath,
     bridgeEntryPath
   });
-  const child = spawn7(spawnSpec.command, spawnSpec.args, {
+  const child = spawn8(spawnSpec.command, spawnSpec.args, {
     cwd: options.cwd ?? process.cwd(),
     env: {
       ...process.env,
@@ -30306,6 +30919,7 @@ var init_acpx_bridge_client = __esm(() => {
   init_errors();
   init_terminate_process_tree();
   init_i18n();
+  init_acpx_queue_owner_launcher();
 });
 
 // src/transport/segment-aggregator.ts
@@ -30508,6 +31122,64 @@ ${headsUpText}`);
     }
   };
 }
+function createVerbatimReplySink(reply) {
+  let pendingError;
+  const inFlight = new Set;
+  const send = (text) => {
+    const p = reply(text).catch((err) => {
+      if (isQuotaDeferredError(err)) {
+        if (!pendingError) {
+          pendingError = err;
+        }
+        return;
+      }
+    });
+    inFlight.add(p);
+    p.finally(() => {
+      inFlight.delete(p);
+    });
+  };
+  return {
+    feedSegment(segment) {
+      if (segment.length === 0)
+        return;
+      send(segment);
+    },
+    finalize() {
+      return { trailing: "", overflowCount: 0 };
+    },
+    getOverflowCount() {
+      return 0;
+    },
+    getPendingError() {
+      return pendingError;
+    },
+    async drain(opts) {
+      const timeoutMs = opts?.timeoutMs ?? 30000;
+      const deadline = Date.now() + timeoutMs;
+      while (inFlight.size > 0) {
+        const remaining = deadline - Date.now();
+        if (remaining <= 0)
+          return;
+        let timer;
+        const timeout = new Promise((resolve3) => {
+          timer = setTimeout(resolve3, remaining);
+        });
+        try {
+          await Promise.race([
+            Promise.allSettled(Array.from(inFlight)).then(() => {
+              return;
+            }),
+            timeout
+          ]);
+        } finally {
+          if (timer)
+            clearTimeout(timer);
+        }
+      }
+    }
+  };
+}
 function buildOverflowSummary(overflowCount) {
   if (overflowCount <= 0)
     return;
@@ -30565,7 +31237,8 @@ class AcpxBridgeTransport {
     });
   }
   async prompt(session3, text, reply, replyContext, options) {
-    const sink = reply ? createQuotaGatedReplySink({
+    const streamMode = (session3.effectiveReplyMode ?? session3.replyMode) === "stream";
+    const sink = reply ? streamMode ? createVerbatimReplySink(reply) : createQuotaGatedReplySink({
       reply,
       ...replyContext ? { replyContext } : {}
     }) : null;
@@ -30575,6 +31248,10 @@ class AcpxBridgeTransport {
     let toolEventChain = Promise.resolve();
     let thoughtError;
     let thoughtChain = Promise.resolve();
+    let planError;
+    let planChain = Promise.resolve();
+    let usageError;
+    let usageChain = Promise.resolve();
     let toolEventMode = resolveToolEventMode(options);
     if ((toolEventMode === "structured" || toolEventMode === "both") && !options?.onToolEvent) {
       toolEventMode = "text";
@@ -30617,10 +31294,32 @@ class AcpxBridgeTransport {
         }
         return;
       }
+      if (event.type === "prompt.plan") {
+        const onPlan = options?.onPlan;
+        if (onPlan) {
+          const entries = event.entries;
+          planChain = planChain.then(() => onPlan(entries)).catch((error2) => {
+            planError ??= error2;
+          });
+        }
+        return;
+      }
+      if (event.type === "prompt.usage") {
+        const onUsage = options?.onUsage;
+        if (onUsage) {
+          const usage = { used: event.used, size: event.size };
+          usageChain = usageChain.then(() => onUsage(usage)).catch((error2) => {
+            usageError ??= error2;
+          });
+        }
+        return;
+      }
     });
     await segmentChain;
     await toolEventChain;
     await thoughtChain;
+    await planChain;
+    await usageChain;
     if (sink) {
       const { overflowCount } = sink.finalize();
       await sink.drain({ timeoutMs: 30000 });
@@ -30638,6 +31337,12 @@ class AcpxBridgeTransport {
       if (thoughtError) {
         throw thoughtError;
       }
+      if (planError) {
+        throw planError;
+      }
+      if (usageError) {
+        throw usageError;
+      }
       return { text: summary ? `${summary}
 
 ${result.text}` : "" };
@@ -30651,6 +31356,12 @@ ${result.text}` : "" };
     if (thoughtError) {
       throw thoughtError;
     }
+    if (planError) {
+      throw planError;
+    }
+    if (usageError) {
+      throw usageError;
+    }
     return result;
   }
   async setMode(session3, modeId) {
@@ -30659,6 +31370,15 @@ ${result.text}` : "" };
       modeId
     });
   }
+  async setModel(session3, modelId) {
+    await this.client.request("setModel", {
+      ...this.toParams({ ...session3, model: modelId }),
+      modelId
+    });
+  }
+  async getSessionModel(session3) {
+    return await this.client.request("getSessionModel", this.toParams(session3));
+  }
   async cancel(session3) {
     return await this.client.request("cancel", this.toParams(session3));
   }
@@ -30687,7 +31407,8 @@ ${result.text}` : "" };
       name: session3.transportSession,
       mcpCoordinatorSession: session3.mcpCoordinatorSession,
       mcpSourceHandle: session3.mcpSourceHandle,
-      replyMode: session3.replyMode ?? "verbose"
+      replyMode: session3.effectiveReplyMode ?? session3.replyMode ?? "verbose",
+      ...session3.model?.trim() ? { model: session3.model.trim() } : {}
     };
   }
 }
@@ -30695,21 +31416,6 @@ var init_acpx_bridge_transport = __esm(() => {
   init_quota_gated_reply_sink();
 });
 
-// src/process/spawn-command.ts
-function resolveSpawnCommand(command, args) {
-  if (SCRIPT_FILE_PATTERN.test(command)) {
-    return {
-      command: process.execPath,
-      args: [command, ...args]
-    };
-  }
-  return { command, args };
-}
-var SCRIPT_FILE_PATTERN;
-var init_spawn_command = __esm(() => {
-  SCRIPT_FILE_PATTERN = /\.(c|m)?js$/i;
-});
-
 // src/transport/prompt-media.ts
 import { mkdtemp, open as open4, rm as rm9, writeFile as writeFile7 } from "node:fs/promises";
 import { tmpdir as defaultTmpdir } from "node:os";
@@ -30860,6 +31566,9 @@ function createStreamingPromptState(formatToolCalls = false, options) {
   let toolEventMode;
   let onToolEvent;
   let onThought;
+  let onPlan;
+  let onUsage;
+  let rawStream = false;
   if (options === undefined) {
     toolEventMode = "text";
     onToolEvent = undefined;
@@ -30869,6 +31578,9 @@ function createStreamingPromptState(formatToolCalls = false, options) {
   } else {
     onToolEvent = options.onToolEvent;
     onThought = options.onThought;
+    onPlan = options.onPlan;
+    onUsage = options.onUsage;
+    rawStream = options.rawStream ?? false;
     toolEventMode = resolveToolEventMode({
       toolEventMode: options.mode,
       onToolEvent
@@ -30882,13 +31594,16 @@ function createStreamingPromptState(formatToolCalls = false, options) {
     formatToolCalls,
     emittedToolCallIds: new Set,
     toolEventMode,
+    rawStream,
     onToolEvent,
     onThought,
+    onPlan,
+    onUsage,
     finalize() {
       if (this.pendingLine.trim().length > 0) {
         parseStreamingChunks(this, this.pendingLine);
       }
-      const remaining = this.buffer.trim();
+      const remaining = this.rawStream ? this.buffer : this.buffer.trim();
       this.buffer = "";
       this.pendingLine = "";
       return remaining;
@@ -30920,9 +31635,9 @@ function parseStreamingChunks(state, line) {
   const update = event.params?.update;
   if (!update)
     return;
-  if (state.formatToolCalls && (update.sessionUpdate === "tool_call" || update.sessionUpdate === "tool_call_update")) {
+  if (update.sessionUpdate === "tool_call" || update.sessionUpdate === "tool_call_update") {
     const wantsStructured = state.toolEventMode === "structured" || state.toolEventMode === "both";
-    const wantsText = state.toolEventMode === "text" || state.toolEventMode === "both";
+    const wantsText = (state.toolEventMode === "text" || state.toolEventMode === "both") && state.formatToolCalls;
     if (wantsStructured && state.onToolEvent) {
       const toolEvent = buildToolUseEvent(update);
       if (toolEvent)
@@ -30942,6 +31657,19 @@ function parseStreamingChunks(state, line) {
     }
     return;
   }
+  if (update.sessionUpdate === "plan") {
+    const entries = Array.isArray(update.entries) ? update.entries.filter((x) => !!x && typeof x === "object" && typeof x.content === "string" && typeof x.status === "string") : [];
+    if (entries.length > 0)
+      state.onPlan?.(entries);
+    return;
+  }
+  if (update.sessionUpdate === "usage_update") {
+    const used = typeof update.used === "number" && Number.isFinite(update.used) ? update.used : undefined;
+    const size = typeof update.size === "number" && Number.isFinite(update.size) ? update.size : undefined;
+    if (used !== undefined && size !== undefined && size > 0)
+      state.onUsage?.({ used, size });
+    return;
+  }
   const isThoughtChunk = update.sessionUpdate === "agent_thought_chunk" && update.content?.type === "text" && typeof update.content.text === "string";
   if (isThoughtChunk) {
     const chunk2 = update.content.text;
@@ -30958,6 +31686,8 @@ function parseStreamingChunks(state, line) {
   if (chunk.length === 0)
     return;
   state.buffer += chunk;
+  if (state.rawStream)
+    return;
   let boundary;
   while ((boundary = state.buffer.indexOf(`
 
@@ -31135,12 +31865,12 @@ var init_streaming_prompt = __esm(() => {
 
 // src/transport/acpx-cli/node-pty-helper.ts
 import { chmod as chmodFs } from "node:fs/promises";
-import { dirname as dirname11, join as join16 } from "node:path";
+import { dirname as dirname11, join as join18 } from "node:path";
 function resolveNodePtyHelperPath(packageJsonPath, platform, arch) {
   if (platform === "win32") {
     return null;
   }
-  return join16(dirname11(packageJsonPath), "prebuilds", `${platform}-${arch}`, "spawn-helper");
+  return join18(dirname11(packageJsonPath), "prebuilds", `${platform}-${arch}`, "spawn-helper");
 }
 async function ensureNodePtyHelperExecutable(helperPath, chmod5 = chmodFs) {
   if (!helperPath) {
@@ -31157,210 +31887,6 @@ async function ensureNodePtyHelperExecutable(helperPath, chmod5 = chmodFs) {
 }
 var init_node_pty_helper = () => {};
 
-// src/transport/acpx-queue-owner-launcher.ts
-import { createHash as createHash3 } from "node:crypto";
-import { spawn as spawn8 } from "node:child_process";
-import { readFile as readFile13, unlink } from "node:fs/promises";
-import { homedir as homedir8 } from "node:os";
-import { join as join17 } from "node:path";
-function buildXacpxMcpServerSpec(input) {
-  const { command, args } = splitCommandLine(input.xacpxCommand);
-  return {
-    name: "xacpx",
-    type: "stdio",
-    command,
-    args: [
-      ...args,
-      "mcp-stdio",
-      "--coordinator-session",
-      input.coordinatorSession,
-      ...input.sourceHandle ? ["--source-handle", input.sourceHandle] : ["--internal-session-tools"]
-    ]
-  };
-}
-function buildQueueOwnerPayload(input) {
-  return {
-    sessionId: input.sessionId,
-    permissionMode: input.permissionMode,
-    nonInteractivePermissions: input.nonInteractivePermissions,
-    ttlMs: input.ttlMs ?? 300000,
-    maxQueueDepth: input.maxQueueDepth ?? 16,
-    ...Number.isFinite(input.promptRetries) ? { promptRetries: input.promptRetries } : {},
-    ...input.sessionOptions ? { sessionOptions: input.sessionOptions } : {},
-    mcpServers: input.mcpServers
-  };
-}
-
-class AcpxQueueOwnerLauncher {
-  acpxCommand;
-  xacpxCommand;
-  spawnOwner;
-  terminateOwner;
-  baseEnv;
-  ttlMs;
-  maxQueueDepth;
-  launchLocks = new Map;
-  constructor(options) {
-    this.acpxCommand = options.acpxCommand;
-    this.xacpxCommand = options.xacpxCommand ?? resolveDefaultXacpxCommand(options.baseEnv ?? process.env);
-    this.spawnOwner = options.spawnOwner ?? defaultQueueOwnerSpawner;
-    this.terminateOwner = options.terminateOwner ?? createDefaultQueueOwnerTerminator(options.acpxCommand);
-    this.baseEnv = options.baseEnv ?? process.env;
-    this.ttlMs = options.ttlMs;
-    this.maxQueueDepth = options.maxQueueDepth;
-  }
-  async launch(input) {
-    const key = input.acpxRecordId;
-    const previous = this.launchLocks.get(key) ?? Promise.resolve();
-    const next = previous.then(() => this.doLaunch(input), () => this.doLaunch(input));
-    const tracked = next.catch(() => {});
-    this.launchLocks.set(key, tracked);
-    tracked.finally(() => {
-      if (this.launchLocks.get(key) === tracked) {
-        this.launchLocks.delete(key);
-      }
-    });
-    return next;
-  }
-  async doLaunch(input) {
-    await this.terminateOwner(input.acpxRecordId);
-    const payload = buildQueueOwnerPayload({
-      sessionId: input.acpxRecordId,
-      permissionMode: input.permissionMode,
-      nonInteractivePermissions: input.nonInteractivePermissions,
-      ttlMs: this.ttlMs,
-      maxQueueDepth: this.maxQueueDepth,
-      mcpServers: [buildXacpxMcpServerSpec({
-        xacpxCommand: this.xacpxCommand,
-        coordinatorSession: input.coordinatorSession,
-        ...input.sourceHandle ? { sourceHandle: input.sourceHandle } : {}
-      })]
-    });
-    const spawnSpec = resolveSpawnCommand(this.acpxCommand, ["__queue-owner"]);
-    await this.spawnOwner(spawnSpec.command, spawnSpec.args, {
-      env: {
-        ...stringEnv(this.baseEnv),
-        XACPX_LANG: getLocale(),
-        ACPX_QUEUE_OWNER_PAYLOAD: JSON.stringify(payload)
-      }
-    });
-  }
-}
-function splitCommandLine(value) {
-  const parts = [];
-  let current = "";
-  let quote = null;
-  let escaping = false;
-  for (const char of value) {
-    if (escaping) {
-      current += char;
-      escaping = false;
-      continue;
-    }
-    if (char === "\\" && quote !== "'") {
-      escaping = true;
-      continue;
-    }
-    if (quote) {
-      if (char === quote) {
-        quote = null;
-      } else {
-        current += char;
-      }
-      continue;
-    }
-    if (char === "'" || char === '"') {
-      quote = char;
-      continue;
-    }
-    if (/\s/.test(char)) {
-      if (current.length > 0) {
-        parts.push(current);
-        current = "";
-      }
-      continue;
-    }
-    current += char;
-  }
-  if (escaping) {
-    current += "\\";
-  }
-  if (quote) {
-    throw new Error("xacpx MCP command has an unterminated quote");
-  }
-  if (current.length > 0) {
-    parts.push(current);
-  }
-  if (parts.length === 0) {
-    throw new Error("xacpx MCP command must not be empty");
-  }
-  return { command: parts[0], args: parts.slice(1) };
-}
-function stringEnv(env) {
-  return Object.fromEntries(Object.entries(env).filter((entry) => typeof entry[1] === "string"));
-}
-async function defaultQueueOwnerSpawner(command, args, options) {
-  await new Promise((resolve3, reject) => {
-    const child = spawn8(command, args, {
-      detached: true,
-      stdio: "ignore",
-      env: options.env,
-      windowsHide: true
-    });
-    child.once("error", reject);
-    child.once("spawn", () => {
-      child.unref();
-      resolve3();
-    });
-  });
-}
-function createDefaultQueueOwnerTerminator(_acpxCommand) {
-  return async (sessionId) => {
-    await terminateAcpxQueueOwner(sessionId);
-  };
-}
-async function terminateAcpxQueueOwner(sessionId) {
-  const lockPath = queueLockFilePath(sessionId);
-  let owner;
-  try {
-    owner = JSON.parse(await readFile13(lockPath, "utf8"));
-  } catch {
-    return;
-  }
-  if (typeof owner.pid === "number" && Number.isInteger(owner.pid) && owner.pid > 0) {
-    await terminateProcessTree(owner.pid, { detachedProcessGroup: true });
-  }
-  await unlink(lockPath).catch(() => {});
-}
-function queueLockFilePath(sessionId) {
-  return join17(homedir8(), ".acpx", "queues", `${shortHash(sessionId, 24)}.lock`);
-}
-function shortHash(value, length) {
-  return createHash3("sha256").update(value).digest("hex").slice(0, length);
-}
-function resolveDefaultXacpxCommand(env) {
-  const cliCommand = coreEnv("CLI_COMMAND", env);
-  if (cliCommand?.trim()) {
-    return cliCommand.trim();
-  }
-  const daemonArg0 = coreEnv("DAEMON_ARG0", env);
-  if (daemonArg0?.trim()) {
-    return `${quoteCommandPart(process.execPath)} ${quoteCommandPart(daemonArg0.trim())}`;
-  }
-  if (process.argv[1]) {
-    return `${quoteCommandPart(process.execPath)} ${quoteCommandPart(process.argv[1])}`;
-  }
-  return "xacpx";
-}
-function quoteCommandPart(value) {
-  return quoteIfNeeded(value);
-}
-var init_acpx_queue_owner_launcher = __esm(() => {
-  init_spawn_command();
-  init_terminate_process_tree();
-  init_i18n();
-});
-
 // src/transport/permission-mode-flag.ts
 function permissionModeToFlag(permissionMode) {
   switch (permissionMode) {
@@ -31578,13 +32104,15 @@ class AcpxCliTransport {
     const structuredPrompt = await createStructuredPromptFile(text, options?.media);
     const args = this.buildPromptArgs(session3, text, structuredPrompt?.filePath);
     try {
-      if (reply || options?.onSegment || options?.onToolEvent || options?.onThought) {
-        const formatToolCalls = (session3.replyMode ?? "verbose") === "verbose";
+      if (reply || options?.onSegment || options?.onToolEvent || options?.onThought || options?.onPlan) {
+        const effectiveReplyMode = session3.effectiveReplyMode ?? session3.replyMode;
+        const formatToolCalls = (effectiveReplyMode ?? "verbose") === "verbose";
+        const rawStream = effectiveReplyMode === "stream";
         let toolEventMode = resolveToolEventMode(options);
         if ((toolEventMode === "structured" || toolEventMode === "both") && !options?.onToolEvent) {
           toolEventMode = "text";
         }
-        const { result: result2, overflowCount } = await this.runStreamingPrompt(this.command, args, reply, formatToolCalls, toolEventMode, replyContext, options?.onSegment, options?.onToolEvent, options?.onThought);
+        const { result: result2, overflowCount } = await this.runStreamingPrompt(this.command, args, reply, formatToolCalls, toolEventMode, replyContext, options?.onSegment, options?.onToolEvent, options?.onThought, options?.onPlan, rawStream);
         const baseText = getPromptText(result2);
         if (!reply) {
           return { text: baseText };
@@ -31610,6 +32138,34 @@ ${baseText}` : "" };
       modeId
     ]));
   }
+  async setModel(session3, modelId) {
+    await this.run(this.buildArgs({ ...session3, model: modelId }, [
+      "set",
+      "-s",
+      session3.transportSession,
+      "model",
+      modelId
+    ]));
+  }
+  async getSessionModel(session3) {
+    const prefix = ["--format", "json", "--cwd", session3.cwd, ...this.buildPermissionArgs()];
+    const tail2 = ["status", "-s", session3.transportSession];
+    const args = session3.agentCommand ? [...prefix, "--agent", session3.agentCommand, ...tail2] : [...prefix, session3.agent, ...tail2];
+    const result = await this.runCommandWithTimeout(this.runCommand, args);
+    if (result.code !== 0) {
+      const detail = normalizeCommandError(result) ?? `command failed with exit code ${result.code}`;
+      throw new Error(detail);
+    }
+    try {
+      const json = JSON.parse(result.stdout);
+      return {
+        current: typeof json.model === "string" ? json.model : undefined,
+        available: Array.isArray(json.availableModels) ? json.availableModels.filter((m) => typeof m === "string") : []
+      };
+    } catch {
+      return { available: [] };
+    }
+  }
   async cancel(session3) {
     const output = await this.run(this.buildArgs(session3, [
       "cancel",
@@ -31673,7 +32229,8 @@ ${baseText}` : "" };
       coordinatorSession: session3.mcpCoordinatorSession,
       ...session3.mcpSourceHandle ? { sourceHandle: session3.mcpSourceHandle } : {},
       permissionMode: this.permissionMode,
-      nonInteractivePermissions: this.nonInteractivePermissions
+      nonInteractivePermissions: this.nonInteractivePermissions,
+      ...session3.model?.trim() ? { sessionOptions: { model: session3.model.trim() } } : {}
     });
   }
   async readSessionRecord(session3) {
@@ -31741,13 +32298,13 @@ ${baseText}` : "" };
       })
     ]);
   }
-  async runStreamingPrompt(command, args, reply, formatToolCalls = false, toolEventMode = "text", replyContext, onSegment, onToolEvent, onThought) {
+  async runStreamingPrompt(command, args, reply, formatToolCalls = false, toolEventMode = "text", replyContext, onSegment, onToolEvent, onThought, onPlan, rawStream = false) {
     const hooks = this.streamingHooks;
     const doSpawn = hooks.spawnPrompt ?? ((cmd, spawnArgs) => spawn9(cmd, spawnArgs, { stdio: ["ignore", "pipe", "pipe"] }));
     const setIntervalFn = hooks.setIntervalFn ?? ((fn, delay) => setInterval(fn, delay));
     const clearIntervalFn = hooks.clearIntervalFn ?? ((timer) => clearInterval(timer));
-    const maxSegmentWaitMs = hooks.maxSegmentWaitMs ?? 30000;
-    const flushCheckIntervalMs = hooks.flushCheckIntervalMs ?? 5000;
+    const maxSegmentWaitMs = hooks.maxSegmentWaitMs ?? (rawStream ? 200 : 30000);
+    const flushCheckIntervalMs = hooks.flushCheckIntervalMs ?? (rawStream ? 80 : 5000);
     const now = hooks.now ?? (() => Date.now());
     return await new Promise((resolve3, reject) => {
       const spawnSpec = resolveSpawnCommand(command, args);
@@ -31761,10 +32318,14 @@ ${baseText}` : "" };
       let toolEventError;
       let thoughtChain = Promise.resolve();
       let thoughtError;
+      let planChain = Promise.resolve();
+      let planError;
       const userOnToolEvent = onToolEvent;
       const userOnThought = onThought;
+      const userOnPlan = onPlan;
       const state = createStreamingPromptState(formatToolCalls, {
         mode: toolEventMode,
+        rawStream,
         ...userOnToolEvent ? {
           onToolEvent: (event) => {
             toolEventChain = toolEventChain.then(() => userOnToolEvent(event)).catch((error2) => {
@@ -31778,9 +32339,16 @@ ${baseText}` : "" };
               thoughtError ??= error2;
             });
           }
+        } : {},
+        ...userOnPlan ? {
+          onPlan: (entries) => {
+            planChain = planChain.then(() => userOnPlan(entries)).catch((error2) => {
+              planError ??= error2;
+            });
+          }
         } : {}
       });
-      const sink = reply ? createQuotaGatedReplySink({
+      const sink = reply ? rawStream ? createVerbatimReplySink(reply) : createQuotaGatedReplySink({
         reply,
         ...replyContext ? { replyContext } : {}
       }) : null;
@@ -31794,7 +32362,7 @@ ${baseText}` : "" };
         lastReplyAt = now();
       };
       const flushBuffer = () => {
-        const remaining = state.buffer.trim();
+        const remaining = rawStream ? state.buffer : state.buffer.trim();
         if (remaining.length > 0) {
           state.buffer = "";
           feedSegment(remaining);
@@ -31831,7 +32399,8 @@ ${baseText}` : "" };
           sink?.drain({ timeoutMs: 30000 }) ?? Promise.resolve(),
           segmentChain,
           toolEventChain,
-          thoughtChain
+          thoughtChain,
+          planChain
         ]).then(() => {
           const deferred = sink?.getPendingError();
           if (deferred) {
@@ -31850,6 +32419,10 @@ ${baseText}` : "" };
             reject(thoughtError);
             return;
           }
+          if (planError) {
+            reject(planError);
+            return;
+          }
           resolve3({
             result: { code: code ?? 1, stdout: stdout2, stderr },
             overflowCount
@@ -31866,7 +32439,8 @@ ${baseText}` : "" };
       "quiet",
       "--cwd",
       session3.cwd,
-      ...this.buildPermissionArgs()
+      ...this.buildPermissionArgs(),
+      ...this.buildModelArgs(session3)
     ];
     if (session3.agentCommand) {
       return [...prefix, "--agent", session3.agentCommand, ...tail2];
@@ -31888,6 +32462,7 @@ ${baseText}` : "" };
       "--cwd",
       session3.cwd,
       ...this.buildPermissionArgs(),
+      ...this.buildModelArgs(session3),
       ...this.buildQueueOwnerTtlArgs()
     ];
     const tail2 = promptFile ? ["prompt", "-s", session3.transportSession, "--file", promptFile] : ["prompt", "-s", session3.transportSession, text];
@@ -31896,6 +32471,10 @@ ${baseText}` : "" };
     }
     return [...prefix, session3.agent, ...tail2];
   }
+  buildModelArgs(session3) {
+    const model = session3.model?.trim();
+    return model ? ["--model", model] : [];
+  }
   buildQueueOwnerTtlArgs() {
     if (typeof this.queueOwnerTtlSeconds !== "number" || !Number.isFinite(this.queueOwnerTtlSeconds)) {
       return [];
@@ -32092,7 +32671,7 @@ function workerBindingReapTargets(orchestration3, config4) {
     if (!cwd) {
       continue;
     }
-    const agentCommand = resolveAgentCommand(agentConfig.driver, agentConfig.command);
+    const agentCommand = resolveRuntimeAgentCommand(agentConfig.driver, agentConfig.command, config4.transport.preferLocalAgents !== false);
     targets.push({
       agent: binding.targetAgent,
       ...agentCommand ? { agentCommand } : {},
@@ -32102,7 +32681,9 @@ function workerBindingReapTargets(orchestration3, config4) {
   }
   return targets;
 }
-var init_collect_reap_targets = () => {};
+var init_collect_reap_targets = __esm(() => {
+  init_resolve_agent_command();
+});
 
 // src/channels/channel-registry.ts
 var exports_channel_registry = {};
@@ -32389,6 +32970,761 @@ var init_quota_manager = __esm(() => {
   DEFAULT_STATE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
 });
 
+// src/control/control-event-bus.ts
+function createControlEventBus(logger2) {
+  const listeners = new Set;
+  return {
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    emit(event) {
+      for (const listener of [...listeners]) {
+        try {
+          listener(event);
+        } catch (error2) {
+          logger2?.error("control.event_listener_failed", "control event listener threw", {
+            eventType: event.type,
+            error: error2 instanceof Error ? error2.message : String(error2)
+          });
+        }
+      }
+    }
+  };
+}
+
+// src/transport/native-session-history.ts
+import { readFile as readFile14 } from "node:fs/promises";
+import { homedir as homedir9 } from "node:os";
+import { join as join19 } from "node:path";
+function classifyToolKind(name) {
+  const n = name.toLowerCase();
+  if (/(^|[^a-z])(read|cat|view|open)([^a-z]|$)/.test(n))
+    return "read";
+  if (/(grep|search|find|glob|ripgrep|rg)/.test(n))
+    return "search";
+  if (/(edit|write|apply|patch|replace|create)/.test(n))
+    return "edit";
+  if (/(bash|shell|exec|run|terminal|command)/.test(n))
+    return "execute";
+  if (/(think|reason|plan)/.test(n))
+    return "think";
+  return "other";
+}
+function textOfUserContent(content) {
+  if (!Array.isArray(content))
+    return "";
+  const out = [];
+  for (const c of content) {
+    if (c && typeof c === "object") {
+      const o = c;
+      if (typeof o.Text === "string")
+        out.push(o.Text);
+      else if (o.Mention && typeof o.Mention.content === "string")
+        out.push(String(o.Mention.content));
+      else if (o.Image)
+        out.push("[image]");
+      else if (o.Audio)
+        out.push("[audio]");
+    }
+  }
+  return out.join(`
+`);
+}
+function toolResultText(result) {
+  if (!result || typeof result !== "object")
+    return { isError: false };
+  const r = result;
+  const isError = r.is_error === true;
+  if (typeof r.output === "string")
+    return { text: r.output, isError };
+  const content = r.content;
+  if (content && typeof content.Text === "string")
+    return { text: content.Text, isError };
+  return { isError };
+}
+function toolUseEventOf(toolUse, result) {
+  const id = typeof toolUse.id === "string" ? toolUse.id : "";
+  const name = typeof toolUse.name === "string" ? toolUse.name : "tool";
+  const rawInput = toolUse.input ?? (typeof toolUse.raw_input === "string" ? safeParse4(toolUse.raw_input) : undefined);
+  const res = toolResultText(result);
+  return {
+    toolCallId: id,
+    toolName: name,
+    kind: classifyToolKind(name),
+    ...rawInput !== undefined ? { rawInput } : {},
+    ...res.text !== undefined ? { rawOutput: res.text } : {},
+    status: result ? res.isError ? "error" : "success" : "success"
+  };
+}
+function safeParse4(s) {
+  try {
+    return JSON.parse(s);
+  } catch {
+    return s;
+  }
+}
+function mapAcpxMessagesToHistory(raw) {
+  if (!Array.isArray(raw))
+    return [];
+  const out = [];
+  for (const msg of raw) {
+    if (msg === "Resume" || !msg || typeof msg !== "object")
+      continue;
+    const m = msg;
+    if (m.User && typeof m.User === "object") {
+      const text = textOfUserContent(m.User.content);
+      out.push({ role: "user", text });
+      continue;
+    }
+    if (m.Agent && typeof m.Agent === "object") {
+      const agent3 = m.Agent;
+      const toolResults = agent3.tool_results ?? {};
+      const parts = [];
+      const textChunks = [];
+      for (const c of Array.isArray(agent3.content) ? agent3.content : []) {
+        if (!c || typeof c !== "object")
+          continue;
+        const o = c;
+        if (typeof o.Text === "string") {
+          parts.push({ kind: "text", text: o.Text });
+          textChunks.push(o.Text);
+        } else if (o.Thinking && typeof o.Thinking.text === "string")
+          parts.push({ kind: "reasoning", text: String(o.Thinking.text) });
+        else if (typeof o.RedactedThinking === "string")
+          parts.push({ kind: "reasoning", text: "[redacted reasoning]" });
+        else if (o.ToolUse && typeof o.ToolUse === "object") {
+          const tu = o.ToolUse;
+          const result = typeof tu.id === "string" ? toolResults[tu.id] : undefined;
+          parts.push({ kind: "tool", tool: toolUseEventOf(tu, result) });
+        }
+      }
+      out.push({ role: "agent", text: textChunks.join(`
+
+`), ...parts.length ? { parts } : {} });
+    }
+  }
+  return out;
+}
+async function readNativeSessionHistory(opts) {
+  try {
+    const dir = opts.sessionsDir ?? join19(opts.homeDir ?? homedir9(), ".acpx", "sessions");
+    const indexRaw = await readFile14(join19(dir, "index.json"), "utf8").catch(() => null);
+    if (!indexRaw)
+      return [];
+    const index = JSON.parse(indexRaw);
+    const candidates = (index.entries ?? []).filter((e) => e.acpSessionId === opts.agentSessionId && (!opts.agentCommand || !e.agentCommand || e.agentCommand === opts.agentCommand));
+    let best = [];
+    for (const entry of candidates) {
+      if (!entry.file)
+        continue;
+      const recRaw = await readFile14(join19(dir, entry.file), "utf8").catch(() => null);
+      if (!recRaw)
+        continue;
+      const record3 = JSON.parse(recRaw);
+      const mapped = mapAcpxMessagesToHistory(record3.messages);
+      if (mapped.length > best.length)
+        best = mapped;
+    }
+    return best;
+  } catch {
+    return [];
+  }
+}
+var init_native_session_history = () => {};
+
+// src/control/workspace-fs.ts
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { homedir as homedir10 } from "node:os";
+import { readdir as readdir3, realpath, stat as stat3, open as open5 } from "node:fs/promises";
+import { isAbsolute as isAbsolute3, relative, resolve as resolve3, sep } from "node:path";
+function expandHome2(p) {
+  if (p === "~")
+    return homedir10();
+  if (p.startsWith("~/") || p.startsWith("~" + sep))
+    return resolve3(homedir10(), p.slice(2));
+  return p;
+}
+
+class WorkspaceFs {
+  listWorkspaces;
+  constructor(listWorkspaces) {
+    this.listWorkspaces = listWorkspaces;
+  }
+  async resolve(workspace3, relPath) {
+    const ref = this.listWorkspaces().find((w) => w.name === workspace3);
+    if (!ref)
+      throw new Error("unknown-workspace");
+    if (relPath && isAbsolute3(relPath))
+      throw new Error("path-must-be-relative");
+    let root;
+    try {
+      root = await realpath(expandHome2(ref.cwd));
+    } catch {
+      throw new Error("workspace-root-missing");
+    }
+    const requested = resolve3(root, relPath ?? ".");
+    let abs;
+    try {
+      abs = await realpath(requested);
+    } catch {
+      throw new Error("not-found");
+    }
+    if (abs !== root && !abs.startsWith(root + sep))
+      throw new Error("path-escapes-workspace");
+    const rel = abs === root ? "" : relative(root, abs).split(sep).join("/");
+    return { root, abs, rel };
+  }
+  async listDirectory(workspace3, relPath) {
+    const { abs, rel } = await this.resolve(workspace3, relPath);
+    const dirents = await readdir3(abs, { withFileTypes: true });
+    const entries = [];
+    for (const d of dirents.slice(0, MAX_ENTRIES)) {
+      if (d.isDirectory()) {
+        entries.push({ name: d.name, type: "dir" });
+      } else if (d.isFile()) {
+        let size;
+        try {
+          size = (await stat3(resolve3(abs, d.name))).size;
+        } catch {
+          size = undefined;
+        }
+        entries.push({ name: d.name, type: "file", size });
+      }
+    }
+    entries.sort((a, b) => a.type !== b.type ? a.type === "dir" ? -1 : 1 : a.name.localeCompare(b.name));
+    return { workspace: workspace3, path: rel, entries };
+  }
+  async readFile(workspace3, relPath) {
+    const { abs, rel } = await this.resolve(workspace3, relPath);
+    const info = await stat3(abs);
+    if (!info.isFile())
+      throw new Error("not-a-file");
+    const fh = await open5(abs, "r");
+    try {
+      const buf = Buffer.alloc(Math.min(info.size, FILE_READ_CAP));
+      const { bytesRead } = await fh.read(buf, 0, buf.length, 0);
+      const slice = buf.subarray(0, bytesRead);
+      const binary = slice.includes(0);
+      return {
+        workspace: workspace3,
+        path: rel,
+        content: binary ? "" : slice.toString("utf8"),
+        size: info.size,
+        truncated: info.size > FILE_READ_CAP,
+        binary
+      };
+    } finally {
+      await fh.close();
+    }
+  }
+  async search(workspace3, query) {
+    const { root } = await this.resolve(workspace3, undefined);
+    const needle = query.trim().toLowerCase();
+    const matches = [];
+    if (!needle)
+      return { workspace: workspace3, query, matches, truncated: false };
+    let scanned = 0;
+    let truncated = false;
+    const queue = [root];
+    while (queue.length) {
+      const dir = queue.shift();
+      let dirents;
+      try {
+        dirents = await readdir3(dir, { withFileTypes: true });
+      } catch {
+        continue;
+      }
+      for (const d of dirents) {
+        if (++scanned > SEARCH_MAX_SCAN) {
+          truncated = true;
+          break;
+        }
+        if (d.isSymbolicLink())
+          continue;
+        if (d.isDirectory()) {
+          if (!SEARCH_SKIP_DIRS.has(d.name))
+            queue.push(resolve3(dir, d.name));
+        } else if (d.isFile()) {
+          const rel = relative(root, resolve3(dir, d.name)).split(sep).join("/");
+          if (rel.toLowerCase().includes(needle)) {
+            matches.push(rel);
+            if (matches.length >= SEARCH_MAX_RESULTS) {
+              truncated = true;
+              break;
+            }
+          }
+        }
+      }
+      if (truncated)
+        break;
+    }
+    matches.sort();
+    return { workspace: workspace3, query, matches, truncated };
+  }
+  async gitDiff(workspace3, relPath) {
+    const { root, rel } = await this.resolve(workspace3, relPath);
+    try {
+      await execFileAsync("git", ["-C", root, "rev-parse", "--is-inside-work-tree"], { maxBuffer: GIT_MAX_BUFFER });
+    } catch {
+      throw new Error("not-a-git-repo");
+    }
+    const files = [];
+    try {
+      const { stdout: stdout2 } = await execFileAsync("git", ["-C", root, "status", "--porcelain"], { maxBuffer: GIT_MAX_BUFFER });
+      for (const line of stdout2.split(`
+`)) {
+        if (!line)
+          continue;
+        const status = line.slice(0, 2);
+        let path15 = line.slice(3);
+        const arrow = path15.indexOf(" -> ");
+        if (arrow >= 0)
+          path15 = path15.slice(arrow + 4);
+        files.push({ path: path15, status });
+      }
+    } catch {}
+    const diffArgs = (base) => ["-C", root, ...base, ...rel ? ["--", rel] : []];
+    let diff = "";
+    try {
+      diff = (await execFileAsync("git", diffArgs(["diff", "HEAD"]), { maxBuffer: GIT_MAX_BUFFER })).stdout;
+    } catch {
+      try {
+        diff = (await execFileAsync("git", diffArgs(["diff"]), { maxBuffer: GIT_MAX_BUFFER })).stdout;
+      } catch {
+        diff = "";
+      }
+    }
+    const truncated = diff.length > DIFF_CAP;
+    return { workspace: workspace3, files, diff: truncated ? diff.slice(0, DIFF_CAP) : diff, truncated, ...await this.gitContext(root) };
+  }
+  async gitContext(root) {
+    const run = async (...args) => {
+      try {
+        return (await execFileAsync("git", ["-C", root, ...args], { maxBuffer: GIT_MAX_BUFFER })).stdout.trim();
+      } catch {
+        return null;
+      }
+    };
+    const ctx = {};
+    const head = await run("rev-parse", "--abbrev-ref", "HEAD");
+    if (head === "HEAD")
+      ctx.detached = true;
+    else if (head)
+      ctx.branch = head;
+    const top = await run("rev-parse", "--show-toplevel");
+    if (top) {
+      const gitDir = await run("rev-parse", "--absolute-git-dir");
+      const commonDir = await run("rev-parse", "--path-format=absolute", "--git-common-dir");
+      ctx.worktree = { root: top, linked: !!gitDir && !!commonDir && gitDir !== commonDir };
+    }
+    return ctx;
+  }
+}
+var execFileAsync, MAX_ENTRIES = 2000, FILE_READ_CAP, DIFF_CAP, GIT_MAX_BUFFER, SEARCH_MAX_RESULTS = 200, SEARCH_MAX_SCAN = 20000, SEARCH_SKIP_DIRS;
+var init_workspace_fs = __esm(() => {
+  execFileAsync = promisify(execFile);
+  FILE_READ_CAP = 256 * 1024;
+  DIFF_CAP = 512 * 1024;
+  GIT_MAX_BUFFER = 32 * 1024 * 1024;
+  SEARCH_SKIP_DIRS = new Set([".git", "node_modules"]);
+});
+
+// src/control/control-service.ts
+class ControlService {
+  deps;
+  constructor(deps) {
+    this.deps = deps;
+  }
+  workspaceFs = new WorkspaceFs(() => this.deps.workspaces.list().map((w) => ({ name: w.name, cwd: w.cwd })));
+  listDirectory(workspace3, path15) {
+    return this.workspaceFs.listDirectory(workspace3, path15);
+  }
+  readWorkspaceFile(workspace3, path15) {
+    return this.workspaceFs.readFile(workspace3, path15);
+  }
+  workspaceGitDiff(workspace3, path15) {
+    return this.workspaceFs.gitDiff(workspace3, path15);
+  }
+  searchWorkspace(workspace3, query) {
+    return this.workspaceFs.search(workspace3, query);
+  }
+  async getSessionModel(chatKey, alias) {
+    const session3 = await this.resolveControlSession(chatKey, alias);
+    if (!session3)
+      return { available: [] };
+    if (!this.deps.transport.getSessionModel)
+      return { current: session3.model, available: [] };
+    return await this.deps.transport.getSessionModel(session3);
+  }
+  async setSessionModel(chatKey, alias, modelId) {
+    const session3 = await this.resolveControlSession(chatKey, alias);
+    if (!session3)
+      throw new Error("session not found");
+    if (!this.deps.transport.setModel)
+      throw new Error("the active transport does not support switching models");
+    await this.deps.transport.setModel(session3, modelId);
+    await this.deps.sessions.setSessionModel(session3.alias, modelId);
+  }
+  async resolveControlSession(chatKey, alias) {
+    const internalAlias = await this.deps.sessions.resolveAliasForChat(chatKey, alias);
+    return await this.deps.sessions.getSession(internalAlias);
+  }
+  get events() {
+    return this.deps.events;
+  }
+  listSessions(chatKey) {
+    const channelId = getChannelIdFromChatKey(chatKey);
+    return this.deps.sessions.listAllResolvedSessions().filter((session3) => isSessionAliasVisibleInChannel(session3.alias, channelId)).map((session3) => ({
+      alias: toDisplaySessionAlias(session3.alias),
+      agent: session3.agent,
+      workspace: session3.workspace,
+      transportSession: session3.transportSession,
+      running: this.deps.activeTurns.isActiveAnywhere(session3.alias)
+    }));
+  }
+  async listNativeSessions(_chatKey, agent3, workspace3) {
+    const sessions = await this.deps.listNativeSessions(agent3, workspace3);
+    return sessions.map((s) => ({
+      sessionId: s.sessionId,
+      title: s.title ?? null,
+      ...s.updatedAt !== undefined ? { updatedAt: s.updatedAt } : {},
+      ...s.cwd !== undefined ? { cwd: s.cwd } : {}
+    }));
+  }
+  async createSession(chatKey, alias, agent3, workspace3, agentSessionId, model) {
+    const internalAlias = await this.deps.sessions.resolveAliasForChat(chatKey, alias);
+    let nativeHistory = [];
+    if (agentSessionId) {
+      try {
+        nativeHistory = await readNativeSessionHistory({ agentSessionId });
+      } catch {}
+    }
+    const session3 = agentSessionId ? await this.deps.attachNativeSessionWithTransport(internalAlias, agent3, workspace3, agentSessionId) : await this.deps.createSessionWithTransport(internalAlias, agent3, workspace3, model);
+    this.deps.events.emit({ type: "sessions-changed" });
+    if (nativeHistory.length > 0) {
+      this.deps.events.emit({ type: "session-history", chatKey, sessionAlias: alias, messages: nativeHistory });
+    }
+    return {
+      alias: toDisplaySessionAlias(session3.alias),
+      agent: session3.agent,
+      workspace: session3.workspace,
+      transportSession: session3.transportSession,
+      running: false
+    };
+  }
+  async removeSession(chatKey, alias) {
+    const internalAlias = await this.deps.sessions.resolveAliasForChat(chatKey, alias);
+    const result = await this.deps.sessions.removeSession(internalAlias);
+    this.deps.events.emit({ type: "sessions-changed" });
+    return result;
+  }
+  listAgents() {
+    return this.deps.agents.list();
+  }
+  listWorkspaces() {
+    return this.deps.workspaces.list();
+  }
+  createWorkspace(name, cwd, description) {
+    return this.deps.workspaces.create(name, cwd, description);
+  }
+  listAgentCatalog() {
+    return this.deps.agents.catalog();
+  }
+  createAgent(name, driver) {
+    return this.deps.agents.create(name, driver);
+  }
+  async removeAgent(name) {
+    if (this.deps.sessions.listAllResolvedSessions().some((s) => s.agent === name)) {
+      throw new Error(`agent "${name}" is in use by an existing session`);
+    }
+    await this.deps.agents.remove(name);
+  }
+  async removeWorkspace(name) {
+    if (this.deps.sessions.listAllResolvedSessions().some((s) => s.workspace === name)) {
+      throw new Error(`workspace "${name}" is in use by an existing session`);
+    }
+    await this.deps.workspaces.remove(name);
+  }
+  listScheduledTasks(chatKey) {
+    return this.deps.scheduled.listRecentForChat(chatKey);
+  }
+  async createScheduledTask(input) {
+    const task = await this.deps.scheduled.createTask(input);
+    this.deps.events.emit({ type: "scheduled-changed", chatKey: input.chatKey });
+    return task;
+  }
+  async cancelScheduledTask(id, chatKey) {
+    const cancelled = await this.deps.scheduled.cancelPending(id, chatKey);
+    if (cancelled) {
+      this.deps.events.emit({ type: "scheduled-changed", chatKey });
+    }
+    return cancelled;
+  }
+  listOrchestrationTasks(filter) {
+    return this.deps.orchestration.listTasks(filter);
+  }
+  getOrchestrationTask(taskId) {
+    return this.deps.orchestration.getTask(taskId);
+  }
+  async cancelOrchestrationTask(input) {
+    const task = await this.deps.orchestration.requestTaskCancellation(input);
+    this.deps.events.emit({ type: "orchestration-changed" });
+    return task;
+  }
+  inFlight = new Map;
+  async prompt(input) {
+    return this.executeTurn({
+      chatKey: input.chatKey,
+      sessionAlias: input.sessionAlias,
+      text: input.text,
+      senderId: input.senderId,
+      ...input.isOwner !== undefined ? { isOwner: input.isOwner } : {},
+      ...input.accountId !== undefined ? { accountId: input.accountId } : {}
+    });
+  }
+  async runScheduledTurn(input) {
+    return this.executeTurn({
+      chatKey: input.chatKey,
+      sessionAlias: input.sessionAlias,
+      text: input.promptText,
+      senderId: "scheduler",
+      isOwner: true,
+      ...input.accountId !== undefined ? { accountId: input.accountId } : {},
+      ...input.abortSignal ? { abortSignal: input.abortSignal } : {},
+      turnStarted: { prompt: input.promptText, scheduled: { taskId: input.taskId, executeAt: input.executeAt } }
+    });
+  }
+  async executeTurn(params) {
+    const key = turnKey(params.chatKey, params.sessionAlias);
+    const existing = this.inFlight.get(key);
+    if (existing) {
+      if (!existing.controller.signal.aborted) {
+        return { ok: false, errorMessage: "turn-already-running" };
+      }
+      await raceWithTimeout(existing.settled, CANCEL_DRAIN_TIMEOUT_MS);
+      if (this.inFlight.has(key)) {
+        return { ok: false, errorMessage: "turn-already-running" };
+      }
+    }
+    const controller = new AbortController;
+    if (params.abortSignal) {
+      if (params.abortSignal.aborted)
+        controller.abort();
+      else
+        params.abortSignal.addEventListener("abort", () => controller.abort(), { once: true });
+    }
+    let resolveSettled;
+    const settled = new Promise((resolve4) => {
+      resolveSettled = resolve4;
+    });
+    this.inFlight.set(key, { controller, settled });
+    try {
+      await this.deps.sessions.useSession(params.chatKey, params.sessionAlias);
+    } catch (error2) {
+      this.inFlight.delete(key);
+      resolveSettled();
+      return { ok: false, errorMessage: toErrorMessage(error2) };
+    }
+    this.deps.events.emit({
+      type: "turn-started",
+      chatKey: params.chatKey,
+      sessionAlias: params.sessionAlias,
+      ...params.turnStarted?.prompt ? { prompt: params.turnStarted.prompt } : {},
+      ...params.turnStarted?.scheduled ? { scheduled: params.turnStarted.scheduled } : {}
+    });
+    let streamMode = false;
+    try {
+      const resolved = await this.resolveControlSession(params.chatKey, params.sessionAlias);
+      streamMode = (resolved?.effectiveReplyMode ?? resolved?.replyMode) === "stream";
+    } catch {}
+    let emittedChunk = false;
+    const emitChunk = (chunk) => {
+      if (!chunk)
+        return;
+      this.deps.events.emit({
+        type: "turn-output",
+        chatKey: params.chatKey,
+        sessionAlias: params.sessionAlias,
+        chunk: !streamMode && emittedChunk ? `
+
+${chunk}` : chunk
+      });
+      emittedChunk = true;
+    };
+    try {
+      const response = await this.deps.agent.chat({
+        accountId: params.accountId ?? "control",
+        conversationId: params.chatKey,
+        text: params.text,
+        metadata: buildControlMetadata(params.senderId, params.isOwner),
+        abortSignal: controller.signal,
+        reply: async (chunk) => {
+          emitChunk(chunk);
+        },
+        onToolEvent: (event) => {
+          this.deps.events.emit({
+            type: "tool-event",
+            chatKey: params.chatKey,
+            sessionAlias: params.sessionAlias,
+            event
+          });
+        },
+        onThought: (chunk) => {
+          this.deps.events.emit({
+            type: "turn-thought",
+            chatKey: params.chatKey,
+            sessionAlias: params.sessionAlias,
+            chunk
+          });
+        },
+        onPlan: (entries) => {
+          this.deps.events.emit({
+            type: "plan",
+            chatKey: params.chatKey,
+            sessionAlias: params.sessionAlias,
+            entries
+          });
+        },
+        onUsage: (usage) => {
+          this.deps.events.emit({
+            type: "turn-usage",
+            chatKey: params.chatKey,
+            sessionAlias: params.sessionAlias,
+            used: usage.used,
+            size: usage.size
+          });
+        }
+      });
+      if (response.text) {
+        emitChunk(response.text);
+      }
+      this.deps.events.emit({
+        type: "turn-finished",
+        chatKey: params.chatKey,
+        sessionAlias: params.sessionAlias,
+        ok: true
+      });
+      return { ok: true, text: response.text };
+    } catch (error2) {
+      const errorMessage = toErrorMessage(error2);
+      this.deps.events.emit({
+        type: "turn-finished",
+        chatKey: params.chatKey,
+        sessionAlias: params.sessionAlias,
+        ok: false,
+        errorMessage,
+        ...controller.signal.aborted ? { cancelled: true } : {}
+      });
+      return { ok: false, errorMessage };
+    } finally {
+      this.inFlight.delete(key);
+      resolveSettled();
+    }
+  }
+  cancelTurn(chatKey, sessionAlias) {
+    const entry = this.inFlight.get(turnKey(chatKey, sessionAlias));
+    if (!entry) {
+      return false;
+    }
+    entry.controller.abort();
+    return true;
+  }
+  async executeCommand(input) {
+    const chunks = [];
+    const response = await this.deps.agent.chat({
+      accountId: input.accountId ?? "control",
+      conversationId: input.chatKey,
+      text: input.text,
+      metadata: buildControlMetadata(input.senderId, input.isOwner),
+      reply: async (chunk) => {
+        chunks.push(chunk);
+      }
+    });
+    if (response.text) {
+      chunks.push(response.text);
+    }
+    return chunks.join(`
+`);
+  }
+}
+async function raceWithTimeout(promise2, ms) {
+  let timer;
+  const timeout = new Promise((resolve4) => {
+    timer = setTimeout(resolve4, ms);
+  });
+  try {
+    await Promise.race([promise2, timeout]);
+  } finally {
+    if (timer)
+      clearTimeout(timer);
+  }
+}
+function turnKey(chatKey, sessionAlias) {
+  return `${chatKey} ${sessionAlias}`;
+}
+function toErrorMessage(error2) {
+  return error2 instanceof Error ? error2.message : String(error2);
+}
+function buildControlMetadata(senderId, isOwner) {
+  return {
+    channel: "control",
+    chatType: "direct",
+    senderId,
+    ...isOwner === undefined ? {} : { isOwner }
+  };
+}
+var CANCEL_DRAIN_TIMEOUT_MS = 5000;
+var init_control_service = __esm(() => {
+  init_channel_scope();
+  init_native_session_history();
+  init_workspace_fs();
+});
+
+// src/config/agent-catalog.ts
+import { existsSync as existsSync3 } from "node:fs";
+import { delimiter as delimiter2, join as join20 } from "node:path";
+function isBinaryOnPath(binary) {
+  const path15 = process.env.PATH ?? "";
+  const exts = process.platform === "win32" ? ["", ".exe", ".cmd", ".bat"] : [""];
+  for (const dir of path15.split(delimiter2)) {
+    if (!dir)
+      continue;
+    for (const ext of exts) {
+      try {
+        if (existsSync3(join20(dir, binary + ext)))
+          return true;
+      } catch {}
+    }
+  }
+  return false;
+}
+function listAgentCatalog(config4, probe = isBinaryOnPath) {
+  const agents = config4.agents ?? {};
+  const driverConfigured = (driver) => Object.entries(agents).some(([name, a]) => name === driver || a.driver === driver);
+  return listAgentTemplates().map((driver) => {
+    let installed;
+    if (BUILTIN_DRIVERS.has(driver)) {
+      installed = "builtin";
+    } else {
+      const binary = DRIVER_BINARIES[driver] ?? driver;
+      installed = probe(binary) ? "yes" : "unknown";
+    }
+    return { driver, configured: driverConfigured(driver), installed };
+  });
+}
+var BUILTIN_DRIVERS, DRIVER_BINARIES;
+var init_agent_catalog = __esm(() => {
+  init_agent_templates();
+  BUILTIN_DRIVERS = new Set(["codex", "claude"]);
+  DRIVER_BINARIES = {
+    cursor: "cursor-agent"
+  };
+});
+
 // src/main.ts
 var exports_main = {};
 __export(exports_main, {
@@ -32399,8 +33735,8 @@ __export(exports_main, {
   buildApp: () => buildApp
 });
 import { randomUUID as randomUUID3 } from "node:crypto";
-import { homedir as homedir9 } from "node:os";
-import { dirname as dirname12, join as join18 } from "node:path";
+import { homedir as homedir11 } from "node:os";
+import { dirname as dirname12, join as join21 } from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 function startProgressHeartbeat(orchestration3, config4, logger2, channel) {
   const thresholdSeconds = config4.orchestration.progressHeartbeatSeconds;
@@ -32676,7 +34012,7 @@ async function buildApp(paths, deps = {}) {
     return {
       alias: input.workerSession,
       agent: input.targetAgent,
-      agentCommand: resolveAgentCommand(agentConfig.driver, agentConfig.command),
+      agentCommand: resolveRuntimeAgentCommand(agentConfig.driver, agentConfig.command, config4.transport.preferLocalAgents !== false),
       workspace: input.workspace,
       transportSession: input.workerSession,
       cwd: input.cwd
@@ -32890,9 +34226,52 @@ async function buildApp(paths, deps = {}) {
   });
   const router3 = new CommandRouter(sessions, transport, config4, configStore, logger2, undefined, orchestration3, quota, scheduledService, deps.channel?.supportsScheduledMessages ? { supportsScheduledMessages: deps.channel.supportsScheduledMessages.bind(deps.channel) } : undefined, deps.channel?.nativeSessionListFormat ? deps.channel.nativeSessionListFormat.bind(deps.channel) : undefined, activeTurns);
   const agent3 = new ConsoleAgent(router3, logger2);
+  const controlEvents = createControlEventBus(logger2);
+  const control = new ControlService({
+    agent: agent3,
+    sessions,
+    transport,
+    createSessionWithTransport: (internalAlias, agent4, workspace3, model) => router3.createSessionWithTransport(internalAlias, agent4, workspace3, model),
+    listNativeSessions: (agent4, workspace3) => router3.listNativeSessionsForControl(agent4, workspace3),
+    attachNativeSessionWithTransport: (internalAlias, agent4, workspace3, agentSessionId, nativeMeta) => router3.attachNativeSessionWithTransport(internalAlias, agent4, workspace3, agentSessionId, nativeMeta),
+    activeTurns,
+    scheduled: scheduledService,
+    orchestration: orchestration3,
+    events: controlEvents,
+    agents: {
+      list: () => Object.entries(config4.agents).map(([name, agentConfig]) => ({ name, driver: agentConfig.driver })),
+      catalog: () => listAgentCatalog(config4),
+      create: async (name, driver) => {
+        const updated = await configStore.upsertAgent(name, { driver });
+        replaceRuntimeConfig(config4, updated);
+        return { name, driver };
+      },
+      remove: async (name) => {
+        const updated = await configStore.removeAgent(name);
+        replaceRuntimeConfig(config4, updated);
+      }
+    },
+    workspaces: {
+      list: () => Object.entries(config4.workspaces).map(([name, workspace3]) => ({
+        name,
+        cwd: workspace3.cwd,
+        ...workspace3.description ? { description: workspace3.description } : {}
+      })),
+      create: async (name, cwd, description) => {
+        const updated = await configStore.upsertWorkspace(name, cwd, description);
+        replaceRuntimeConfig(config4, updated);
+        return { name, cwd, ...description ? { description } : {} };
+      },
+      remove: async (name) => {
+        const updated = await configStore.removeWorkspace(name);
+        replaceRuntimeConfig(config4, updated);
+      }
+    }
+  });
   const scheduledScheduler = new ScheduledTaskScheduler(scheduledService, {
     dispatchTask: buildScheduledDispatchTask({
       getSession: (alias) => sessions.getSession(alias),
+      resolveAliasForChat: (chatKey, alias) => sessions.resolveAliasForChat(chatKey, alias),
       resolveSession: (alias, agent4, workspace3, transportSession) => sessions.resolveSession(alias, agent4, workspace3, transportSession),
       sendScheduledMessage: async (input) => {
         if (!deps.channel?.sendScheduledMessage) {
@@ -32903,6 +34282,7 @@ async function buildApp(paths, deps = {}) {
       ...transport.removeSession ? { removeSession: (session3) => transport.removeSession(session3) } : {},
       logger: logger2
     }),
+    onSettled: (task) => controlEvents.emit({ type: "scheduled-changed", chatKey: task.chat_key }),
     logger: logger2
   });
   const reapWarmQueueOwners = async (phase) => {
@@ -32952,6 +34332,7 @@ async function buildApp(paths, deps = {}) {
       service: scheduledService,
       scheduler: scheduledScheduler
     },
+    control,
     reapStaleQueueOwners: () => reapWarmQueueOwners("startup"),
     dispose: async () => {
       scheduledScheduler.stop();
@@ -33015,8 +34396,8 @@ async function main() {
   }
 }
 async function prepareChannelMedia(configPath, config4) {
-  const runtimeDir = join18(dirname12(configPath), "runtime");
-  const mediaRootDir = join18(runtimeDir, "media");
+  const runtimeDir = join21(dirname12(configPath), "runtime");
+  const mediaRootDir = join21(runtimeDir, "media");
   const mediaStore = new RuntimeMediaStore({ rootDir: mediaRootDir });
   await mediaStore.cleanupExpired().catch((error2) => {
     console.error("[xacpx] media cleanup failed:", error2 instanceof Error ? error2.message : String(error2));
@@ -33025,16 +34406,16 @@ async function prepareChannelMedia(configPath, config4) {
   return { mediaStore, channelDeps: { mediaStore, allowedMediaRoots } };
 }
 function resolveRuntimePaths() {
-  const home = process.env.HOME ?? homedir9();
+  const home = process.env.HOME ?? homedir11();
   if (!home) {
     throw new Error("Unable to resolve the current user home directory");
   }
-  const configPath = coreEnv("CONFIG") ?? join18(coreHomeDir(home), "config.json");
-  const runtimeDir = join18(dirname12(configPath), "runtime");
+  const configPath = coreEnv("CONFIG") ?? join21(coreHomeDir(home), "config.json");
+  const runtimeDir = join21(dirname12(configPath), "runtime");
   return {
     configPath,
-    statePath: coreEnv("STATE") ?? join18(coreHomeDir(home), "state.json"),
-    perfLogPath: join18(runtimeDir, "perf.log"),
+    statePath: coreEnv("STATE") ?? join21(coreHomeDir(home), "state.json"),
+    perfLogPath: join21(runtimeDir, "perf.log"),
     orchestrationSocketPath: coreEnv("ORCHESTRATION_SOCKET") ?? resolveDaemonOrchestrationSocketPath(runtimeDir)
   };
 }
@@ -33046,13 +34427,13 @@ function resolveBridgeEntryPath() {
 }
 function resolveAppLogPath(configPath) {
   const rootDir = dirname12(configPath);
-  const runtimeDir = join18(rootDir, "runtime");
-  return join18(runtimeDir, "app.log");
+  const runtimeDir = join21(rootDir, "runtime");
+  return join21(runtimeDir, "app.log");
 }
 function resolvePerfLogPath(configPath) {
   const rootDir = dirname12(configPath);
-  const runtimeDir = join18(rootDir, "runtime");
-  return join18(runtimeDir, "perf.log");
+  const runtimeDir = join21(rootDir, "runtime");
+  return join21(runtimeDir, "perf.log");
 }
 function resolveOrchestrationSocketPathFromConfigPath(configPath) {
   const runtimeDir = resolveRuntimeDirFromConfigPath(configPath);
@@ -33068,6 +34449,7 @@ var init_main = __esm(async () => {
   init_ensure_config();
   init_load_config();
   init_resolve_acpx_command();
+  init_resolve_agent_command();
   init_console_agent();
   init_app_logger();
   init_daemon_files();
@@ -33095,6 +34477,8 @@ var init_main = __esm(async () => {
   init_inbound();
   init_render_text();
   init_quota_manager();
+  init_control_service();
+  init_agent_catalog();
   init_perf_tracer();
   init_bootstrap();
   init_i18n();
@@ -33148,7 +34532,7 @@ function buildDetails(metadata, version2, verbose) {
 }
 async function defaultRunVersion(command) {
   const spawnSpec = resolveSpawnCommand(command, ["--version"]);
-  return await new Promise((resolve3, reject) => {
+  return await new Promise((resolve4, reject) => {
     const child = spawn11(spawnSpec.command, spawnSpec.args, {
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -33165,7 +34549,7 @@ async function defaultRunVersion(command) {
       if (code === 0) {
         const version2 = stdout2.trim() || stderr.trim();
         if (version2.length > 0) {
-          resolve3(version2);
+          resolve4(version2);
           return;
         }
       }
@@ -33287,12 +34671,12 @@ var init_config_check = __esm(async () => {
 });
 
 // src/doctor/checks/daemon-check.ts
-import { readdir as readdir3, readFile as readFile14, rm as rm10 } from "node:fs/promises";
+import { readdir as readdir4, readFile as readFile15, rm as rm10 } from "node:fs/promises";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
-import { homedir as homedir10 } from "node:os";
-import { join as join19 } from "node:path";
+import { homedir as homedir12 } from "node:os";
+import { join as join22 } from "node:path";
 async function checkDaemon(options = {}) {
-  const home = options.home ?? process.env.HOME ?? homedir10();
+  const home = options.home ?? process.env.HOME ?? homedir12();
   const runtimeDir = options.configPath ? resolveRuntimeDirFromConfigPath(options.configPath) : undefined;
   const paths = (options.resolveDaemonPaths ?? resolveDaemonPaths)({
     home,
@@ -33392,7 +34776,7 @@ async function detectStaleConsumerLockFix(runtimeDir, deps) {
     if (!fileName.endsWith(CONSUMER_LOCK_SUFFIX)) {
       continue;
     }
-    const lockPath = join19(runtimeDir, fileName);
+    const lockPath = join22(runtimeDir, fileName);
     const lock2 = await deps.readConsumerLock(lockPath);
     if (lock2 && !deps.isProcessRunning(lock2.pid)) {
       stalePaths.push(lockPath);
@@ -33426,14 +34810,14 @@ async function detectStaleConsumerLockFix(runtimeDir, deps) {
 }
 async function defaultListConsumerLocks(runtimeDir) {
   try {
-    return await readdir3(runtimeDir);
+    return await readdir4(runtimeDir);
   } catch {
     return [];
   }
 }
 async function defaultReadConsumerLock(path15) {
   try {
-    const raw = await readFile14(path15, "utf8");
+    const raw = await readFile15(path15, "utf8");
     const parsed = JSON.parse(raw);
     return typeof parsed.pid === "number" ? { pid: parsed.pid } : null;
   } catch {
@@ -33456,11 +34840,11 @@ var init_daemon_check = __esm(() => {
 });
 
 // src/doctor/checks/logs-check.ts
-import { stat as stat3, readdir as readdir4 } from "node:fs/promises";
-import { basename as basename3, join as join20 } from "node:path";
-import { homedir as homedir11 } from "node:os";
+import { stat as stat4, readdir as readdir5 } from "node:fs/promises";
+import { basename as basename3, join as join23 } from "node:path";
+import { homedir as homedir13 } from "node:os";
 async function checkLogs(options = {}) {
-  const home = options.home ?? process.env.HOME ?? homedir11();
+  const home = options.home ?? process.env.HOME ?? homedir13();
   const runtimeDir = options.configPath ? resolveRuntimeDirFromConfigPath(options.configPath) : undefined;
   const paths = (options.resolveDaemonPaths ?? resolveDaemonPaths)({
     home,
@@ -33492,7 +34876,7 @@ async function checkLogs(options = {}) {
   const matched = entries.filter((entry) => isTrackedLogName(entry, tracked));
   const files = [];
   for (const name of matched) {
-    const path15 = join20(paths.runtimeDir, name);
+    const path15 = join23(paths.runtimeDir, name);
     try {
       const fileStat = await probe.stat(path15);
       if (fileStat.isDirectory()) {
@@ -33572,8 +34956,8 @@ function formatBytes(bytes) {
 }
 function createLogsFsProbe() {
   return {
-    stat: async (path15) => await stat3(path15),
-    readdir: async (path15) => await readdir4(path15)
+    stat: async (path15) => await stat4(path15),
+    readdir: async (path15) => await readdir5(path15)
   };
 }
 function formatError6(error2) {
@@ -33642,9 +35026,9 @@ var init_orchestration_health = __esm(() => {
 });
 
 // src/doctor/checks/orchestration-socket-check.ts
-import { homedir as homedir12 } from "node:os";
+import { homedir as homedir14 } from "node:os";
 async function checkOrchestrationSocket(options = {}) {
-  const home = options.home ?? process.env.HOME ?? homedir12();
+  const home = options.home ?? process.env.HOME ?? homedir14();
   const runtimeDir = options.configPath ? resolveRuntimeDirFromConfigPath(options.configPath) : undefined;
   const paths = (options.resolveDaemonPaths ?? resolveDaemonPaths)({
     home,
@@ -33817,11 +35201,11 @@ var init_plugin_check = __esm(async () => {
 
 // src/doctor/checks/runtime-check.ts
 import { constants } from "node:fs";
-import { access as access4, stat as stat4 } from "node:fs/promises";
+import { access as access4, stat as stat5 } from "node:fs/promises";
 import { dirname as dirname13 } from "node:path";
-import { homedir as homedir13 } from "node:os";
+import { homedir as homedir15 } from "node:os";
 async function checkRuntime(options = {}) {
-  const home = options.home ?? process.env.HOME ?? homedir13();
+  const home = options.home ?? process.env.HOME ?? homedir15();
   const runtimeDir = options.configPath ? resolveRuntimeDirFromConfigPath(options.configPath) : undefined;
   const paths = (options.resolveDaemonPaths ?? resolveDaemonPaths)({
     home,
@@ -33915,7 +35299,7 @@ function formatMode(mode) {
 }
 function createRuntimeFsProbe() {
   return {
-    stat: async (path15) => await stat4(path15),
+    stat: async (path15) => await stat5(path15),
     access: async (path15, mode) => await access4(path15, mode)
   };
 }
@@ -34247,7 +35631,10 @@ function buildSession(options) {
   return {
     alias: "xacpx-doctor",
     agent: options.agent,
-    ...agentConfig.command ? { agentCommand: agentConfig.command } : {},
+    ...(() => {
+      const agentCommand = resolveRuntimeAgentCommand(agentConfig.driver, agentConfig.command, options.config.transport.preferLocalAgents !== false);
+      return agentCommand ? { agentCommand } : {};
+    })(),
     workspace: options.workspace,
     transportSession: `xacpx-doctor-${timestamp}`,
     replyMode: options.config.channel.replyMode,
@@ -34292,6 +35679,7 @@ var SMOKE_PROMPT = "Reply with exactly: ok";
 var init_smoke_check = __esm(async () => {
   init_load_config();
   init_resolve_acpx_command();
+  init_resolve_agent_command();
   init_acpx_bridge_client();
   init_acpx_bridge_transport();
   init_acpx_cli_transport();
@@ -34450,10 +35838,10 @@ var init_render_doctor = __esm(() => {
 });
 
 // src/doctor/doctor.ts
-import { homedir as homedir14 } from "node:os";
-import { join as join21 } from "node:path";
+import { homedir as homedir16 } from "node:os";
+import { join as join24 } from "node:path";
 async function runDoctor(options = {}, deps = {}) {
-  const home = deps.home ?? process.env.HOME ?? homedir14();
+  const home = deps.home ?? process.env.HOME ?? homedir16();
   const runtimePaths = resolveDoctorRuntimePaths(home, deps.resolveRuntimePaths);
   const sharedLoadConfig = createSharedLoadConfig(runtimePaths, deps.loadConfig ?? loadConfig);
   const runners = [
@@ -34606,8 +35994,8 @@ function resolveDoctorRuntimePaths(home, resolver) {
     return resolveRuntimePaths();
   }
   return {
-    configPath: join21(coreHomeDir(home), "config.json"),
-    statePath: join21(coreHomeDir(home), "state.json")
+    configPath: join24(coreHomeDir(home), "config.json"),
+    statePath: join24(coreHomeDir(home), "state.json")
   };
 }
 function depsUseExplicitRuntimeOverrides() {
@@ -34790,8 +36178,8 @@ var init_doctor2 = __esm(async () => {
 // src/cli.ts
 init_core_home();
 import { randomUUID as randomUUID4 } from "node:crypto";
-import { homedir as homedir15 } from "node:os";
-import { dirname as dirname14, join as join22, sep } from "node:path";
+import { homedir as homedir17 } from "node:os";
+import { dirname as dirname14, join as join25, sep as sep2 } from "node:path";
 import { fileURLToPath as fileURLToPath7 } from "node:url";
 
 // src/runtime/migrate-core-home.ts
@@ -47288,7 +48676,7 @@ init_core_home();
 init_daemon_files();
 init_orchestration_ipc();
 import { homedir as homedir2 } from "node:os";
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 function resolveDefaultOrchestrationEndpoint(env = process.env, platform = process.platform) {
   const orchestrationSocket = coreEnv("ORCHESTRATION_SOCKET", env);
   if (typeof orchestrationSocket === "string" && orchestrationSocket.trim().length > 0) {
@@ -47296,7 +48684,7 @@ function resolveDefaultOrchestrationEndpoint(env = process.env, platform = proce
   }
   const home = requireHome(env);
   const configOverride = coreEnv("CONFIG", env);
-  const configPath = typeof configOverride === "string" && configOverride.trim().length > 0 ? configOverride.trim() : join5(coreHomeDir(home), "config.json");
+  const configPath = typeof configOverride === "string" && configOverride.trim().length > 0 ? configOverride.trim() : join6(coreHomeDir(home), "config.json");
   const runtimeDir = resolveRuntimeDirFromConfigPath(configPath);
   return resolveOrchestrationEndpoint(runtimeDir, platform);
 }
@@ -48833,14 +50221,14 @@ function resolveTemplateChoice(answer, names) {
 init_plugin_home();
 import { spawn as spawn4 } from "node:child_process";
 import { readFile as readFile9 } from "node:fs/promises";
-import { dirname as dirname8, join as join11 } from "node:path";
+import { dirname as dirname8, join as join12 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // src/plugins/package-manager.ts
 init_plugin_home();
 import { spawn as spawn3 } from "node:child_process";
 import { rm as rm4 } from "node:fs/promises";
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 function shellSpawnPlan(args) {
   const shell = process.platform === "win32";
   return { shell, args: shell ? args.map((arg) => `"${arg}"`) : args };
@@ -48888,7 +50276,7 @@ async function installPluginPackage(input) {
   const packageManager = input.packageManager ?? await detectPackageManager();
   await normalizePluginHomeManifest(input.pluginHome);
   if (packageManager === "bun") {
-    await rm4(join7(input.pluginHome, "bun.lock"), { force: true }).catch(() => {});
+    await rm4(join8(input.pluginHome, "bun.lock"), { force: true }).catch(() => {});
   }
   const spec = input.version ? `${input.packageName}@${input.version}` : input.packageName;
   if (packageManager === "bun") {
@@ -49180,7 +50568,7 @@ async function runInherit(command, args) {
 async function readPackageName() {
   try {
     const here = dirname8(fileURLToPath3(import.meta.url));
-    for (const candidate of [join11(here, "..", "package.json"), join11(here, "..", "..", "package.json")]) {
+    for (const candidate of [join12(here, "..", "package.json"), join12(here, "..", "..", "package.json")]) {
       try {
         const parsed = JSON.parse(await readFile9(candidate, "utf8"));
         if (typeof parsed.name === "string" && parsed.name.trim())
@@ -49835,7 +51223,7 @@ async function setChannelAccountEnabled(type, accountId, enabled, rawArgs, deps)
 init_core_home();
 init_plugin_home();
 import { readFile as readFile11 } from "node:fs/promises";
-import { isAbsolute, join as join13, resolve } from "node:path";
+import { isAbsolute, join as join14, resolve } from "node:path";
 init_plugin_loader();
 init_validate_plugin();
 init_plugin_doctor();
@@ -49866,7 +51254,7 @@ function looksLikePath(spec) {
 }
 async function readDependencyEntries2(pluginHome) {
   try {
-    const raw = await readFile11(join13(pluginHome, "package.json"), "utf8");
+    const raw = await readFile11(join14(pluginHome, "package.json"), "utf8");
     const parsed = JSON.parse(raw);
     const out = {};
     for (const [name, value] of Object.entries(parsed.dependencies ?? {})) {
@@ -49892,7 +51280,7 @@ async function resolveLocalPluginName(installSpec, pluginHome, namesBeforeInstal
       return name;
   }
   try {
-    const raw = await readFile11(join13(installSpec, "package.json"), "utf8");
+    const raw = await readFile11(join14(installSpec, "package.json"), "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed.name === "string" && parsed.name.trim())
       return parsed.name.trim();
@@ -51034,7 +52422,7 @@ async function createCliScheduledTaskService() {
   return new ScheduledTaskService(state, stateStore);
 }
 function resolveConfigPathForCurrentEnv() {
-  return coreEnv("CONFIG") ?? join22(coreHomeDir(requireHome2()), "config.json");
+  return coreEnv("CONFIG") ?? join25(coreHomeDir(requireHome2()), "config.json");
 }
 function resolveDaemonPathsForCurrentConfig() {
   const configPath = resolveConfigPathForCurrentEnv();
@@ -51093,7 +52481,7 @@ async function defaultRun(options = {}) {
   const firstRunOnboarding = options.firstRunOnboarding ?? decodeFirstRunOnboarding(coreEnv("FIRST_RUN_ONBOARDING"));
   await runConsole2(runtimePaths, {
     buildApp: (paths) => buildApp2(paths, {
-      defaultLoggingLevel: resolveCliEntryPath2().includes(`${sep}src${sep}`) ? "debug" : "info",
+      defaultLoggingLevel: resolveCliEntryPath2().includes(`${sep2}src${sep2}`) ? "debug" : "info",
       channel: channelRegistry
     }),
     beforeReady: firstRunOnboarding ? async (runtime) => {
@@ -51104,7 +52492,7 @@ async function defaultRun(options = {}) {
     daemonRuntime,
     ...firstLockCreator ? {
       consumerLockFactory: (runtime) => firstLockCreator.create({
-        lockFilePath: `${daemonPaths.runtimeDir}${sep}${firstLockCreator.channel.id}-consumer.lock.json`,
+        lockFilePath: `${daemonPaths.runtimeDir}${sep2}${firstLockCreator.channel.id}-consumer.lock.json`,
         onDiagnostic: async (event, context) => {
           await runtime.logger.info(`${firstLockCreator.channel.id}.consumer_lock.${event}`, `${firstLockCreator.channel.id} consumer lock diagnostic`, context);
         }
@@ -51295,7 +52683,7 @@ async function defaultPromptSecret(message) {
   process.stdout.write(message);
   process.stdin.setRawMode(true);
   process.stdin.resume();
-  return await new Promise((resolve3, reject) => {
+  return await new Promise((resolve4, reject) => {
     const chunks = [];
     let inEscape = false;
     const cleanup = () => {
@@ -51326,7 +52714,7 @@ async function defaultPromptSecret(message) {
         if (char === "\r" || char === `
 `) {
           cleanup();
-          resolve3(chunks.join(""));
+          resolve4(chunks.join(""));
           return;
         }
         if (char === "" || char === "\b") {
@@ -51381,7 +52769,7 @@ function decodeFirstRunOnboarding(raw) {
   return null;
 }
 function requireHome2() {
-  const home = process.env.HOME ?? homedir15();
+  const home = process.env.HOME ?? homedir17();
   if (!home) {
     throw new Error("Unable to resolve the current user home directory");
   }
@@ -51405,7 +52793,7 @@ function safeDaemonLogPaths() {
     const configPath = resolveConfigPathForCurrentEnv();
     const paths = resolveDaemonPathsForCurrentConfig();
     return {
-      appLog: join22(dirname14(configPath), "runtime", "app.log"),
+      appLog: join25(dirname14(configPath), "runtime", "app.log"),
       stderrLog: paths.stderrLog
     };
   } catch {