@ganglion/xacpx 0.10.0 → 0.11.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"
@@ -5301,7 +5392,7 @@ class DaemonController {
     this.deps = deps;
     this.statusStore = new DaemonStatusStore(paths.statusFile);
     this.startupPollIntervalMs = deps.startupPollIntervalMs ?? 50;
-    this.startupTimeoutMs = deps.startupTimeoutMs ?? 5000;
+    this.startupTimeoutMs = deps.startupTimeoutMs ?? 1e4;
     this.onboardingStartupTimeoutMs = deps.onboardingStartupTimeoutMs ?? 300000;
     this.shutdownPollIntervalMs = deps.shutdownPollIntervalMs ?? 50;
     this.shutdownTimeoutMs = deps.shutdownTimeoutMs ?? 5000;
@@ -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,24 +5769,32 @@ 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;
 }
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
 var init_daemon_files = __esm(() => {
   init_core_home();
   init_orchestration_ipc();
@@ -13101,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));
   }
@@ -13224,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 {}
@@ -13249,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);
@@ -13261,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: {
@@ -13290,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");
@@ -13315,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;
@@ -17365,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 {
@@ -17415,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);
@@ -19093,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 {
@@ -19770,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);
 }
@@ -19815,6 +19922,122 @@ var init_plugin_loader = __esm(() => {
   init_plugin_home();
 });
 
+// src/plugins/plugin-doctor.ts
+import { readFile as readFile10 } from "node:fs/promises";
+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(join13(pluginHome, "package.json"), "utf8");
+    const parsed = JSON.parse(raw);
+    const out = {};
+    for (const [name, value] of Object.entries(parsed.dependencies ?? {})) {
+      if (typeof value === "string")
+        out[name] = value;
+    }
+    return out;
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    throw new Error(`failed to read plugin home package.json: ${message}`);
+  }
+}
+async function inspectPlugins(input) {
+  const issues = [];
+  let dependencies;
+  try {
+    dependencies = await readDependencyEntries(input.pluginHome);
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    return [{ level: "error", message }];
+  }
+  const importPlugin = input.importPlugin ?? importPluginFromHome;
+  const allConfigured = input.config.plugins;
+  const filterByName = input.pluginName ? normalizePluginPackageName(input.pluginName) : null;
+  if (filterByName && !allConfigured.some((plugin) => normalizePluginPackageName(plugin.name) === filterByName)) {
+    return [{ level: "error", plugin: filterByName, message: `plugin is not configured; run xacpx plugin add ${filterByName}` }];
+  }
+  const pushIfRelevant = (issue2) => {
+    if (!filterByName || issue2.plugin === filterByName)
+      issues.push(issue2);
+  };
+  const channelProviders = new Map;
+  for (const configPlugin of allConfigured) {
+    if (!(configPlugin.name in dependencies)) {
+      pushIfRelevant({ level: "error", plugin: configPlugin.name, message: `package not installed in plugin home; run xacpx plugin add ${configPlugin.name}`, suggestion: `xacpx plugin add ${configPlugin.name} && xacpx restart` });
+      continue;
+    }
+    let moduleValue;
+    try {
+      moduleValue = await importPlugin(configPlugin.name, input.pluginHome);
+    } catch (error2) {
+      const message = error2 instanceof Error ? error2.message : String(error2);
+      pushIfRelevant({ level: "error", plugin: configPlugin.name, message: `failed to import plugin: ${message}`, suggestion: `xacpx plugin add ${configPlugin.name} && xacpx restart` });
+      continue;
+    }
+    try {
+      const plugin = validateWeacpxPlugin(moduleValue, configPlugin.name, {
+        ...input.currentXacpxVersion !== undefined ? { currentXacpxVersion: input.currentXacpxVersion } : {}
+      });
+      const channels = plugin.channels ?? [];
+      const channelTypes = channels.map((channel) => channel.type);
+      for (const type of channelTypes) {
+        const existing = channelProviders.get(type);
+        if (existing) {
+          pushIfRelevant({ level: "error", plugin: configPlugin.name, message: `channel type ${type} is already provided by ${existing.plugin}` });
+        } else {
+          channelProviders.set(type, { plugin: configPlugin.name, enabled: configPlugin.enabled });
+        }
+      }
+      pushIfRelevant({
+        level: configPlugin.enabled ? "ok" : "warn",
+        plugin: configPlugin.name,
+        message: configPlugin.enabled ? `plugin is installed and valid; channels: ${channelTypes.length > 0 ? channelTypes.join(", ") : "none"}` : `plugin is installed and valid but disabled; run xacpx plugin enable ${configPlugin.name}`,
+        ...configPlugin.enabled ? {} : { suggestion: `xacpx plugin enable ${configPlugin.name}` }
+      });
+    } catch (error2) {
+      const message = error2 instanceof Error ? error2.message : String(error2);
+      pushIfRelevant({ level: "error", plugin: configPlugin.name, message });
+    }
+  }
+  const builtInChannelTypes = new Set(listKnownChannelIds());
+  for (const channel of input.config.channels) {
+    if (channel.enabled === false)
+      continue;
+    if (builtInChannelTypes.has(channel.type))
+      continue;
+    const provider = channelProviders.get(channel.type);
+    if (!provider) {
+      if (!filterByName) {
+        const suggestedPackage = suggestedPluginPackageForChannel(channel.type);
+        issues.push({
+          level: "error",
+          message: `channel ${channel.type} is configured but no enabled plugin provides it; run xacpx plugin add ${suggestedPackage} or another plugin that provides type "${channel.type}"`,
+          suggestion: `xacpx plugin add ${suggestedPackage}`
+        });
+      }
+      continue;
+    }
+    if (!provider.enabled) {
+      pushIfRelevant({
+        level: "error",
+        plugin: provider.plugin,
+        message: `channel ${channel.type} is configured but provider plugin is disabled; run xacpx plugin enable ${provider.plugin}`,
+        suggestion: `xacpx plugin enable ${provider.plugin}`
+      });
+    }
+  }
+  return issues;
+}
+var init_plugin_doctor = __esm(() => {
+  init_channel_scope();
+  init_plugin_loader();
+  init_validate_plugin();
+  init_known_plugins();
+  init_plugin_renames();
+});
+
 // src/channels/bootstrap.ts
 function bootstrapBuiltinChannels() {
   bootstrapBuiltinChannelFactories();
@@ -20141,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)
@@ -20279,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" };
   }
@@ -20286,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] };
@@ -20364,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") {
@@ -20382,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);
@@ -20843,6 +21087,7 @@ var init_command_policy = __esm(() => {
     "session.tail",
     "status",
     "mode.show",
+    "model.show",
     "replymode.show",
     "config.show",
     "permission.status",
@@ -20862,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",
@@ -21648,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 {
@@ -21721,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);
@@ -21729,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 {
@@ -21741,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", {
@@ -21867,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) {
@@ -22052,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) {
   const effectiveReplyMode = resolveEffectiveReplyMode(context.config, chatKey, session3.replyMode);
   if (!session3.replyMode)
     session3.replyMode = effectiveReplyMode;
@@ -22084,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);
     if (claimHumanReply) {
       try {
         await context.orchestration?.claimActiveHumanReply?.(claimHumanReply);
@@ -22104,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) {
   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);
   } 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);
     }
     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) {
   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);
 }
 function toCoordinatorRouteChatMetadata(metadata) {
   if (!metadata) {
@@ -22793,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 };
@@ -22803,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) };
 }
@@ -23173,6 +23481,7 @@ function buildHelpTopics() {
     configHelp(),
     orchestrationHelp(),
     modeHelp(),
+    modelHelp(),
     replyModeHelp(),
     statusHelp(),
     cancelHelp(),
@@ -23603,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,
@@ -23841,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();
@@ -23960,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;
@@ -24075,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,
@@ -24105,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))?$/, "");
 }
@@ -24118,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"),
@@ -24141,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);
     }
   }
@@ -24225,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);
     });
   });
 }
@@ -24372,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) {
     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
@@ -24411,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":
@@ -24435,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":
@@ -24456,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":
@@ -24525,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);
           }
           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);
           }
-          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);
         }
       }
     });
@@ -24586,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) => this.promptTransportSession(session3, text, reply, replyContext, media, abortSignal, onToolEvent, onThought, perfSpanOverride ?? perfSpan, onPlan)
     };
   }
   createSessionRenderRecoveryOps() {
@@ -24769,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) {
     session3.mcpCoordinatorSession ??= stableCoordinatorSession(session3.transportSession);
     let done = false;
     let abortRequested = false;
@@ -24826,7 +25235,8 @@ class CommandRouter {
         ...media ? { media } : {},
         ...reply ? { onSegment } : {},
         ...onToolEvent ? { onToolEvent } : {},
-        ...onThought ? { onThought } : {}
+        ...onThought ? { onThought } : {},
+        ...onPlan ? { onPlan } : {}
       }));
     } catch (error2) {
       localOutcome = isAbortError2(error2) || abortRequested ? "aborted" : "error";
@@ -24845,6 +25255,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));
   }
@@ -24904,6 +25328,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();
@@ -24997,7 +25422,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);
   }
   isKnownCommand(text) {
     return isKnownXacpxCommandText(text);
@@ -28811,12 +29236,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));
@@ -28861,6 +29288,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,
@@ -28871,6 +29299,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,
@@ -28882,6 +29311,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;
@@ -28917,7 +29358,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`);
   }
@@ -28926,6 +29368,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,
@@ -28946,6 +29389,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,
@@ -29135,6 +29579,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()
     });
@@ -29505,10 +29950,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,
@@ -29518,9 +29966,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];
@@ -29565,6 +30050,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
@@ -29593,6 +30079,7 @@ class SessionService {
   }
 }
 var init_session_service = __esm(() => {
+  init_resolve_agent_command();
   init_i18n();
   init_channel_scope();
 });
@@ -29616,6 +30103,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;
     }
   };
 }
@@ -29724,6 +30218,7 @@ var init_command_hints = __esm(() => {
     config: "/config",
     orchestration: "/delegate",
     mode: "/mode",
+    model: "/model",
     replymode: "/replymode",
     status: "/status",
     cancel: "/cancel",
@@ -29815,8 +30310,9 @@ async function runConsole(paths, deps) {
         throw error2;
       }
     }
-    await runtime.reapStaleQueueOwners();
+    const reapPromise = Promise.resolve(runtime.reapStaleQueueOwners()).catch(() => {});
     if (deps.beforeReady) {
+      await reapPromise;
       await deps.beforeReady(runtime);
     }
     if (deps.daemonRuntime) {
@@ -29830,6 +30326,7 @@ async function runConsole(paths, deps) {
         deps.daemonRuntime?.heartbeat().catch(() => {});
       }, deps.heartbeatIntervalMs ?? 30000);
     }
+    await reapPromise;
     const channelStartPromise = deps.channels.startAll({
       agent: runtime.agent,
       abortSignal: shutdownController.signal,
@@ -29840,7 +30337,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;
@@ -29976,6 +30474,10 @@ function encodeBridgePromptThoughtEvent(event) {
   return `${JSON.stringify(event)}
 `;
 }
+function encodeBridgePromptPlanEvent(event) {
+  return `${JSON.stringify(event)}
+`;
+}
 function encodeBridgeSessionProgressEvent(event) {
   return `${JSON.stringify(event)}
 `;
@@ -29985,8 +30487,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";
 
@@ -30053,6 +30775,11 @@ 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 === "session.progress") {
         pending.onEvent?.({
           type: "session.progress",
@@ -30102,6 +30829,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",
@@ -30128,7 +30856,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,
@@ -30180,6 +30908,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
@@ -30382,6 +31111,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;
@@ -30439,7 +31226,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;
@@ -30449,6 +31237,8 @@ class AcpxBridgeTransport {
     let toolEventChain = Promise.resolve();
     let thoughtError;
     let thoughtChain = Promise.resolve();
+    let planError;
+    let planChain = Promise.resolve();
     let toolEventMode = resolveToolEventMode(options);
     if ((toolEventMode === "structured" || toolEventMode === "both") && !options?.onToolEvent) {
       toolEventMode = "text";
@@ -30491,10 +31281,21 @@ 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;
+      }
     });
     await segmentChain;
     await toolEventChain;
     await thoughtChain;
+    await planChain;
     if (sink) {
       const { overflowCount } = sink.finalize();
       await sink.drain({ timeoutMs: 30000 });
@@ -30512,6 +31313,9 @@ class AcpxBridgeTransport {
       if (thoughtError) {
         throw thoughtError;
       }
+      if (planError) {
+        throw planError;
+      }
       return { text: summary ? `${summary}
 
 ${result.text}` : "" };
@@ -30525,6 +31329,9 @@ ${result.text}` : "" };
     if (thoughtError) {
       throw thoughtError;
     }
+    if (planError) {
+      throw planError;
+    }
     return result;
   }
   async setMode(session3, modeId) {
@@ -30533,6 +31340,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));
   }
@@ -30561,7 +31377,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() } : {}
     };
   }
 }
@@ -30569,21 +31386,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";
@@ -30734,6 +31536,8 @@ function createStreamingPromptState(formatToolCalls = false, options) {
   let toolEventMode;
   let onToolEvent;
   let onThought;
+  let onPlan;
+  let rawStream = false;
   if (options === undefined) {
     toolEventMode = "text";
     onToolEvent = undefined;
@@ -30743,6 +31547,8 @@ function createStreamingPromptState(formatToolCalls = false, options) {
   } else {
     onToolEvent = options.onToolEvent;
     onThought = options.onThought;
+    onPlan = options.onPlan;
+    rawStream = options.rawStream ?? false;
     toolEventMode = resolveToolEventMode({
       toolEventMode: options.mode,
       onToolEvent
@@ -30756,13 +31562,15 @@ function createStreamingPromptState(formatToolCalls = false, options) {
     formatToolCalls,
     emittedToolCallIds: new Set,
     toolEventMode,
+    rawStream,
     onToolEvent,
     onThought,
+    onPlan,
     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;
@@ -30794,9 +31602,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)
@@ -30816,6 +31624,12 @@ 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;
+  }
   const isThoughtChunk = update.sessionUpdate === "agent_thought_chunk" && update.content?.type === "text" && typeof update.content.text === "string";
   if (isThoughtChunk) {
     const chunk2 = update.content.text;
@@ -30832,6 +31646,8 @@ function parseStreamingChunks(state, line) {
   if (chunk.length === 0)
     return;
   state.buffer += chunk;
+  if (state.rawStream)
+    return;
   let boundary;
   while ((boundary = state.buffer.indexOf(`
 
@@ -31009,12 +31825,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) {
@@ -31031,210 +31847,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) {
@@ -31452,13 +32064,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 };
@@ -31484,6 +32098,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",
@@ -31547,7 +32189,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) {
@@ -31615,13 +32258,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);
@@ -31635,10 +32278,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) => {
@@ -31652,9 +32299,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;
@@ -31668,7 +32322,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);
@@ -31705,7 +32359,8 @@ ${baseText}` : "" };
           sink?.drain({ timeoutMs: 30000 }) ?? Promise.resolve(),
           segmentChain,
           toolEventChain,
-          thoughtChain
+          thoughtChain,
+          planChain
         ]).then(() => {
           const deferred = sink?.getPendingError();
           if (deferred) {
@@ -31724,6 +32379,10 @@ ${baseText}` : "" };
             reject(thoughtError);
             return;
           }
+          if (planError) {
+            reject(planError);
+            return;
+          }
           resolve3({
             result: { code: code ?? 1, stdout: stdout2, stderr },
             overflowCount
@@ -31740,7 +32399,8 @@ ${baseText}` : "" };
       "quiet",
       "--cwd",
       session3.cwd,
-      ...this.buildPermissionArgs()
+      ...this.buildPermissionArgs(),
+      ...this.buildModelArgs(session3)
     ];
     if (session3.agentCommand) {
       return [...prefix, "--agent", session3.agentCommand, ...tail2];
@@ -31762,6 +32422,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];
@@ -31770,6 +32431,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 [];
@@ -31966,7 +32631,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 } : {},
@@ -31976,7 +32641,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 = {};
@@ -32263,6 +32930,730 @@ 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 };
+  }
+}
+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
+          });
+        }
+      });
+      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, {
@@ -32273,8 +33664,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;
@@ -32550,7 +33941,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
@@ -32764,9 +34155,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) {
@@ -32777,6 +34211,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) => {
@@ -32826,6 +34261,7 @@ async function buildApp(paths, deps = {}) {
       service: scheduledService,
       scheduler: scheduledScheduler
     },
+    control,
     reapStaleQueueOwners: () => reapWarmQueueOwners("startup"),
     dispose: async () => {
       scheduledScheduler.stop();
@@ -32889,8 +34325,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));
@@ -32899,16 +34335,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)
   };
 }
@@ -32920,13 +34356,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);
@@ -32942,6 +34378,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();
@@ -32969,6 +34406,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();
@@ -33022,7 +34461,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"]
     });
@@ -33039,7 +34478,7 @@ async function defaultRunVersion(command) {
       if (code === 0) {
         const version2 = stdout2.trim() || stderr.trim();
         if (version2.length > 0) {
-          resolve3(version2);
+          resolve4(version2);
           return;
         }
       }
@@ -33161,24 +34600,36 @@ var init_config_check = __esm(async () => {
 });
 
 // src/doctor/checks/daemon-check.ts
+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 { 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,
     ...runtimeDir ? { runtimeDir } : {}
   });
+  const isProcessRunning = options.isProcessRunning ?? isProcessAlive;
+  const listConsumerLocks = options.listConsumerLocks ?? defaultListConsumerLocks;
+  const readConsumerLock = options.readConsumerLock ?? defaultReadConsumerLock;
+  const removeConsumerLock = options.removeConsumerLock ?? defaultRemoveConsumerLock;
   const controller = createDaemonController(paths, {
     processExecPath: options.processExecPath ?? process.execPath,
     cliEntryPath: options.cliEntryPath ?? resolveCliEntryPath(),
     cwd: options.cwd ?? process.cwd(),
     env: options.env ?? process.env,
-    isProcessRunning: options.isProcessRunning ?? defaultIsProcessRunning5
+    isProcessRunning
   });
   try {
     const status = await controller.getStatus();
+    const staleLockFix = status.state === "stopped" ? await detectStaleConsumerLockFix(paths.runtimeDir, {
+      isProcessRunning,
+      listConsumerLocks,
+      readConsumerLock,
+      removeConsumerLock
+    }) : undefined;
     switch (status.state) {
       case "running":
         return {
@@ -33200,6 +34651,7 @@ async function checkDaemon(options = {}) {
           summary: status.stale ? "daemon was stopped and stale runtime files were cleared" : "daemon is not running",
           details: status.stale ? ["stale runtime files were cleared"] : undefined,
           suggestions: ["run: xacpx start"],
+          ...staleLockFix ? { fixes: [staleLockFix] } : {},
           metadata: {
             paths,
             status
@@ -33246,25 +34698,210 @@ async function checkDaemon(options = {}) {
     };
   }
 }
-function defaultIsProcessRunning5(pid) {
+async function detectStaleConsumerLockFix(runtimeDir, deps) {
+  const lockFiles = await deps.listConsumerLocks(runtimeDir);
+  const stalePaths = [];
+  for (const fileName of lockFiles) {
+    if (!fileName.endsWith(CONSUMER_LOCK_SUFFIX)) {
+      continue;
+    }
+    const lockPath = join22(runtimeDir, fileName);
+    const lock2 = await deps.readConsumerLock(lockPath);
+    if (lock2 && !deps.isProcessRunning(lock2.pid)) {
+      stalePaths.push(lockPath);
+    }
+  }
+  if (stalePaths.length === 0) {
+    return;
+  }
+  return {
+    id: "daemon.clear-stale-lock",
+    title: "remove stale consumer lock(s)",
+    run: async () => {
+      const removed = [];
+      let skipped = 0;
+      for (const lockPath of stalePaths) {
+        const lock2 = await deps.readConsumerLock(lockPath);
+        if (!lock2 || deps.isProcessRunning(lock2.pid)) {
+          skipped += 1;
+          continue;
+        }
+        await deps.removeConsumerLock(lockPath);
+        removed.push(lockPath);
+      }
+      const skippedNote = skipped > 0 ? `; left ${skipped} no-longer-stale lock(s) alone` : "";
+      return {
+        ok: true,
+        message: removed.length > 0 ? `removed ${removed.length} stale consumer lock(s): ${removed.join(", ")}${skippedNote}` : `no locks removed${skippedNote}`
+      };
+    }
+  };
+}
+async function defaultListConsumerLocks(runtimeDir) {
   try {
-    process.kill(pid, 0);
-    return true;
+    return await readdir4(runtimeDir);
   } catch {
-    return false;
+    return [];
   }
 }
+async function defaultReadConsumerLock(path15) {
+  try {
+    const raw = await readFile15(path15, "utf8");
+    const parsed = JSON.parse(raw);
+    return typeof parsed.pid === "number" ? { pid: parsed.pid } : null;
+  } catch {
+    return null;
+  }
+}
+async function defaultRemoveConsumerLock(path15) {
+  await rm10(path15, { force: true });
+}
 function resolveCliEntryPath() {
   return process.argv[1] ?? fileURLToPath6(import.meta.url);
 }
 function formatError5(error2) {
   return error2 instanceof Error ? error2.message : String(error2);
 }
+var CONSUMER_LOCK_SUFFIX = "-consumer.lock.json";
 var init_daemon_check = __esm(() => {
   init_create_daemon_controller();
   init_daemon_files();
 });
 
+// src/doctor/checks/logs-check.ts
+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 ?? homedir13();
+  const runtimeDir = options.configPath ? resolveRuntimeDirFromConfigPath(options.configPath) : undefined;
+  const paths = (options.resolveDaemonPaths ?? resolveDaemonPaths)({
+    home,
+    ...runtimeDir ? { runtimeDir } : {}
+  });
+  const probe = options.probe ?? createLogsFsProbe();
+  const singleFileWarnBytes = options.singleFileWarnBytes ?? DEFAULT_SINGLE_FILE_WARN_BYTES;
+  const totalWarnBytes = options.totalWarnBytes ?? DEFAULT_TOTAL_WARN_BYTES;
+  let entries;
+  try {
+    const dirStat = await probe.stat(paths.runtimeDir);
+    if (!dirStat.isDirectory()) {
+      return skip("runtime log directory could not be read", [
+        `runtimeDir: ${paths.runtimeDir} (exists but is not a directory)`
+      ]);
+    }
+    entries = await probe.readdir(paths.runtimeDir);
+  } catch (error2) {
+    if (isMissingPathError(error2)) {
+      return skip("no runtime logs yet", [`runtimeDir: ${paths.runtimeDir} (missing)`]);
+    }
+    return skip("runtime log directory could not be read", [
+      `runtimeDir: ${paths.runtimeDir}`,
+      `error: ${formatError6(error2)}`
+    ]);
+  }
+  const baseNames = [basename3(paths.appLog), basename3(paths.stdoutLog), basename3(paths.stderrLog)];
+  const tracked = new Set(baseNames);
+  const matched = entries.filter((entry) => isTrackedLogName(entry, tracked));
+  const files = [];
+  for (const name of matched) {
+    const path15 = join23(paths.runtimeDir, name);
+    try {
+      const fileStat = await probe.stat(path15);
+      if (fileStat.isDirectory()) {
+        continue;
+      }
+      files.push({ name, path: path15, size: fileStat.size });
+    } catch {
+      continue;
+    }
+  }
+  const total = files.reduce((sum, file) => sum + file.size, 0);
+  const largestSingle = files.reduce((max, file) => Math.max(max, file.size), 0);
+  const overSingle = files.some((file) => file.size > singleFileWarnBytes);
+  const overTotal = total > totalWarnBytes;
+  const sorted = [...files].sort((a, b) => b.size - a.size);
+  const details = [
+    ...sorted.map((file) => `${file.name}: ${formatBytes(file.size)}`),
+    `total: ${formatBytes(total)}`
+  ];
+  if (overSingle || overTotal) {
+    const reason = overSingle ? `largest single log is ${formatBytes(largestSingle)}` : `total is ${formatBytes(total)}`;
+    return {
+      id: "logs",
+      label: "Logs",
+      severity: "warn",
+      summary: `log growth high: ${reason} (total ${formatBytes(total)})`,
+      details,
+      suggestions: [
+        "logs are large; check disk space and that log rotation is configured (logging.maxSizeBytes / maxFiles)"
+      ]
+    };
+  }
+  return {
+    id: "logs",
+    label: "Logs",
+    severity: "pass",
+    summary: `logs total ${formatBytes(total)}`,
+    details
+  };
+}
+function skip(summary, details) {
+  return {
+    id: "logs",
+    label: "Logs",
+    severity: "skip",
+    summary,
+    details
+  };
+}
+function isTrackedLogName(name, baseNames) {
+  if (baseNames.has(name)) {
+    return true;
+  }
+  for (const base of baseNames) {
+    const prefix = `${base}.`;
+    if (name.startsWith(prefix)) {
+      const suffix = name.slice(prefix.length);
+      if (/^\d+$/.test(suffix) && Number(suffix) > 0) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) {
+    return `${bytes} B`;
+  }
+  const units = ["KB", "MB", "GB", "TB"];
+  let value = bytes / 1024;
+  let unitIndex = 0;
+  while (value >= 1024 && unitIndex < units.length - 1) {
+    value /= 1024;
+    unitIndex += 1;
+  }
+  return `${value.toFixed(1)} ${units[unitIndex]}`;
+}
+function createLogsFsProbe() {
+  return {
+    stat: async (path15) => await stat4(path15),
+    readdir: async (path15) => await readdir5(path15)
+  };
+}
+function formatError6(error2) {
+  return error2 instanceof Error ? error2.message : String(error2);
+}
+function isMissingPathError(error2) {
+  return typeof error2 === "object" && error2 !== null && "code" in error2 && (error2.code === "ENOENT" || error2.code === "ENOTDIR");
+}
+var DEFAULT_SINGLE_FILE_WARN_BYTES, DEFAULT_TOTAL_WARN_BYTES;
+var init_logs_check = __esm(() => {
+  init_daemon_files();
+  DEFAULT_SINGLE_FILE_WARN_BYTES = 50 * 1024 * 1024;
+  DEFAULT_TOTAL_WARN_BYTES = 200 * 1024 * 1024;
+});
+
 // src/doctor/checks/orchestration-health.ts
 async function checkOrchestrationHealth(options) {
   const state = await options.loadState();
@@ -33317,13 +34954,187 @@ var init_orchestration_health = __esm(() => {
   init_i18n();
 });
 
+// src/doctor/checks/orchestration-socket-check.ts
+import { homedir as homedir14 } from "node:os";
+async function checkOrchestrationSocket(options = {}) {
+  const home = options.home ?? process.env.HOME ?? homedir14();
+  const runtimeDir = options.configPath ? resolveRuntimeDirFromConfigPath(options.configPath) : undefined;
+  const paths = (options.resolveDaemonPaths ?? resolveDaemonPaths)({
+    home,
+    ...runtimeDir ? { runtimeDir } : {}
+  });
+  const getDaemonStatus = options.getDaemonStatus ?? ((p) => defaultGetDaemonStatus(p, options));
+  const probe = options.canConnectToEndpoint ?? canConnectToEndpoint;
+  const resolveEndpoint = options.resolveOrchestrationEndpoint ?? ((dir) => resolveOrchestrationEndpoint(dir));
+  let status;
+  try {
+    status = await getDaemonStatus(paths);
+  } catch (error2) {
+    return {
+      id: "orchestration-socket",
+      label: "Orchestration IPC",
+      severity: "skip",
+      summary: "daemon status could not be read",
+      details: [`runtime dir: ${paths.runtimeDir}`, `error: ${formatError7(error2)}`]
+    };
+  }
+  if (status.state === "stopped") {
+    return {
+      id: "orchestration-socket",
+      label: "Orchestration IPC",
+      severity: "skip",
+      summary: "daemon stopped"
+    };
+  }
+  let endpoint;
+  let reachable;
+  try {
+    endpoint = resolveEndpoint(paths.runtimeDir);
+    reachable = await probe(endpoint.path);
+  } catch (error2) {
+    return {
+      id: "orchestration-socket",
+      label: "Orchestration IPC",
+      severity: "skip",
+      summary: "orchestration IPC liveness could not be probed",
+      details: [`runtime dir: ${paths.runtimeDir}`, `error: ${formatError7(error2)}`]
+    };
+  }
+  if (reachable) {
+    return {
+      id: "orchestration-socket",
+      label: "Orchestration IPC",
+      severity: "pass",
+      summary: "orchestration IPC is accepting connections",
+      details: [`endpoint: ${endpoint.path}`]
+    };
+  }
+  return {
+    id: "orchestration-socket",
+    label: "Orchestration IPC",
+    severity: "fail",
+    summary: "daemon is running but orchestration IPC is not accepting connections",
+    details: [`endpoint: ${endpoint.path}`],
+    suggestions: ["run: xacpx restart"]
+  };
+}
+async function defaultGetDaemonStatus(paths, options) {
+  const controller = createDaemonController(paths, {
+    processExecPath: options.processExecPath ?? process.execPath,
+    cliEntryPath: options.cliEntryPath ?? process.argv[1] ?? "",
+    cwd: options.cwd ?? process.cwd(),
+    env: options.env ?? process.env,
+    isProcessRunning: options.isProcessRunning ?? isProcessAlive
+  });
+  return await controller.getStatus();
+}
+function formatError7(error2) {
+  return error2 instanceof Error ? error2.message : String(error2);
+}
+var init_orchestration_socket_check = __esm(() => {
+  init_create_daemon_controller();
+  init_daemon_files();
+  init_endpoint_probe();
+  init_orchestration_ipc();
+});
+
+// src/doctor/checks/plugin-check.ts
+async function checkPlugins(options = {}) {
+  const runtimePaths = (options.resolveRuntimePaths ?? resolveRuntimePaths)();
+  let config4;
+  try {
+    config4 = await (options.loadConfig ?? loadConfig)(runtimePaths.configPath);
+  } catch (error2) {
+    return {
+      id: "plugins",
+      label: "Plugins",
+      severity: "skip",
+      summary: "plugin check skipped because configuration could not be loaded",
+      details: [`config path: ${runtimePaths.configPath}`, `error: ${formatError8(error2)}`],
+      suggestions: ["fix the Config check first, then run: xacpx doctor"]
+    };
+  }
+  if (!hasPluginSurface(config4)) {
+    return {
+      id: "plugins",
+      label: "Plugins",
+      severity: "skip",
+      summary: "no plugins configured"
+    };
+  }
+  const pluginHome = (options.resolvePluginHome ?? resolvePluginHome)({ home: options.home });
+  const inspect = options.inspectPlugins ?? inspectPlugins;
+  let issues;
+  try {
+    issues = await inspect({
+      config: config4,
+      pluginHome,
+      currentXacpxVersion: options.currentXacpxVersion ?? XACPX_CORE_VERSION
+    });
+  } catch (error2) {
+    return {
+      id: "plugins",
+      label: "Plugins",
+      severity: "fail",
+      summary: "plugin health check failed",
+      details: [`plugin home: ${pluginHome}`, `error: ${formatError8(error2)}`]
+    };
+  }
+  const errorCount = issues.filter((issue2) => issue2.level === "error").length;
+  const warnCount = issues.filter((issue2) => issue2.level === "warn").length;
+  const severity = errorCount > 0 ? "fail" : warnCount > 0 ? "warn" : "pass";
+  const problemCount = errorCount + warnCount;
+  return {
+    id: "plugins",
+    label: "Plugins",
+    severity,
+    summary: problemCount > 0 ? `${problemCount} plugin issue(s)` : "all plugins healthy",
+    details: issues.filter((issue2) => issue2.level !== "ok").map(formatIssueDetail),
+    suggestions: collectSuggestions(issues),
+    metadata: { pluginHome, errorCount, warnCount }
+  };
+}
+function hasPluginSurface(config4) {
+  if ((config4.plugins ?? []).length > 0) {
+    return true;
+  }
+  const builtInChannelTypes = new Set(listKnownChannelIds());
+  return (config4.channels ?? []).some((channel) => channel.enabled !== false && !builtInChannelTypes.has(channel.type));
+}
+function formatIssueDetail(issue2) {
+  return issue2.plugin ? `${issue2.plugin}: ${issue2.message}` : issue2.message;
+}
+function collectSuggestions(issues) {
+  const suggestions = [];
+  const seen = new Set;
+  for (const issue2 of issues) {
+    const suggestion = issue2.suggestion;
+    if (suggestion && !seen.has(suggestion)) {
+      seen.add(suggestion);
+      suggestions.push(`run: ${suggestion}`);
+    }
+  }
+  return suggestions;
+}
+function formatError8(error2) {
+  return error2 instanceof Error ? error2.message : String(error2);
+}
+var init_plugin_check = __esm(async () => {
+  init_load_config();
+  init_channel_scope();
+  init_plugin_doctor();
+  init_plugin_home();
+  init_version();
+  await init_main();
+});
+
 // src/doctor/checks/runtime-check.ts
 import { constants } from "node:fs";
-import { access as access4, stat as stat3 } 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 homedir11 } from "node:os";
+import { homedir as homedir15 } from "node:os";
 async function checkRuntime(options = {}) {
-  const home = options.home ?? process.env.HOME ?? homedir11();
+  const home = options.home ?? process.env.HOME ?? homedir15();
   const runtimeDir = options.configPath ? resolveRuntimeDirFromConfigPath(options.configPath) : undefined;
   const paths = (options.resolveDaemonPaths ?? resolveDaemonPaths)({
     home,
@@ -33349,6 +35160,20 @@ async function checkRuntime(options = {}) {
       details: checks3.map((check) => check.detail)
     };
   }
+  const privacy = await inspectRuntimeDirPrivacy(paths.runtimeDir, probe, platform);
+  if (privacy.needsRepair) {
+    return {
+      id: "runtime",
+      label: "Runtime",
+      severity: "warn",
+      summary: "daemon runtime dir should be private (mode 0700)",
+      details: [...checks3.map((check) => check.detail), privacy.detail],
+      fixes: [createEnsurePrivateDirFix(paths.runtimeDir, options.ensurePrivateRuntimeDir)],
+      metadata: {
+        paths
+      }
+    };
+  }
   return {
     id: "runtime",
     label: "Runtime",
@@ -33360,9 +35185,50 @@ async function checkRuntime(options = {}) {
     }
   };
 }
+async function inspectRuntimeDirPrivacy(runtimeDir, probe, platform) {
+  if (platform === "win32") {
+    return { needsRepair: false, detail: "" };
+  }
+  try {
+    const stats = await probe.stat(runtimeDir);
+    if (typeof stats.mode !== "number") {
+      return { needsRepair: false, detail: "" };
+    }
+    const mode = stats.mode & 511;
+    if (mode === PRIVATE_DIR_MODE) {
+      return { needsRepair: false, detail: "" };
+    }
+    return {
+      needsRepair: true,
+      detail: `runtimeDir: ${runtimeDir} (mode ${formatMode(mode)} is not 0700; group/other access should be removed)`
+    };
+  } catch (error2) {
+    if (isMissingPathError2(error2)) {
+      return {
+        needsRepair: true,
+        detail: `runtimeDir: ${runtimeDir} (missing; will be created with mode 0700)`
+      };
+    }
+    return { needsRepair: false, detail: "" };
+  }
+}
+function createEnsurePrivateDirFix(runtimeDir, ensureImpl) {
+  const ensure = ensureImpl ?? ((dir) => ensurePrivateRuntimeDir(dir));
+  return {
+    id: "runtime.ensure-private-dir",
+    title: "create/repair runtime dir with mode 0700",
+    run: async () => {
+      await ensure(runtimeDir);
+      return { ok: true, message: `runtime dir ${runtimeDir} created/repaired with mode 0700` };
+    }
+  };
+}
+function formatMode(mode) {
+  return `0${(mode & 511).toString(8)}`;
+}
 function createRuntimeFsProbe() {
   return {
-    stat: async (path15) => await stat3(path15),
+    stat: async (path15) => await stat5(path15),
     access: async (path15, mode) => await access4(path15, mode)
   };
 }
@@ -33381,10 +35247,10 @@ async function checkDirectoryCreatable(label, path15, probe, platform) {
       detail: `${label}: ${path15} (writable)`
     };
   } catch (error2) {
-    if (!isMissingPathError(error2)) {
+    if (!isMissingPathError2(error2)) {
       return {
         ok: false,
-        detail: `${label}: ${path15} (unusable: ${formatError6(error2)})`
+        detail: `${label}: ${path15} (unusable: ${formatError9(error2)})`
       };
     }
     const parentCheck = await checkCreatableAncestorDirectory(path15, probe, platform);
@@ -33415,10 +35281,10 @@ async function checkFileCreatable(label, path15, probe, platform) {
       detail: `${label}: ${path15} (writable)`
     };
   } catch (error2) {
-    if (!isMissingPathError(error2)) {
+    if (!isMissingPathError2(error2)) {
       return {
         ok: false,
-        detail: `${label}: ${path15} (unusable: ${formatError6(error2)})`
+        detail: `${label}: ${path15} (unusable: ${formatError9(error2)})`
       };
     }
     const parentCheck = await checkCreatableAncestorDirectory(dirname13(path15), probe, platform);
@@ -33450,7 +35316,7 @@ async function checkCreatableAncestorDirectory(path15, probe, platform) {
       creatableFrom: path15
     };
   } catch (error2) {
-    if (!isMissingPathError(error2)) {
+    if (!isMissingPathError2(error2)) {
       return {
         ok: false,
         creatableFrom: path15,
@@ -33478,21 +35344,22 @@ async function checkCreatableAncestorDirectory(path15, probe, platform) {
 function directoryAccessMode(platform) {
   return platform === "win32" ? constants.W_OK : DIRECTORY_USABLE;
 }
-function isMissingPathError(error2) {
+function isMissingPathError2(error2) {
   return isErrnoError(error2) && (error2.code === "ENOENT" || error2.code === "ENOTDIR");
 }
 function isErrnoError(error2) {
   return typeof error2 === "object" && error2 !== null && "code" in error2;
 }
-function formatError6(error2) {
+function formatError9(error2) {
   if (error2 instanceof Error) {
     return error2.message;
   }
   return String(error2);
 }
-var DIRECTORY_USABLE;
+var DIRECTORY_USABLE, PRIVATE_DIR_MODE = 448;
 var init_runtime_check = __esm(() => {
   init_daemon_files();
+  init_private_runtime_dir();
   DIRECTORY_USABLE = constants.W_OK | constants.X_OK;
 });
 
@@ -33604,7 +35471,7 @@ async function checkSmoke(options = {}, deps = {}) {
       label: "Smoke",
       severity: "fail",
       summary: "smoke transport probe failed",
-      details: [`config path: ${runtimePaths.configPath}`, `error: ${formatError7(error2)}`]
+      details: [`config path: ${runtimePaths.configPath}`, `error: ${formatError10(error2)}`]
     };
   }
 }
@@ -33693,7 +35560,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,
@@ -33731,13 +35601,14 @@ function buildDetails3(options) {
   }
   return details;
 }
-function formatError7(error2) {
+function formatError10(error2) {
   return error2 instanceof Error ? error2.message : String(error2);
 }
 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();
@@ -33756,7 +35627,7 @@ async function checkWechat(options = {}) {
     } catch (error2) {
       return {
         accountId,
-        error: formatError8(error2)
+        error: formatError11(error2)
       };
     }
   });
@@ -33797,7 +35668,7 @@ function buildVerboseDetails(loggedIn, verbose, accounts) {
   }
   return details;
 }
-function formatError8(error2) {
+function formatError11(error2) {
   return error2 instanceof Error ? error2.message : String(error2);
 }
 var init_wechat_check = __esm(() => {
@@ -33806,43 +35677,60 @@ var init_wechat_check = __esm(() => {
 
 // src/doctor/render-doctor.ts
 function renderDoctor(report, options = {}) {
-  return options.verbose ? renderVerboseDoctor(report) : renderDefaultDoctor(report);
+  const fixMode = options.fix === true;
+  return options.verbose ? renderVerboseDoctor(report, fixMode) : renderDefaultDoctor(report, fixMode);
 }
-function renderDefaultDoctor(report) {
+function renderDefaultDoctor(report, fixMode) {
   const lines = [];
   for (const check of report.checks) {
-    lines.push(renderCheckLine(check));
+    lines.push(renderCheckLine(check, fixMode));
   }
+  appendRepairs(lines, report, fixMode);
   lines.push(renderSummaryLine(report.checks));
-  const suggestions = collectSuggestions(report.checks);
-  if (suggestions.length > 0) {
-    lines.push("Next steps:");
-    for (const suggestion of suggestions) {
-      lines.push(`- ${suggestion}`);
-    }
-  }
+  appendNextSteps(lines, report.checks);
   return lines;
 }
-function renderVerboseDoctor(report) {
+function renderVerboseDoctor(report, fixMode) {
   const lines = [];
   for (const check of report.checks) {
-    lines.push(renderCheckLine(check));
+    lines.push(renderCheckLine(check, fixMode));
     for (const detail of check.details ?? []) {
       lines.push(`  detail: ${detail}`);
     }
   }
+  appendRepairs(lines, report, fixMode);
   lines.push(renderSummaryLine(report.checks));
-  const suggestions = collectSuggestions(report.checks);
+  appendNextSteps(lines, report.checks);
+  return lines;
+}
+function appendNextSteps(lines, checks3) {
+  const suggestions = collectSuggestions2(checks3);
   if (suggestions.length > 0) {
     lines.push("Next steps:");
     for (const suggestion of suggestions) {
       lines.push(`- ${suggestion}`);
     }
   }
-  return lines;
 }
-function renderCheckLine(check) {
-  return `${SEVERITY_LABELS[check.severity]} ${check.label}: ${check.summary}`;
+function appendRepairs(lines, report, fixMode) {
+  if (!fixMode) {
+    return;
+  }
+  const repairs = report.repairs ?? [];
+  if (repairs.length === 0) {
+    return;
+  }
+  lines.push("Repairs:");
+  for (const repair of repairs) {
+    lines.push(`- ${repair.title}: ${repair.status} (${repair.message})`);
+  }
+}
+function renderCheckLine(check, fixMode) {
+  const base = `${SEVERITY_LABELS[check.severity]} ${check.label}: ${check.summary}`;
+  if (!fixMode && (check.fixes?.length ?? 0) > 0) {
+    return `${base} (fixable — run: xacpx doctor --fix)`;
+  }
+  return base;
 }
 function renderSummaryLine(checks3) {
   const counts = summarizeChecks(checks3);
@@ -33854,7 +35742,7 @@ function summarizeChecks(checks3) {
     return counts;
   }, { pass: 0, warn: 0, fail: 0, skip: 0 });
 }
-function collectSuggestions(checks3) {
+function collectSuggestions2(checks3) {
   const seen = new Set;
   const suggestions = [];
   for (const check of checks3) {
@@ -33879,47 +35767,112 @@ var init_render_doctor = __esm(() => {
 });
 
 // src/doctor/doctor.ts
-import { homedir as homedir12 } from "node:os";
-import { join as join19 } 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 ?? homedir12();
+  const home = deps.home ?? process.env.HOME ?? homedir16();
   const runtimePaths = resolveDoctorRuntimePaths(home, deps.resolveRuntimePaths);
   const sharedLoadConfig = createSharedLoadConfig(runtimePaths, deps.loadConfig ?? loadConfig);
+  const runners = [
+    {
+      id: "config",
+      run: () => (deps.checkConfig ?? checkConfig)({
+        loadConfig: sharedLoadConfig,
+        resolveRuntimePaths: () => runtimePaths
+      })
+    },
+    {
+      id: "runtime",
+      run: () => (deps.checkRuntime ?? checkRuntime)({
+        home,
+        configPath: runtimePaths.configPath
+      })
+    },
+    {
+      id: "logs",
+      run: () => (deps.checkLogs ?? checkLogs)({
+        home,
+        configPath: runtimePaths.configPath
+      })
+    },
+    {
+      id: "daemon",
+      run: () => (deps.checkDaemon ?? checkDaemon)({
+        home,
+        configPath: runtimePaths.configPath
+      })
+    },
+    {
+      id: "wechat",
+      run: () => (deps.checkWechat ?? checkWechat)({
+        verbose: options.verbose
+      })
+    },
+    {
+      id: "acpx",
+      run: () => (deps.checkAcpx ?? checkAcpx)({
+        verbose: options.verbose,
+        loadConfig: sharedLoadConfig,
+        resolveRuntimePaths: () => runtimePaths
+      })
+    },
+    {
+      id: "bridge",
+      run: () => (deps.checkBridge ?? checkBridge)({
+        verbose: options.verbose,
+        loadConfig: sharedLoadConfig,
+        resolveRuntimePaths: () => runtimePaths
+      })
+    },
+    {
+      id: "plugins",
+      run: () => (deps.checkPlugins ?? checkPlugins)({
+        home,
+        loadConfig: sharedLoadConfig,
+        resolveRuntimePaths: () => runtimePaths
+      })
+    },
+    {
+      id: "orchestration",
+      run: () => (deps.checkOrchestrationHealth ?? (() => defaultCheckOrchestrationHealth({
+        runtimePaths,
+        loadConfig: sharedLoadConfig,
+        isDaemonRunning: deps.isDaemonRunning ?? (() => defaultIsDaemonRunning(home, runtimePaths, deps.getDaemonStatus))
+      })))()
+    },
+    {
+      id: "orchestration-socket",
+      run: () => (deps.checkOrchestrationSocket ?? checkOrchestrationSocket)({
+        home,
+        configPath: runtimePaths.configPath
+      })
+    },
+    {
+      id: "smoke",
+      run: () => options.smoke === true ? (deps.checkSmoke ?? ((runOptions) => defaultCheckSmoke(runOptions, {
+        resolveRuntimePaths: () => runtimePaths,
+        loadConfig: sharedLoadConfig
+      })))(options) : Promise.resolve(createSmokeSkipResult("smoke probe not requested"))
+    }
+  ];
+  const runnersById = new Map(runners.map((runner) => [runner.id, runner.run]));
   const checks3 = [];
-  checks3.push(await (deps.checkConfig ?? checkConfig)({
-    loadConfig: sharedLoadConfig,
-    resolveRuntimePaths: () => runtimePaths
-  }));
-  checks3.push(await (deps.checkRuntime ?? checkRuntime)({
-    home,
-    configPath: runtimePaths.configPath
-  }));
-  checks3.push(await (deps.checkDaemon ?? checkDaemon)({
-    home,
-    configPath: runtimePaths.configPath
-  }));
-  checks3.push(await (deps.checkWechat ?? checkWechat)({
-    verbose: options.verbose
-  }));
-  checks3.push(await (deps.checkAcpx ?? checkAcpx)({
-    verbose: options.verbose,
-    loadConfig: sharedLoadConfig,
-    resolveRuntimePaths: () => runtimePaths
-  }));
-  checks3.push(await (deps.checkBridge ?? checkBridge)({
-    verbose: options.verbose,
-    loadConfig: sharedLoadConfig,
-    resolveRuntimePaths: () => runtimePaths
-  }));
-  checks3.push(await (deps.checkOrchestrationHealth ?? (() => defaultCheckOrchestrationHealth({
-    runtimePaths,
-    loadConfig: sharedLoadConfig
-  })))());
-  checks3.push(options.smoke === true ? await (deps.checkSmoke ?? ((runOptions) => defaultCheckSmoke(runOptions, {
-    resolveRuntimePaths: () => runtimePaths,
-    loadConfig: sharedLoadConfig
-  })))(options) : createSmokeSkipResult("smoke probe not requested"));
+  for (const runner of runners) {
+    checks3.push(await runner.run());
+  }
   const report = { checks: checks3 };
+  if (options.fix === true) {
+    const { repairs, repairedCheckIds } = await applyRepairs(checks3);
+    report.repairs = repairs;
+    for (const checkId of repairedCheckIds) {
+      const index = checks3.findIndex((check) => check.id === checkId);
+      const rerun = runnersById.get(checkId);
+      if (index === -1 || !rerun) {
+        continue;
+      }
+      checks3[index] = await rerun();
+    }
+  }
   const output = (deps.renderDoctor ?? renderDoctor)(report, options);
   return {
     report,
@@ -33927,6 +35880,41 @@ async function runDoctor(options = {}, deps = {}) {
     exitCode: checks3.some((check) => check.severity === "fail") ? 1 : 0
   };
 }
+async function applyRepairs(checks3) {
+  const repairs = [];
+  const repairedCheckIds = [];
+  for (const check of checks3) {
+    for (const fix of check.fixes ?? []) {
+      if (fix.withheld !== undefined) {
+        repairs.push({
+          checkId: check.id,
+          fixId: fix.id,
+          title: fix.title,
+          status: "skipped",
+          message: fix.withheld
+        });
+        continue;
+      }
+      let outcome;
+      try {
+        outcome = await fix.run();
+      } catch (error2) {
+        outcome = { ok: false, message: formatError12(error2) };
+      }
+      repairs.push({
+        checkId: check.id,
+        fixId: fix.id,
+        title: fix.title,
+        status: outcome.ok ? "applied" : "failed",
+        message: outcome.message
+      });
+      if (outcome.ok && !repairedCheckIds.includes(check.id)) {
+        repairedCheckIds.push(check.id);
+      }
+    }
+  }
+  return { repairs, repairedCheckIds };
+}
 function resolveDoctorRuntimePaths(home, resolver) {
   if (resolver) {
     return resolver();
@@ -33935,8 +35923,8 @@ function resolveDoctorRuntimePaths(home, resolver) {
     return resolveRuntimePaths();
   }
   return {
-    configPath: join19(coreHomeDir(home), "config.json"),
-    statePath: join19(coreHomeDir(home), "state.json")
+    configPath: join24(coreHomeDir(home), "config.json"),
+    statePath: join24(coreHomeDir(home), "state.json")
   };
 }
 function depsUseExplicitRuntimeOverrides() {
@@ -33976,7 +35964,7 @@ async function defaultCheckOrchestrationHealth(deps) {
       label: "Orchestration",
       severity: "skip",
       summary: "orchestration check skipped because configuration could not be loaded",
-      details: [`config path: ${deps.runtimePaths.configPath}`, `error: ${formatError9(error2)}`],
+      details: [`config path: ${deps.runtimePaths.configPath}`, `error: ${formatError12(error2)}`],
       suggestions: ["fix the Config check first, then run: xacpx doctor"]
     };
   }
@@ -33988,18 +35976,19 @@ async function defaultCheckOrchestrationHealth(deps) {
       now: () => new Date,
       heartbeatThresholdSeconds: config4.orchestration.progressHeartbeatSeconds
     });
-    return applyStateInspectionReport(result, inspection.report, deps.runtimePaths.statePath);
+    const daemonRunning = inspection.report ? await deps.isDaemonRunning() : false;
+    return applyStateInspectionReport(result, inspection.report, deps.runtimePaths.statePath, daemonRunning, deps.isDaemonRunning);
   } catch (error2) {
     return {
       id: "orchestration",
       label: "Orchestration",
       severity: "fail",
       summary: "orchestration health check failed",
-      details: [`state path: ${deps.runtimePaths.statePath}`, `error: ${formatError9(error2)}`]
+      details: [`state path: ${deps.runtimePaths.statePath}`, `error: ${formatError12(error2)}`]
     };
   }
 }
-function applyStateInspectionReport(result, report, statePath) {
+function applyStateInspectionReport(result, report, statePath, daemonRunning, isDaemonRunning) {
   if (!report) {
     return result;
   }
@@ -34017,18 +36006,74 @@ function applyStateInspectionReport(result, report, statePath) {
     suggestions: [
       ...result.suggestions ?? [],
       fileCorrupt ? "back up the state file before the next daemon start if you want to attempt manual recovery" : "the daemon backs the original file up as state.json.quarantine-* before dropping these records"
-    ]
+    ],
+    fixes: [createStateQuarantineFix(statePath, daemonRunning, isDaemonRunning)]
   };
 }
-function formatError9(error2) {
+function createStateQuarantineFix(statePath, daemonRunning, isDaemonRunning) {
+  return {
+    id: "state.quarantine",
+    title: "quarantine invalid state.json records",
+    ...daemonRunning ? { withheld: "stop the daemon first: xacpx stop" } : {},
+    run: async () => {
+      if (await isDaemonRunning()) {
+        return {
+          ok: false,
+          message: "a daemon started since detection; stop it first: xacpx stop"
+        };
+      }
+      const store = new StateStore(statePath);
+      await store.load();
+      const report = store.lastLoadReport;
+      if (!report) {
+        return { ok: true, message: "state.json was already valid; nothing to quarantine" };
+      }
+      if (report.corruptPath) {
+        return { ok: true, message: `state.json was unreadable; renamed to ${report.corruptPath} and reset` };
+      }
+      const backup = report.quarantinePath ? ` (original backed up to ${report.quarantinePath})` : "";
+      return {
+        ok: true,
+        message: `quarantined ${report.dropped.length} invalid state.json record(s)${backup}`
+      };
+    }
+  };
+}
+async function defaultIsDaemonRunning(home, runtimePaths, getDaemonStatus = () => defaultGetDaemonStatus2(home, runtimePaths)) {
+  try {
+    const status = await getDaemonStatus();
+    return status.state === "running" || status.state === "indeterminate";
+  } catch {
+    return true;
+  }
+}
+async function defaultGetDaemonStatus2(home, runtimePaths) {
+  const paths = resolveDaemonPaths({
+    home,
+    runtimeDir: resolveRuntimeDirFromConfigPath(runtimePaths.configPath)
+  });
+  const controller = createDaemonController(paths, {
+    processExecPath: process.execPath,
+    cliEntryPath: process.argv[1] ?? "",
+    cwd: process.cwd(),
+    env: process.env,
+    isProcessRunning: isProcessAlive
+  });
+  return await controller.getStatus();
+}
+function formatError12(error2) {
   return error2 instanceof Error ? error2.message : String(error2);
 }
 var init_doctor = __esm(async () => {
   init_core_home();
   init_load_config();
+  init_create_daemon_controller();
+  init_daemon_files();
   init_state_store();
   init_daemon_check();
+  init_logs_check();
   init_orchestration_health();
+  init_orchestration_socket_check();
   init_runtime_check();
   init_wechat_check();
   init_render_doctor();
@@ -34037,6 +36082,7 @@ var init_doctor = __esm(async () => {
     init_acpx_check(),
     init_bridge_check(),
     init_config_check(),
+    init_plugin_check(),
     init_smoke_check()
   ]);
 });
@@ -34061,8 +36107,8 @@ var init_doctor2 = __esm(async () => {
 // src/cli.ts
 init_core_home();
 import { randomUUID as randomUUID4 } from "node:crypto";
-import { homedir as homedir13 } from "node:os";
-import { dirname as dirname14, join as join20, 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
@@ -46559,7 +48605,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) {
@@ -46567,7 +48613,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);
 }
@@ -48104,14 +50150,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 };
@@ -48159,7 +50205,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") {
@@ -48451,7 +50497,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())
@@ -49106,121 +51152,10 @@ 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();
-
-// src/plugins/plugin-doctor.ts
-init_channel_scope();
-init_plugin_loader();
-init_validate_plugin();
-init_known_plugins();
-init_plugin_renames();
-import { readFile as readFile10 } from "node:fs/promises";
-import { join as join12 } 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 parsed = JSON.parse(raw);
-    const out = {};
-    for (const [name, value] of Object.entries(parsed.dependencies ?? {})) {
-      if (typeof value === "string")
-        out[name] = value;
-    }
-    return out;
-  } catch (error2) {
-    const message = error2 instanceof Error ? error2.message : String(error2);
-    throw new Error(`failed to read plugin home package.json: ${message}`);
-  }
-}
-async function inspectPlugins(input) {
-  const issues = [];
-  let dependencies;
-  try {
-    dependencies = await readDependencyEntries(input.pluginHome);
-  } catch (error2) {
-    const message = error2 instanceof Error ? error2.message : String(error2);
-    return [{ level: "error", message }];
-  }
-  const importPlugin = input.importPlugin ?? importPluginFromHome;
-  const allConfigured = input.config.plugins;
-  const filterByName = input.pluginName ? normalizePluginPackageName(input.pluginName) : null;
-  if (filterByName && !allConfigured.some((plugin) => normalizePluginPackageName(plugin.name) === filterByName)) {
-    return [{ level: "error", plugin: filterByName, message: `plugin is not configured; run xacpx plugin add ${filterByName}` }];
-  }
-  const pushIfRelevant = (issue2) => {
-    if (!filterByName || issue2.plugin === filterByName)
-      issues.push(issue2);
-  };
-  const channelProviders = new Map;
-  for (const configPlugin of allConfigured) {
-    if (!(configPlugin.name in dependencies)) {
-      pushIfRelevant({ level: "error", plugin: configPlugin.name, message: `package not installed in plugin home; run xacpx plugin add ${configPlugin.name}` });
-      continue;
-    }
-    let moduleValue;
-    try {
-      moduleValue = await importPlugin(configPlugin.name, input.pluginHome);
-    } catch (error2) {
-      const message = error2 instanceof Error ? error2.message : String(error2);
-      pushIfRelevant({ level: "error", plugin: configPlugin.name, message: `failed to import plugin: ${message}` });
-      continue;
-    }
-    try {
-      const plugin = validateWeacpxPlugin(moduleValue, configPlugin.name, {
-        ...input.currentXacpxVersion !== undefined ? { currentXacpxVersion: input.currentXacpxVersion } : {}
-      });
-      const channels = plugin.channels ?? [];
-      const channelTypes = channels.map((channel) => channel.type);
-      for (const type of channelTypes) {
-        const existing = channelProviders.get(type);
-        if (existing) {
-          pushIfRelevant({ level: "error", plugin: configPlugin.name, message: `channel type ${type} is already provided by ${existing.plugin}` });
-        } else {
-          channelProviders.set(type, { plugin: configPlugin.name, enabled: configPlugin.enabled });
-        }
-      }
-      pushIfRelevant({
-        level: configPlugin.enabled ? "ok" : "warn",
-        plugin: configPlugin.name,
-        message: configPlugin.enabled ? `plugin is installed and valid; channels: ${channelTypes.length > 0 ? channelTypes.join(", ") : "none"}` : `plugin is installed and valid but disabled; run xacpx plugin enable ${configPlugin.name}`
-      });
-    } catch (error2) {
-      const message = error2 instanceof Error ? error2.message : String(error2);
-      pushIfRelevant({ level: "error", plugin: configPlugin.name, message });
-    }
-  }
-  const builtInChannelTypes = new Set(listKnownChannelIds());
-  for (const channel of input.config.channels) {
-    if (channel.enabled === false)
-      continue;
-    if (builtInChannelTypes.has(channel.type))
-      continue;
-    const provider = channelProviders.get(channel.type);
-    if (!provider) {
-      if (!filterByName) {
-        issues.push({
-          level: "error",
-          message: `channel ${channel.type} is configured but no enabled plugin provides it; run xacpx plugin add ${suggestedPluginPackageForChannel(channel.type)} or another plugin that provides type "${channel.type}"`
-        });
-      }
-      continue;
-    }
-    if (!provider.enabled) {
-      pushIfRelevant({
-        level: "error",
-        plugin: provider.plugin,
-        message: `channel ${channel.type} is configured but provider plugin is disabled; run xacpx plugin enable ${provider.plugin}`
-      });
-    }
-  }
-  return issues;
-}
-
-// src/plugins/plugin-cli.ts
+init_plugin_doctor();
 init_known_plugins();
 init_plugin_renames();
 init_i18n();
@@ -49248,7 +51183,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 ?? {})) {
@@ -49274,7 +51209,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();
@@ -50416,7 +52351,7 @@ async function createCliScheduledTaskService() {
   return new ScheduledTaskService(state, stateStore);
 }
 function resolveConfigPathForCurrentEnv() {
-  return coreEnv("CONFIG") ?? join20(coreHomeDir(requireHome2()), "config.json");
+  return coreEnv("CONFIG") ?? join25(coreHomeDir(requireHome2()), "config.json");
 }
 function resolveDaemonPathsForCurrentConfig() {
   const configPath = resolveConfigPathForCurrentEnv();
@@ -50475,7 +52410,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) => {
@@ -50486,7 +52421,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);
         }
@@ -50677,7 +52612,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 = () => {
@@ -50708,7 +52643,7 @@ async function defaultPromptSecret(message) {
         if (char === "\r" || char === `
 `) {
           cleanup();
-          resolve3(chunks.join(""));
+          resolve4(chunks.join(""));
           return;
         }
         if (char === "" || char === "\b") {
@@ -50763,7 +52698,7 @@ function decodeFirstRunOnboarding(raw) {
   return null;
 }
 function requireHome2() {
-  const home = process.env.HOME ?? homedir13();
+  const home = process.env.HOME ?? homedir17();
   if (!home) {
     throw new Error("Unable to resolve the current user home directory");
   }
@@ -50787,7 +52722,7 @@ function safeDaemonLogPaths() {
     const configPath = resolveConfigPathForCurrentEnv();
     const paths = resolveDaemonPathsForCurrentConfig();
     return {
-      appLog: join20(dirname14(configPath), "runtime", "app.log"),
+      appLog: join25(dirname14(configPath), "runtime", "app.log"),
       stderrLog: paths.stderrLog
     };
   } catch {
@@ -50811,6 +52746,9 @@ function parseDoctorArgs(args) {
       case "--smoke":
         options.smoke = true;
         break;
+      case "--fix":
+        options.fix = true;
+        break;
       case "--agent": {
         const value = args[index + 1];
         if (!value || value.startsWith("--")) {