@ganglion/xacpx 0.9.2 → 0.10.0

package/dist/cli.js

@@ -93,6 +93,11 @@ var init_session = __esm(() => {
     currentLabel: "[current]",
     sessionListItem: (alias, agent, workspace) => `- ${alias} (${agent} @ ${workspace})`,
     sessionCreated: (alias) => `Session "${alias}" created and switched.`,
+    sessionAlreadyExists: (alias, agent, workspace) => [
+      `Session "${alias}" already exists (${agent} @ ${workspace}).`,
+      `Switch to it with /use ${alias}, or remove it first with /session rm ${alias}.`
+    ].join(`
+`),
     sessionAttachNotFound: (alias, agent, workspace) => [
       "No existing session found to attach.",
       `Check the session name and retry: /session attach ${alias} --agent ${agent} --ws ${workspace} --name <session-name>`
@@ -129,6 +134,7 @@ var init_session = __esm(() => {
     sessionBlockedByTasksHint: "Use /tasks to list tasks, or /task cancel <id> to cancel one.",
     sessionRemoved: (alias) => `Session "${alias}" removed.`,
     sessionRemovedWasActive: "This was the active session. Its chat context has been cleared.",
+    sessionRemovedWasActivePromoted: (alias) => `This was the active session. Switched back to the previous session "${alias}".`,
     sessionTransportShared: (transportSession, count) => `Note: backend session "${transportSession}" is still referenced by ${count} other session(s) and was not closed.`,
     sessionOrchestrationPurgeFailed: (warning) => `Note: failed to purge orchestration references (${warning}). Run /tasks clean manually to clean up.`,
     sessionTransportTeardownFailed: (warning) => `Note: backend session could not be closed automatically (${warning}). Run acpx sessions close manually if needed.`,
@@ -422,7 +428,7 @@ var init_later = __esm(() => {
     helpNote2: "Time must be at least 10 seconds and at most 7 days away",
     helpNote3: "By default runs in a new temporary session that is destroyed after completion",
     helpNote4: "Use --bind to send to the session that was current when the task was created (configurable via later.defaultMode)",
-    helpNote5: "/lt list shows all pending tasks globally; in group chats only the owner can cancel",
+    helpNote5: "/lt list shows only this chat's pending tasks; in group chats only the owner can cancel",
     helpNote6: "Scheduling slash-prefixed xacpx commands is not supported",
     helpNote7: "Full time format reference: docs/later-command.md"
   };
@@ -851,7 +857,6 @@ var init_cli_update = __esm(() => {
     updateFailed: (name, error) => `${name} update failed: ${error}`,
     targetNotFound: (name) => `Update target not found: ${name}`,
     targetVersionUnknown: (name) => `${name}: cannot check latest version; skipped.`,
-    targetNotPinned: (name) => `${name} has no recorded version; use \`xacpx plugin update ${name}\` or specify a version explicitly.`,
     multiTargetNonInteractive: "Installed plugins detected; in non-interactive mode use `xacpx update --all` or `xacpx update <name>`.",
     selectionPrompt: "Select items to update (numbers, comma-separated; a=all; Enter to cancel): ",
     selectionInvalid: (part) => `Invalid selection: ${part}`,
@@ -916,6 +921,8 @@ var init_plugin_cli = __esm(() => {
     noPlugins: "No plugins installed yet.",
     pluginListHeader: "Plugins:",
     unrecognizedArgs: (args) => `Unrecognized arguments: ${args}`,
+    pluginSpecHasDoubleQuote: (spec) => `Invalid plugin spec ${spec}: double quotes (") are never valid in an npm package spec.`,
+    pluginSpecHasPercentOnWindows: (spec) => `Invalid plugin spec ${spec}: "%" would be mangled by cmd.exe on Windows. Install the package with npm directly instead.`,
     pluginInstallFailed: (packageSpec, error) => `Plugin ${packageSpec} install failed: ${error}`,
     pluginValidateFailed: (recordedName, error) => `Plugin ${recordedName} validation failed: ${error}`,
     pluginInstalled: (recordedName) => `Plugin ${recordedName} installed`,
@@ -1027,8 +1034,6 @@ var init_weixin = __esm(() => {
     debugEnabled: "Debug mode enabled",
     debugDisabled: "Debug mode disabled",
     sessionCleared: "✅ Session cleared. Starting a fresh conversation.",
-    noAccountsLoggedIn: "No accounts are currently logged in.",
-    logoutSuccess: "✅ Logged out. All account credentials cleared.",
     commandFailed: (detail) => `❌ Command failed: ${detail}`
   };
 });
@@ -1066,6 +1071,7 @@ var init_misc = __esm(() => {
     quotaOverflowSummary: (count) => `(${count} progress updates omitted due to message limit; see final result below)`,
     finalHeadsUp: (total, sentSoFar, remaining) => `—
 \uD83D\uDCC4 Result: ${total} parts total, ${sentSoFar} sent. Reply /jx to see the next ${remaining} parts.`,
+    finalAllParked: (count) => `\uD83D\uDCC4 Message limit reached: the result (${count} parts) is parked. Reply /jx to receive it.`,
     quotedMessagePrefix: (parts) => `[Quote: ${parts}]`,
     scheduledTaskFailed: (message) => `Scheduled task failed: ${message}`,
     orchestrationTaskCompleted: (taskId, workerSession, result) => `Delegation task "${taskId}" completed
@@ -1094,6 +1100,8 @@ var init_misc = __esm(() => {
     delegateQPackageInstr3: "Do not forward the human's exact words to the worker",
     commandAccessDeniedSuffix: " is restricted to group owner only.",
     commandAccessDeniedHint: "To perform control operations, have the owner send them in the group, or use a private chat.",
+    commandAccessDeniedChatTypeMissingSuffix: " was blocked: this channel did not report the chat type (direct or group), so control commands are disabled here.",
+    commandAccessDeniedChatTypeMissingHint: "Read-only commands and prompts still work. This is a channel metadata issue — update or report the channel plugin.",
     commandLabelThisMessage: "This message",
     sessionResetNoCurrentSession: "No session is currently selected. Run /session new ... or /use <alias> first.",
     sessionResetFailed: (alias) => `Session "${alias}" reset failed. The new backend session was not created, please try again later.`,
@@ -1164,6 +1172,11 @@ var init_session2 = __esm(() => {
     currentLabel: "[当前]",
     sessionListItem: (alias, agent2, workspace2) => `- ${alias} (${agent2} @ ${workspace2})`,
     sessionCreated: (alias) => `会话「${alias}」已创建并切换`,
+    sessionAlreadyExists: (alias, agent2, workspace2) => [
+      `会话「${alias}」已存在（${agent2} @ ${workspace2}）。`,
+      `发送 /use ${alias} 切换到它，或先执行 /session rm ${alias} 删除后再创建。`
+    ].join(`
+`),
     sessionAttachNotFound: (alias, agent2, workspace2) => [
       "没有找到可绑定的已有会话。",
       `请确认会话名是否正确，然后重新执行：/session attach ${alias} --agent ${agent2} --ws ${workspace2} --name <会话名>`
@@ -1200,6 +1213,7 @@ var init_session2 = __esm(() => {
     sessionBlockedByTasksHint: "使用 /tasks 查看任务列表，或 /task cancel <id> 取消任务。",
     sessionRemoved: (alias) => `已删除会话「${alias}」。`,
     sessionRemovedWasActive: "该会话是当前活跃会话，已自动清除相关聊天上下文。",
+    sessionRemovedWasActivePromoted: (alias) => `该会话是当前活跃会话，已切换回上一个会话「${alias}」。`,
     sessionTransportShared: (transportSession, count) => `提示：后端会话「${transportSession}」仍被其他 ${count} 个会话引用，未关闭。`,
     sessionOrchestrationPurgeFailed: (warning) => `提示：清理任务编排引用失败（${warning}），请稍后执行 /tasks clean 手动清理。`,
     sessionTransportTeardownFailed: (warning) => `提示：后端会话未能自动关闭（${warning}），如有残留请手动执行 acpx sessions close。`,
@@ -1493,7 +1507,7 @@ var init_later2 = __esm(() => {
     helpNote2: "时间必须在 10 秒之后、7 天之内",
     helpNote3: "默认在为本次任务新建的临时会话里执行，跑完即销毁",
     helpNote4: "加 --bind 改为发送到创建时绑定的当前会话（默认模式可用 later.defaultMode 配置）",
-    helpNote5: "/lt list 显示全局待执行任务；群聊中只有群主可取消",
+    helpNote5: "/lt list 只显示本聊天创建的待执行任务；群聊中只有群主可取消",
     helpNote6: "不支持延迟执行 / 开头的 xacpx 命令",
     helpNote7: "完整时间格式与说明见 docs/later-command.md"
   };
@@ -1922,7 +1936,6 @@ var init_cli_update2 = __esm(() => {
     updateFailed: (name, error) => `${name} 更新失败：${error}`,
     targetNotFound: (name) => `没有找到更新项：${name}`,
     targetVersionUnknown: (name) => `${name} 无法检查最新版本，已跳过。`,
-    targetNotPinned: (name) => `${name} 未记录当前版本；请先使用 \`xacpx plugin update ${name}\` 或显式选择版本。`,
     multiTargetNonInteractive: "检测到已安装插件；非交互模式请使用 `xacpx update --all` 或 `xacpx update <name>`。",
     selectionPrompt: "请选择要更新的项目（数字，逗号分隔，a=全部，回车取消）：",
     selectionInvalid: (part) => `无效选择：${part}`,
@@ -1987,6 +2000,8 @@ var init_plugin_cli2 = __esm(() => {
     noPlugins: "还没有安装插件。",
     pluginListHeader: "插件：",
     unrecognizedArgs: (args) => `未识别的参数：${args}`,
+    pluginSpecHasDoubleQuote: (spec) => `非法插件 spec ${spec}：npm 包 spec 不允许包含双引号 (")。`,
+    pluginSpecHasPercentOnWindows: (spec) => `非法插件 spec ${spec}：Windows 上 cmd.exe 会展开 %，无法安全传递。请改用 npm 直接安装该包。`,
     pluginInstallFailed: (packageSpec, error) => `插件 ${packageSpec} 安装失败：${error}`,
     pluginValidateFailed: (recordedName, error) => `插件 ${recordedName} 校验失败：${error}`,
     pluginInstalled: (recordedName) => `插件 ${recordedName} 已安装`,
@@ -2098,8 +2113,6 @@ var init_weixin2 = __esm(() => {
     debugEnabled: "Debug 模式已开启",
     debugDisabled: "Debug 模式已关闭",
     sessionCleared: "✅ 会话已清除，重新开始对话",
-    noAccountsLoggedIn: "当前没有已登录的账号",
-    logoutSuccess: "✅ 已退出登录，清除所有账号凭证",
     commandFailed: (detail) => `❌ 指令执行失败: ${detail}`
   };
 });
@@ -2137,6 +2150,7 @@ var init_misc2 = __esm(() => {
     quotaOverflowSummary: (count) => `（因消息次数限制省略 ${count} 条进度，请继续查看下方最终结果）`,
     finalHeadsUp: (total, sentSoFar, remaining) => `—
 \uD83D\uDCC4 结果共 ${total} 段，已发 ${sentSoFar} 段。回复 /jx 续看后 ${remaining} 段。`,
+    finalAllParked: (count) => `\uD83D\uDCC4 已达消息上限：结果共 ${count} 段已暂存。回复 /jx 接收。`,
     quotedMessagePrefix: (parts) => `[引用: ${parts}]`,
     scheduledTaskFailed: (message) => `定时任务执行失败：${message}`,
     orchestrationTaskCompleted: (taskId, workerSession, result) => `委派任务「${taskId}」已完成
@@ -2165,6 +2179,8 @@ var init_misc2 = __esm(() => {
     delegateQPackageInstr3: "不要直接把 human 原话转发给 worker",
     commandAccessDeniedSuffix: " 仅限群创建者/频道 owner 使用。",
     commandAccessDeniedHint: "如果需要执行控制类操作，请由 owner 在群内发送，或改用私聊。",
+    commandAccessDeniedChatTypeMissingSuffix: " 已被拦截：该频道未上报会话类型（直聊/群聊），控制类命令在此暂不可用。",
+    commandAccessDeniedChatTypeMissingHint: "只读命令与普通对话不受影响。这是频道元数据问题，请升级或反馈该频道插件。",
     commandLabelThisMessage: "该消息",
     sessionResetNoCurrentSession: "当前还没有选中的会话。请先执行 /session new ... 或 /use <alias>。",
     sessionResetFailed: (alias) => `会话「${alias}」重置失败。
@@ -4214,7 +4230,7 @@ var require_lib = __commonJS((exports, module) => {
 import { chmod, mkdir, writeFile } from "node:fs/promises";
 import { chmodSync, mkdirSync as mkdirSync2, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
-async function writePrivateFileAtomic(path, content) {
+async function withPrivateFileLock(path, fn) {
   await mkdir(dirname(path), { recursive: true });
   const release = await lockfile.lock(path, {
     realpath: false,
@@ -4228,23 +4244,31 @@ async function writePrivateFileAtomic(path, content) {
     }
   });
   try {
-    try {
-      await retryTransientWriteErrors(async () => import_write_file_atomic.default(path, content, {
-        mode: PRIVATE_FILE_MODE,
-        encoding: "utf8",
-        fsync: true
-      }));
-    } catch (error) {
-      if (!isTransientWriteError(error, process.platform)) {
-        throw error;
-      }
-      await writeFile(path, content, { encoding: "utf8", mode: PRIVATE_FILE_MODE });
-      await chmod(path, PRIVATE_FILE_MODE).catch(() => {});
-    }
+    return await fn((content) => writePrivateFileAtomicUnlocked(path, content));
   } finally {
     await release();
   }
 }
+async function writePrivateFileAtomic(path, content) {
+  await withPrivateFileLock(path, async (writeLocked) => {
+    await writeLocked(content);
+  });
+}
+async function writePrivateFileAtomicUnlocked(path, content) {
+  try {
+    await retryTransientWriteErrors(async () => import_write_file_atomic.default(path, content, {
+      mode: PRIVATE_FILE_MODE,
+      encoding: "utf8",
+      fsync: true
+    }));
+  } catch (error) {
+    if (!isTransientWriteError(error, process.platform)) {
+      throw error;
+    }
+    await writeFile(path, content, { encoding: "utf8", mode: PRIVATE_FILE_MODE });
+    await chmod(path, PRIVATE_FILE_MODE).catch(() => {});
+  }
+}
 function writePrivateFileSync(path, content, deps = {}) {
   mkdirSync2(dirname(path), { recursive: true });
   const platform = deps.platform ?? process.platform;
@@ -4401,6 +4425,14 @@ function isRecord(value) {
 function isReplyMode(value) {
   return value === "stream" || value === "final" || value === "verbose";
 }
+function parseOwnerIds(value, path2) {
+  if (value === undefined)
+    return;
+  if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string" || entry.trim().length === 0)) {
+    throw new Error(`${path2} must be an array of non-empty strings`);
+  }
+  return value.map((entry) => entry.trim());
+}
 function parseChannelConfig(channel, legacyWechat) {
   if (channel !== undefined) {
     if (!isRecord(channel)) {
@@ -4413,6 +4445,7 @@ function parseChannelConfig(channel, legacyWechat) {
       throw new Error("channel.replyMode must be stream, final, or verbose");
     }
     const type = typeof channel.type === "string" ? channel.type : "weixin";
+    const ownerIds = parseOwnerIds(channel.ownerIds, "channel.ownerIds");
     let options = undefined;
     if ("feishu" in channel && isRecord(channel.feishu)) {
       options = channel.feishu;
@@ -4422,6 +4455,7 @@ function parseChannelConfig(channel, legacyWechat) {
     return {
       type,
       replyMode: isReplyMode(channel.replyMode) ? channel.replyMode : DEFAULT_CHANNEL_CONFIG.replyMode,
+      ...ownerIds ? { ownerIds } : {},
       ...options ? { options } : {}
     };
   }
@@ -4660,6 +4694,7 @@ function parseRuntimeChannelConfig(raw, index) {
   if ("replyMode" in raw && !isReplyMode(raw.replyMode)) {
     throw new Error(`channels[${index}].replyMode must be stream, final, or verbose`);
   }
+  const ownerIds = parseOwnerIds(raw.ownerIds, `channels[${index}].ownerIds`);
   let options = undefined;
   if ("feishu" in raw && isRecord(raw.feishu)) {
     options = raw.feishu;
@@ -4671,6 +4706,7 @@ function parseRuntimeChannelConfig(raw, index) {
     type: raw.type,
     enabled,
     ...isReplyMode(raw.replyMode) ? { replyMode: raw.replyMode } : {},
+    ...ownerIds ? { ownerIds } : {},
     ...options ? { options } : {}
   };
 }
@@ -4755,6 +4791,8 @@ var init_load_config = __esm(() => {
 });
 
 // src/config/config-store.ts
+import { readFile as readFile2 } from "node:fs/promises";
+
 class ConfigStore {
   path;
   constructor(path2) {
@@ -4763,60 +4801,250 @@ class ConfigStore {
   async load() {
     return await loadConfig(this.path);
   }
-  async save(config3) {
-    await writePrivateFileAtomic(this.path, `${JSON.stringify(config3, null, 2)}
-`);
+  async getRawValue(path2) {
+    return readRawConfigValue((await this.readRaw()).raw, path2);
+  }
+  async setRawValue(path2, value) {
+    return await this.patchRaw((raw) => {
+      setRawConfigValue(raw, path2, value);
+    });
+  }
+  async unsetRawValue(path2) {
+    return await this.patchRaw((raw) => {
+      unsetRawConfigValue(raw, path2);
+    });
   }
   async upsertWorkspace(name, cwd, description) {
-    const config3 = await this.load();
-    const workspace3 = {
-      cwd,
-      ...description ? { description } : {}
-    };
-    config3.workspaces[name] = workspace3;
-    await this.save(config3);
-    return config3;
+    assertSafeConfigKey(name);
+    return await this.patchRaw((raw) => {
+      const workspaces = ensureRecordAt(raw, "workspaces");
+      workspaces[name] = {
+        cwd,
+        ...description ? { description } : {}
+      };
+    });
   }
   async removeWorkspace(name) {
-    const config3 = await this.load();
-    delete config3.workspaces[name];
-    await this.save(config3);
-    return config3;
+    assertSafeConfigKey(name);
+    return await this.patchRaw((raw) => {
+      deleteRecordEntry(raw, "workspaces", name);
+    });
   }
   async upsertAgent(name, agent3) {
-    const config3 = await this.load();
-    config3.agents[name] = agent3;
-    await this.save(config3);
-    return config3;
+    assertSafeConfigKey(name);
+    return await this.patchRaw((raw) => {
+      const agents = ensureRecordAt(raw, "agents");
+      agents[name] = {
+        driver: agent3.driver,
+        ...agent3.command ? { command: agent3.command } : {}
+      };
+    });
   }
   async removeAgent(name) {
-    const config3 = await this.load();
-    delete config3.agents[name];
-    await this.save(config3);
-    return config3;
-  }
-  async updateTransport(transport) {
-    const config3 = await this.load();
-    config3.transport = {
-      ...config3.transport,
-      ...transport
-    };
-    await this.save(config3);
-    return config3;
-  }
-  async updateChannel(channel) {
-    const config3 = await this.load();
-    config3.channel = {
-      ...config3.channel,
-      ...channel
-    };
-    await this.save(config3);
-    return config3;
+    assertSafeConfigKey(name);
+    return await this.patchRaw((raw) => {
+      deleteRecordEntry(raw, "agents", name);
+    });
+  }
+  async updateTransport(patch) {
+    return await this.patchRaw((raw) => {
+      applyRecordPatch(ensureRecordAt(raw, "transport"), patch);
+    });
+  }
+  async updateChannel(patch) {
+    return await this.patchRaw((raw) => {
+      applyRecordPatch(ensureRecordAt(raw, "channel"), patch);
+    });
+  }
+  async replacePlugins(plugins) {
+    return await this.patchRaw((raw) => {
+      raw.plugins = clonePlain(plugins);
+    });
+  }
+  async replaceChannels(channels) {
+    return await this.patchRaw((raw) => {
+      raw.channels = clonePlain(channels);
+    });
+  }
+  async patchRaw(mutate) {
+    return await withPrivateFileLock(this.path, async (writeLocked) => {
+      const { raw, existed } = await this.readRaw();
+      const doc = existed ? raw : { transport: {}, agents: {}, workspaces: {} };
+      mutate(doc);
+      const parsed = parseConfig({ transport: {}, agents: {}, workspaces: {}, ...doc });
+      await writeLocked(serializeRawConfig(doc));
+      return parsed;
+    });
+  }
+  async readRaw() {
+    let text;
+    try {
+      text = await readFile2(this.path, "utf8");
+    } catch (error) {
+      if (isMissingFileError(error)) {
+        return { raw: {}, existed: false };
+      }
+      throw error;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(text);
+    } catch (error) {
+      throw new Error(`refusing to modify ${this.path}: it is not valid JSON (${error instanceof Error ? error.message : String(error)}); fix the file and retry`);
+    }
+    if (!isPlainRecord(parsed)) {
+      throw new Error(`refusing to modify ${this.path}: the top level must be a JSON object`);
+    }
+    return { raw: parsed, existed: true };
+  }
+}
+function serializeRawConfig(raw) {
+  return `${JSON.stringify(raw, null, 2)}
+`;
+}
+function readRawConfigValue(root, path2) {
+  const lastKey = requireObjectKeyTail(path2);
+  let container = root;
+  for (const segment of path2.slice(0, -1)) {
+    const next = descendForRead(container, segment);
+    if (!next.ok) {
+      return { present: false };
+    }
+    container = next.value;
+  }
+  if (!isPlainRecord(container) || !Object.hasOwn(container, lastKey)) {
+    return { present: false };
+  }
+  return { present: true, value: container[lastKey] };
+}
+function setRawConfigValue(root, path2, value) {
+  const lastKey = requireObjectKeyTail(path2);
+  let container = root;
+  for (let index = 0;index < path2.length - 1; index += 1) {
+    const segment = path2[index];
+    const nextSegment = path2[index + 1];
+    container = descendForWrite(container, segment, typeof nextSegment !== "string", path2);
+  }
+  if (!isPlainRecord(container)) {
+    throw new Error(`config path "${describeRawConfigPath(path2)}" does not address an object`);
+  }
+  container[lastKey] = value;
+}
+function unsetRawConfigValue(root, path2) {
+  const lastKey = requireObjectKeyTail(path2);
+  let container = root;
+  for (const segment of path2.slice(0, -1)) {
+    const next = descendForRead(container, segment);
+    if (!next.ok) {
+      return;
+    }
+    container = next.value;
+  }
+  if (isPlainRecord(container)) {
+    delete container[lastKey];
+  }
+}
+function descendForRead(container, segment) {
+  if (typeof segment === "string") {
+    assertSafeConfigKey(segment);
+    if (!isPlainRecord(container) || !Object.hasOwn(container, segment)) {
+      return { ok: false };
+    }
+    return { ok: true, value: container[segment] };
+  }
+  if (!Array.isArray(container)) {
+    return { ok: false };
+  }
+  const entry = container.find((item) => isPlainRecord(item) && item.id === segment.id);
+  return entry === undefined ? { ok: false } : { ok: true, value: entry };
+}
+function descendForWrite(container, segment, nextIsArrayEntry, path2) {
+  if (typeof segment === "string") {
+    assertSafeConfigKey(segment);
+    if (!isPlainRecord(container)) {
+      throw new Error(`config path "${describeRawConfigPath(path2)}" does not address an object at "${segment}"`);
+    }
+    let existing = container[segment];
+    if (existing === undefined) {
+      existing = nextIsArrayEntry ? [] : {};
+      container[segment] = existing;
+    }
+    if (!isPlainRecord(existing) && !Array.isArray(existing)) {
+      throw new Error(`refusing to overwrite config key "${segment}" (path "${describeRawConfigPath(path2)}"): it is not an object`);
+    }
+    return existing;
+  }
+  if (!Array.isArray(container)) {
+    throw new Error(`config path "${describeRawConfigPath(path2)}" expects an array before [id=${segment.id}]`);
+  }
+  const entry = container.find((item) => isPlainRecord(item) && item.id === segment.id);
+  if (entry !== undefined) {
+    return entry;
+  }
+  if (!segment.createWith) {
+    throw new Error(`config path "${describeRawConfigPath(path2)}" has no entry with id "${segment.id}"`);
+  }
+  const created = clonePlain(segment.createWith);
+  container.push(created);
+  return created;
+}
+function requireObjectKeyTail(path2) {
+  const last = path2[path2.length - 1];
+  if (typeof last !== "string") {
+    throw new Error("raw config path must end with an object key");
+  }
+  assertSafeConfigKey(last);
+  return last;
+}
+function assertSafeConfigKey(key) {
+  if (PROTOTYPE_POLLUTING_KEYS.has(key)) {
+    throw new Error(`refusing to use unsafe config key "${key}"`);
+  }
+}
+function describeRawConfigPath(path2) {
+  return path2.map((segment) => typeof segment === "string" ? segment : `[id=${segment.id}]`).join(".");
+}
+function ensureRecordAt(raw, key) {
+  const existing = raw[key];
+  if (existing === undefined) {
+    const created = {};
+    raw[key] = created;
+    return created;
+  }
+  if (!isPlainRecord(existing)) {
+    throw new Error(`refusing to overwrite config key "${key}": it is not a JSON object`);
+  }
+  return existing;
+}
+function deleteRecordEntry(raw, section, name) {
+  const record = raw[section];
+  if (isPlainRecord(record)) {
+    delete record[name];
   }
 }
+function applyRecordPatch(target, patch) {
+  for (const [key, value] of Object.entries(patch)) {
+    if (value === undefined) {
+      delete target[key];
+    } else {
+      target[key] = value;
+    }
+  }
+}
+function clonePlain(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function isPlainRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isMissingFileError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+var PROTOTYPE_POLLUTING_KEYS;
 var init_config_store = __esm(() => {
   init_private_file();
   init_load_config();
+  PROTOTYPE_POLLUTING_KEYS = new Set(["__proto__", "constructor", "prototype"]);
 });
 
 // src/config/default-workspace.ts
@@ -4829,16 +5057,16 @@ var init_default_workspace = __esm(() => {
 });
 
 // src/config/ensure-config.ts
-import { readFile as readFile2 } from "node:fs/promises";
+import { readFile as readFile3 } from "node:fs/promises";
 async function ensureConfigExists(path2, options = {}) {
   try {
     await loadConfig(path2);
   } catch (error) {
-    if (!isMissingFileError(error)) {
+    if (!isMissingFileError2(error)) {
       throw error;
     }
-    const store = new ConfigStore(path2);
-    await store.save(await loadDefaultConfigTemplate(options));
+    const seed = await loadDefaultConfigTemplate(options);
+    await writePrivateFileAtomic(path2, serializeRawConfig(seed));
   }
 }
 async function loadDefaultConfigTemplate(options = {}) {
@@ -4846,7 +5074,7 @@ async function loadDefaultConfigTemplate(options = {}) {
     try {
       return normalizeDefaultConfigTemplate(await options.readDefaultConfigTemplate());
     } catch (error) {
-      if (!isMissingFileError(error)) {
+      if (!isMissingFileError2(error)) {
         throw error;
       }
     }
@@ -4858,10 +5086,10 @@ async function loadDefaultConfigTemplate(options = {}) {
   let raw;
   for (const candidate of candidates) {
     try {
-      raw = await readFile2(candidate, "utf8");
+      raw = await readFile3(candidate, "utf8");
       break;
     } catch (error) {
-      if (!isMissingFileError(error)) {
+      if (!isMissingFileError2(error)) {
         throw error;
       }
     }
@@ -4874,7 +5102,14 @@ async function loadDefaultConfigTemplate(options = {}) {
 function normalizeDefaultConfigTemplate(raw) {
   const template = parseConfig(raw);
   return {
-    ...template,
+    transport: {
+      type: template.transport.type,
+      ...template.transport.command ? { command: template.transport.command } : {}
+    },
+    channel: {
+      type: template.channel.type,
+      replyMode: template.channel.replyMode
+    },
     agents: Object.fromEntries(Object.entries(template.agents).map(([name, agent3]) => [
       name,
       {
@@ -4887,32 +5122,18 @@ function normalizeDefaultConfigTemplate(raw) {
     }
   };
 }
-function isMissingFileError(error) {
+function isMissingFileError2(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 var BUILTIN_DEFAULT_CONFIG_TEMPLATE;
 var init_ensure_config = __esm(() => {
+  init_private_file();
   init_config_store();
   init_default_workspace();
   init_load_config();
   BUILTIN_DEFAULT_CONFIG_TEMPLATE = {
     transport: {
-      type: "acpx-bridge",
-      sessionInitTimeoutMs: 120000,
-      permissionMode: "approve-all",
-      nonInteractivePermissions: "deny"
-    },
-    logging: {
-      level: "info",
-      maxSizeBytes: 2 * 1024 * 1024,
-      maxFiles: 5,
-      retentionDays: 7,
-      perf: {
-        enabled: false,
-        maxSizeBytes: 5242880,
-        maxFiles: 3,
-        retentionDays: 7
-      }
+      type: "acpx-bridge"
     },
     channel: {
       type: "weixin",
@@ -4924,8 +5145,7 @@ var init_ensure_config = __esm(() => {
     },
     workspaces: {
       [DEFAULT_HOME_WORKSPACE_NAME]: { ...DEFAULT_HOME_WORKSPACE }
-    },
-    plugins: []
+    }
   };
 });
 
@@ -5006,7 +5226,7 @@ var init_agent_templates = __esm(() => {
 });
 
 // src/daemon/daemon-status.ts
-import { mkdir as mkdir2, readFile as readFile3, rm, writeFile as writeFile2 } from "node:fs/promises";
+import { mkdir as mkdir2, readFile as readFile4, rm } from "node:fs/promises";
 import { dirname as dirname2 } from "node:path";
 
 class DaemonStatusStore {
@@ -5016,7 +5236,7 @@ class DaemonStatusStore {
   }
   async load() {
     try {
-      const content = await readFile3(this.path, "utf8");
+      const content = await readFile4(this.path, "utf8");
       if (content.trim() === "") {
         return null;
       }
@@ -5032,18 +5252,37 @@ class DaemonStatusStore {
     }
   }
   async save(status) {
-    await mkdir2(dirname2(this.path), { recursive: true });
-    await writeFile2(this.path, JSON.stringify(status, null, 2));
+    await mkdir2(dirname2(this.path), { recursive: true, mode: 448 });
+    await import_write_file_atomic2.default(this.path, JSON.stringify(status, null, 2), { encoding: "utf8" });
   }
   async clear() {
     await rm(this.path, { force: true });
   }
 }
-var init_daemon_status = () => {};
+var import_write_file_atomic2;
+var init_daemon_status = __esm(() => {
+  import_write_file_atomic2 = __toESM(require_lib(), 1);
+});
+
+// src/daemon/private-runtime-dir.ts
+import { chmod as chmod2, mkdir as mkdir3 } from "node:fs/promises";
+async function ensurePrivateRuntimeDir(runtimeDir, options = {}) {
+  await mkdir3(runtimeDir, { recursive: true, mode: 448 });
+  const platform = options.platform ?? process.platform;
+  if (platform === "win32") {
+    return;
+  }
+  const chmodImpl = options.chmodImpl ?? chmod2;
+  try {
+    await chmodImpl(runtimeDir, 448);
+  } catch (error) {
+    options.onChmodError?.(error);
+  }
+}
+var init_private_runtime_dir = () => {};
 
 // src/daemon/daemon-controller.ts
-import { mkdir as mkdir3, open, readFile as readFile4, rm as rm2 } from "node:fs/promises";
-import { dirname as dirname3 } from "node:path";
+import { open, readFile as readFile5, rm as rm2 } from "node:fs/promises";
 
 class DaemonController {
   paths;
@@ -5131,7 +5370,7 @@ class DaemonController {
   }
   async loadPid() {
     try {
-      const content = await readFile4(this.paths.pidFile, "utf8");
+      const content = await readFile5(this.paths.pidFile, "utf8");
       const pid = Number(content.trim());
       return Number.isFinite(pid) && pid > 0 ? pid : null;
     } catch (error) {
@@ -5142,7 +5381,7 @@ class DaemonController {
     }
   }
   async openPidFileExclusive() {
-    await mkdir3(dirname3(this.paths.pidFile), { recursive: true });
+    await ensurePrivateRuntimeDir(this.paths.runtimeDir);
     try {
       return await open(this.paths.pidFile, "wx", 384);
     } catch (error) {
@@ -5196,6 +5435,7 @@ class DaemonController {
 }
 var init_daemon_controller = __esm(() => {
   init_daemon_status();
+  init_private_runtime_dir();
 });
 
 // src/process/terminate-process-tree.ts
@@ -5247,13 +5487,15 @@ async function defaultRunProcessCommand(command, args) {
 var init_terminate_process_tree = () => {};
 
 // src/daemon/create-daemon-controller.ts
-import { mkdir as mkdir4, open as open2 } from "node:fs/promises";
+import { open as open2 } from "node:fs/promises";
 import { spawn as spawn2 } from "node:child_process";
 function createDaemonController(paths, options) {
   return new DaemonController(paths, {
     isProcessRunning: options.isProcessRunning ?? defaultIsProcessRunning2,
     spawnDetached: async (spawnOptions) => {
-      await mkdir4(paths.runtimeDir, { recursive: true });
+      await ensurePrivateRuntimeDir(paths.runtimeDir, {
+        ...options.platform ? { platform: options.platform } : {}
+      });
       const stdoutHandle = await open2(paths.stdoutLog, "a", 384);
       const stderrHandle = await open2(paths.stderrLog, "a", 384);
       await stdoutHandle.chmod(384).catch(() => {});
@@ -5325,8 +5567,10 @@ function buildSpawnRequest(paths, options, stdoutFd, stderrFd, spawnOptions = {}
 function buildWindowsLauncherScript() {
   const script = [
     "$env:XACPX_DAEMON_RUN = '1'",
+    `$arg0 = '"' + $env:XACPX_DAEMON_ARG0 + '"'`,
+    `$arg1 = '"' + $env:XACPX_DAEMON_ARG1 + '"'`,
     "$process = Start-Process -FilePath $env:XACPX_DAEMON_COMMAND `",
-    "  -ArgumentList @($env:XACPX_DAEMON_ARG0, $env:XACPX_DAEMON_ARG1) `",
+    "  -ArgumentList @($arg0, $arg1) `",
     "  -WorkingDirectory $env:XACPX_DAEMON_CWD `",
     "  -RedirectStandardOutput $env:XACPX_DAEMON_STDOUT `",
     "  -RedirectStandardError $env:XACPX_DAEMON_STDERR `",
@@ -5397,6 +5641,7 @@ async function defaultTerminateProcess(pid) {
 }
 var init_create_daemon_controller = __esm(() => {
   init_daemon_controller();
+  init_private_runtime_dir();
   init_terminate_process_tree();
 });
 
@@ -5433,7 +5678,7 @@ function encodeOrchestrationRpcResponse(response) {
 var init_orchestration_ipc = () => {};
 
 // src/daemon/daemon-files.ts
-import { dirname as dirname4, join as join4 } from "node:path";
+import { dirname as dirname3, join as join4 } from "node:path";
 function resolveDaemonPaths(options) {
   const runtimeDir = options.runtimeDir ?? (options.configPath ? resolveRuntimeDirFromConfigPath(options.configPath) : join4(coreHomeDir(options.home), "runtime"));
   return {
@@ -5446,7 +5691,7 @@ function resolveDaemonPaths(options) {
   };
 }
 function resolveRuntimeDirFromConfigPath(configPath) {
-  return join4(dirname4(configPath), "runtime");
+  return join4(dirname3(configPath), "runtime");
 }
 function resolveDaemonOrchestrationSocketPath(runtimeDir, platform = process.platform) {
   return resolveOrchestrationEndpoint(runtimeDir, platform).path;
@@ -11959,6 +12204,41 @@ var init_version = __esm(() => {
   XACPX_CORE_VERSION = readVersion();
 });
 
+// src/orchestration/endpoint-probe.ts
+import { createConnection } from "node:net";
+async function canConnectToEndpoint(path3, timeoutMs) {
+  return await new Promise((resolve) => {
+    const socket = createConnection(path3);
+    let settled = false;
+    let timer;
+    const finish = (result) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      if (timer) {
+        clearTimeout(timer);
+      }
+      socket.destroy();
+      resolve(result);
+    };
+    if (timeoutMs !== undefined && timeoutMs > 0) {
+      timer = setTimeout(() => finish(true), timeoutMs);
+      timer.unref?.();
+    }
+    socket.once("connect", () => finish(true));
+    socket.once("error", (error2) => {
+      const code = error2.code;
+      if (code === "ENOENT" || code === "ECONNREFUSED") {
+        finish(false);
+        return;
+      }
+      finish(true);
+    });
+  });
+}
+var init_endpoint_probe = () => {};
+
 // src/orchestration/task-watch-timeouts.ts
 var DEFAULT_TASK_WATCH_TIMEOUT_MS = 60000, MAX_TASK_WATCH_TIMEOUT_MS, DEFAULT_TASK_WATCH_POLL_INTERVAL_MS = 1000, MAX_TASK_WATCH_POLL_INTERVAL_MS = 1e4, TASK_WATCH_RPC_TIMEOUT_PADDING_MS = 5000;
 var init_task_watch_timeouts = __esm(() => {
@@ -12014,6 +12294,14 @@ function escapeRegExp(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
+// src/orchestration/coordinator-identity.ts
+function stableCoordinatorSession(transportSession) {
+  return transportSession.replace(/:reset-\d+$/, "");
+}
+function sameCoordinatorSession(a, b) {
+  return stableCoordinatorSession(a) === stableCoordinatorSession(b);
+}
+
 // src/util/text.ts
 function truncateText(text, maxLength, ellipsis = "…") {
   if (text.length <= maxLength)
@@ -12083,10 +12371,24 @@ function createEmptyState() {
 var init_types = () => {};
 
 // src/state/state-store.ts
-import { readFile as readFile5 } from "node:fs/promises";
+import { readFile as readFile6, rename, writeFile as writeFile3 } from "node:fs/promises";
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function sectionRecord(value, section, dropped) {
+  if (value === undefined) {
+    return {};
+  }
+  if (!isRecord2(value)) {
+    dropped.push({
+      section,
+      key: "",
+      reason: `field "${section}" is not an object; reset to empty`
+    });
+    return {};
+  }
+  return value;
+}
 function isString(value) {
   return typeof value === "string";
 }
@@ -12191,73 +12493,82 @@ function isHumanQuestionPackageRecord(value) {
   const messages = value.messages;
   return isString(value.packageId) && isString(value.coordinatorSession) && (value.status === "active" || value.status === "closed") && isString(value.createdAt) && isString(value.updatedAt) && isOptionalString(value.closedAt) && Array.isArray(initialTaskIds) && initialTaskIds.every(isString) && Array.isArray(openTaskIds) && openTaskIds.every(isString) && Array.isArray(resolvedTaskIds) && resolvedTaskIds.every(isString) && Array.isArray(messages) && messages.every(isHumanQuestionPackageMessageRecord) && isOptionalString(value.awaitingReplyMessageId);
 }
-function parseOrchestrationState(raw, path3) {
+function parseOrchestrationState(raw, dropped) {
   if (raw === undefined) {
     return createEmptyOrchestrationState();
   }
   if (!isRecord2(raw)) {
-    throw new Error(`state file "${path3}" must contain an object field "orchestration"`);
-  }
-  const tasks = raw.tasks;
-  if (tasks !== undefined && !isRecord2(tasks)) {
-    throw new Error(`state file "${path3}" must contain an object field "orchestration.tasks"`);
-  }
-  const workerBindings = raw.workerBindings;
-  if (workerBindings !== undefined && !isRecord2(workerBindings)) {
-    throw new Error(`state file "${path3}" must contain an object field "orchestration.workerBindings"`);
-  }
-  const groups = raw.groups;
-  if (groups !== undefined && !isRecord2(groups)) {
-    throw new Error(`state file "${path3}" must contain an object field "orchestration.groups"`);
-  }
-  const humanQuestionPackages = raw.humanQuestionPackages;
-  if (humanQuestionPackages !== undefined && !isRecord2(humanQuestionPackages)) {
-    throw new Error(`state file "${path3}" must contain an object field "orchestration.humanQuestionPackages"`);
-  }
-  const coordinatorQuestionState = raw.coordinatorQuestionState;
-  if (coordinatorQuestionState !== undefined && !isRecord2(coordinatorQuestionState)) {
-    throw new Error(`state file "${path3}" must contain an object field "orchestration.coordinatorQuestionState"`);
-  }
-  const coordinatorRoutes = raw.coordinatorRoutes;
-  if (coordinatorRoutes !== undefined && !isRecord2(coordinatorRoutes)) {
-    throw new Error(`state file "${path3}" must contain an object field "orchestration.coordinatorRoutes"`);
-  }
-  const externalCoordinators = raw.externalCoordinators;
-  if (externalCoordinators !== undefined && !isRecord2(externalCoordinators)) {
-    throw new Error(`state file "${path3}" must contain an object field "orchestration.externalCoordinators"`);
+    dropped.push({
+      section: "orchestration",
+      key: "",
+      reason: 'field "orchestration" is not an object; reset to empty'
+    });
+    return createEmptyOrchestrationState();
   }
+  const tasks = sectionRecord(raw.tasks, "orchestration.tasks", dropped);
+  const workerBindings = sectionRecord(raw.workerBindings, "orchestration.workerBindings", dropped);
+  const groups = sectionRecord(raw.groups, "orchestration.groups", dropped);
+  const humanQuestionPackages = sectionRecord(raw.humanQuestionPackages, "orchestration.humanQuestionPackages", dropped);
+  const coordinatorQuestionState = sectionRecord(raw.coordinatorQuestionState, "orchestration.coordinatorQuestionState", dropped);
+  const coordinatorRoutes = sectionRecord(raw.coordinatorRoutes, "orchestration.coordinatorRoutes", dropped);
+  const externalCoordinators = sectionRecord(raw.externalCoordinators, "orchestration.externalCoordinators", dropped);
   const parsedTasks = {};
-  for (const [taskId, task] of Object.entries(tasks ?? {})) {
+  for (const [taskId, task] of Object.entries(tasks)) {
     if (!isTaskRecord(task)) {
-      throw new Error(`state file "${path3}" contains an invalid orchestration task at "${taskId}"`);
+      dropped.push({
+        section: "orchestration.tasks",
+        key: taskId,
+        reason: "malformed orchestration task record"
+      });
+      continue;
     }
     parsedTasks[taskId] = task;
   }
   const parsedWorkerBindings = {};
-  for (const [workerSession, binding] of Object.entries(workerBindings ?? {})) {
+  for (const [workerSession, binding] of Object.entries(workerBindings)) {
     if (!isWorkerBindingRecord(binding)) {
-      throw new Error(`state file "${path3}" contains an invalid orchestration worker binding at "${workerSession}"`);
+      dropped.push({
+        section: "orchestration.workerBindings",
+        key: workerSession,
+        reason: "malformed orchestration worker binding record"
+      });
+      continue;
     }
     parsedWorkerBindings[workerSession] = binding;
   }
   const parsedGroups = {};
-  for (const [groupId, group] of Object.entries(groups ?? {})) {
+  for (const [groupId, group] of Object.entries(groups)) {
     if (!isGroupRecord(group)) {
-      throw new Error(`state file "${path3}" contains an invalid orchestration group at "${groupId}"`);
+      dropped.push({
+        section: "orchestration.groups",
+        key: groupId,
+        reason: "malformed orchestration group record"
+      });
+      continue;
     }
     parsedGroups[groupId] = group;
   }
   const parsedHumanQuestionPackages = {};
-  for (const [packageId, packageRecord] of Object.entries(humanQuestionPackages ?? {})) {
+  for (const [packageId, packageRecord] of Object.entries(humanQuestionPackages)) {
     if (!isHumanQuestionPackageRecord(packageRecord)) {
-      throw new Error(`state file "${path3}" contains an invalid human question package at "${packageId}"`);
+      dropped.push({
+        section: "orchestration.humanQuestionPackages",
+        key: packageId,
+        reason: "malformed human question package record"
+      });
+      continue;
     }
     parsedHumanQuestionPackages[packageId] = packageRecord;
   }
   const parsedCoordinatorQuestionState = {};
-  for (const [coordinatorSession, questionState] of Object.entries(coordinatorQuestionState ?? {})) {
+  for (const [coordinatorSession, questionState] of Object.entries(coordinatorQuestionState)) {
     if (!isCoordinatorQuestionStateRecord(questionState)) {
-      throw new Error(`state file "${path3}" contains an invalid coordinator question state at "${coordinatorSession}"`);
+      dropped.push({
+        section: "orchestration.coordinatorQuestionState",
+        key: coordinatorSession,
+        reason: "malformed coordinator question state record"
+      });
+      continue;
     }
     parsedCoordinatorQuestionState[coordinatorSession] = {
       activePackageId: questionState.activePackageId,
@@ -12265,19 +12576,34 @@ function parseOrchestrationState(raw, path3) {
     };
   }
   const parsedCoordinatorRoutes = {};
-  for (const [coordinatorSession, route] of Object.entries(coordinatorRoutes ?? {})) {
+  for (const [coordinatorSession, route] of Object.entries(coordinatorRoutes)) {
     if (!isCoordinatorRouteContextRecord(route)) {
-      throw new Error(`state file "${path3}" contains an invalid coordinator route at "${coordinatorSession}"`);
+      dropped.push({
+        section: "orchestration.coordinatorRoutes",
+        key: coordinatorSession,
+        reason: "malformed coordinator route record"
+      });
+      continue;
     }
     parsedCoordinatorRoutes[coordinatorSession] = route;
   }
   const parsedExternalCoordinators = {};
-  for (const [coordinatorSession, externalCoordinator] of Object.entries(externalCoordinators ?? {})) {
+  for (const [coordinatorSession, externalCoordinator] of Object.entries(externalCoordinators)) {
     if (!isExternalCoordinatorRecord(externalCoordinator)) {
-      throw new Error(`state file "${path3}" contains an invalid external coordinator at "${coordinatorSession}"`);
+      dropped.push({
+        section: "orchestration.externalCoordinators",
+        key: coordinatorSession,
+        reason: "malformed external coordinator record"
+      });
+      continue;
     }
     if (externalCoordinator.coordinatorSession !== coordinatorSession) {
-      throw new Error(`state file "${path3}" contains an external coordinator key mismatch at "${coordinatorSession}"`);
+      dropped.push({
+        section: "orchestration.externalCoordinators",
+        key: coordinatorSession,
+        reason: `coordinatorSession "${externalCoordinator.coordinatorSession}" does not match map key`
+      });
+      continue;
     }
     parsedExternalCoordinators[coordinatorSession] = externalCoordinator;
   }
@@ -12303,11 +12629,12 @@ function isSessionRecord(value) {
   }
   return isString(value.alias) && isString(value.agent) && isString(value.workspace) && isString(value.transport_session) && isSessionSource(value.source) && isOptionalString(value.agent_session_id) && isOptionalString(value.agent_session_title) && isOptionalString(value.agent_session_updated_at) && isOptionalString(value.attached_at) && isOptionalString(value.transport_agent_command) && isOptionalString(value.mode_id) && (value.reply_mode === undefined || isReplyMode2(value.reply_mode)) && isString(value.created_at) && isString(value.last_used_at);
 }
-function parseSessions(raw, path3) {
+function parseSessions(raw, dropped) {
   const sessions = {};
   for (const [alias, value] of Object.entries(raw)) {
     if (!isSessionRecord(value)) {
-      throw new Error(`state file "${path3}" contains malformed session record "${alias}"`);
+      dropped.push({ section: "sessions", key: alias, reason: "malformed session record" });
+      continue;
     }
     sessions[alias] = value;
   }
@@ -12316,11 +12643,12 @@ function parseSessions(raw, path3) {
 function isChatContextRecord(value) {
   return isRecord2(value) && isString(value.current_session);
 }
-function parseChatContexts(raw, path3) {
+function parseChatContexts(raw, dropped) {
   const chatContexts = {};
   for (const [chatKey, value] of Object.entries(raw)) {
     if (!isChatContextRecord(value)) {
-      throw new Error(`state file "${path3}" contains malformed chat context record "${chatKey}"`);
+      dropped.push({ section: "chat_contexts", key: chatKey, reason: "malformed chat context record" });
+      continue;
     }
     chatContexts[chatKey] = value;
   }
@@ -12361,56 +12689,58 @@ function isScheduledTaskRecord(value) {
     return false;
   return isString(value.id) && isString(value.chat_key) && isString(value.session_alias) && isString(value.execute_at) && isString(value.message) && isScheduledTaskStatus(value.status) && isString(value.created_at) && isOptionalString(value.account_id) && isOptionalString(value.reply_context_token) && isOptionalString(value.source_label) && isOptionalString(value.triggered_at) && isOptionalString(value.executed_at) && isOptionalString(value.cancelled_at) && isOptionalString(value.missed_at) && isOptionalString(value.failed_at) && isOptionalString(value.last_error) && isOptionalScheduledSessionMode(value.session_mode) && isOptionalString(value.agent) && isOptionalString(value.workspace);
 }
-function parseScheduledTasks(raw, path3) {
-  if (raw === undefined)
-    return {};
-  if (!isRecord2(raw)) {
-    throw new Error(`state file "${path3}" must contain an object field "scheduled_tasks"`);
-  }
+function parseScheduledTasks(raw, dropped) {
+  const source = sectionRecord(raw, "scheduled_tasks", dropped);
   const tasks = {};
-  for (const [id, value] of Object.entries(raw)) {
+  for (const [id, value] of Object.entries(source)) {
     if (!isScheduledTaskRecord(value) || value.id !== id) {
-      throw new Error(`state file "${path3}" contains malformed scheduled task record "${id}"`);
+      dropped.push({ section: "scheduled_tasks", key: id, reason: "malformed scheduled task record" });
+      continue;
     }
     tasks[id] = value;
   }
   return tasks;
 }
-function parseState(raw, path3) {
+function parseState(raw, path3, dropped = []) {
   if (!isRecord2(raw)) {
     throw new Error(`state file "${path3}" must contain a JSON object`);
   }
-  const sessions = raw.sessions;
-  if (!isRecord2(sessions)) {
-    throw new Error(`state file "${path3}" must contain an object field "sessions"`);
-  }
-  const chatContexts = raw.chat_contexts;
-  if (!isRecord2(chatContexts)) {
-    throw new Error(`state file "${path3}" must contain an object field "chat_contexts"`);
-  }
-  const parsedSessions = parseSessions(sessions, path3);
-  const orchestration3 = parseOrchestrationState(raw.orchestration, path3);
-  validateExternalCoordinatorIdentityCollisions(parsedSessions, orchestration3, path3);
+  const parsedSessions = parseSessions(sectionRecord(raw.sessions, "sessions", dropped), dropped);
+  const orchestration3 = parseOrchestrationState(raw.orchestration, dropped);
+  repairExternalCoordinatorIdentityCollisions(parsedSessions, orchestration3, dropped);
   return {
     sessions: parsedSessions,
-    chat_contexts: parseChatContexts(chatContexts, path3),
+    chat_contexts: parseChatContexts(sectionRecord(raw.chat_contexts, "chat_contexts", dropped), dropped),
     native_session_lists: parseNativeSessionLists(raw.native_session_lists),
     orchestration: orchestration3,
-    scheduled_tasks: parseScheduledTasks(raw.scheduled_tasks, path3)
+    scheduled_tasks: parseScheduledTasks(raw.scheduled_tasks, dropped)
   };
 }
-function validateExternalCoordinatorIdentityCollisions(sessions, orchestration3, path3) {
+function repairExternalCoordinatorIdentityCollisions(sessions, orchestration3, dropped) {
   for (const coordinatorSession of Object.keys(orchestration3.externalCoordinators)) {
-    if (Object.values(sessions).some((session3) => session3.transport_session === coordinatorSession)) {
-      throw new Error(`state file "${path3}" contains external coordinator "${coordinatorSession}" that conflicts with a logical session`);
-    }
-    if (orchestration3.workerBindings[coordinatorSession]) {
-      throw new Error(`state file "${path3}" contains external coordinator "${coordinatorSession}" that conflicts with a worker binding`);
-    }
-    if (Object.values(orchestration3.tasks).some((task) => task.workerSession === coordinatorSession && (!isTerminalTaskStatus(task.status) || task.reviewPending !== undefined))) {
-      throw new Error(`state file "${path3}" contains external coordinator "${coordinatorSession}" that conflicts with an active task worker session`);
+    const conflict = findExternalCoordinatorConflict(coordinatorSession, sessions, orchestration3);
+    if (!conflict) {
+      continue;
     }
+    delete orchestration3.externalCoordinators[coordinatorSession];
+    dropped.push({
+      section: "orchestration.externalCoordinators",
+      key: coordinatorSession,
+      reason: `conflicts with ${conflict}; dropped (re-registered on next coordinator connect)`
+    });
+  }
+}
+function findExternalCoordinatorConflict(coordinatorSession, sessions, orchestration3) {
+  if (Object.values(sessions).some((session3) => session3.transport_session === coordinatorSession)) {
+    return "a logical session";
   }
+  if (orchestration3.workerBindings[coordinatorSession]) {
+    return "a worker binding";
+  }
+  if (Object.values(orchestration3.tasks).some((task) => task.workerSession === coordinatorSession && (!isTerminalTaskStatus(task.status) || task.reviewPending !== undefined))) {
+    return "an active task worker session";
+  }
+  return null;
 }
 function isTerminalTaskStatus(status) {
   return status === "completed" || status === "failed" || status === "cancelled";
@@ -12418,35 +12748,118 @@ function isTerminalTaskStatus(status) {
 
 class StateStore {
   path;
-  constructor(path3) {
+  options;
+  loadReport = null;
+  constructor(path3, options = {}) {
     this.path = path3;
+    this.options = options;
+  }
+  get lastLoadReport() {
+    return this.loadReport;
   }
   async load() {
+    this.loadReport = null;
+    const read = await this.readAndParse();
+    if (read.kind === "absent") {
+      return createEmptyState();
+    }
+    if (read.kind === "corrupt") {
+      return await this.recoverFromCorruptFile(read.reason);
+    }
+    if (read.dropped.length === 0) {
+      return read.state;
+    }
+    const report = { dropped: read.dropped };
+    const quarantinePath = `${this.path}.quarantine-${this.fileTimestamp()}`;
     try {
-      const content = await readFile5(this.path, "utf8");
-      if (content.trim() === "") {
-        return createEmptyState();
-      }
-      let parsed;
-      try {
-        parsed = JSON.parse(content);
-      } catch (error2) {
-        throw new Error(`failed to parse state file "${this.path}"`, {
-          cause: error2
-        });
-      }
-      return parseState(parsed, this.path);
+      const written = await (this.options.writeBackup ?? defaultWriteBackup)(quarantinePath, read.content);
+      report.quarantinePath = typeof written === "string" ? written : quarantinePath;
+    } catch (error2) {
+      report.backupError = error2 instanceof Error ? error2.message : String(error2);
+    }
+    this.loadReport = report;
+    return read.state;
+  }
+  async inspect() {
+    const read = await this.readAndParse();
+    if (read.kind === "absent") {
+      return { state: createEmptyState(), report: null };
+    }
+    if (read.kind === "corrupt") {
+      return {
+        state: createEmptyState(),
+        report: { dropped: [{ section: "file", key: this.path, reason: read.reason }] }
+      };
+    }
+    return {
+      state: read.state,
+      report: read.dropped.length > 0 ? { dropped: read.dropped } : null
+    };
+  }
+  async readAndParse() {
+    let content;
+    try {
+      content = await readFile6(this.path, "utf8");
     } catch (error2) {
       if (error2.code === "ENOENT") {
-        return createEmptyState();
+        return { kind: "absent" };
       }
       throw error2;
     }
+    if (content.trim() === "") {
+      return { kind: "absent" };
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(content);
+    } catch (error2) {
+      return {
+        kind: "corrupt",
+        reason: `invalid JSON: ${error2 instanceof Error ? error2.message : String(error2)}`
+      };
+    }
+    if (!isRecord2(parsed)) {
+      return { kind: "corrupt", reason: "top-level value is not an object" };
+    }
+    const dropped = [];
+    return { kind: "parsed", state: parseState(parsed, this.path, dropped), dropped, content };
   }
   async save(state) {
-    await writePrivateFileAtomic(this.path, JSON.stringify(state, null, 2));
+    await writePrivateFileAtomic(this.path, JSON.stringify({ version: STATE_FILE_VERSION, ...state }, null, 2));
+  }
+  fileTimestamp() {
+    const now = this.options.now?.() ?? new Date;
+    return now.toISOString().replace(/[:.]/g, "-");
+  }
+  async recoverFromCorruptFile(reason) {
+    const corruptPath = `${this.path}.corrupt-${this.fileTimestamp()}`;
+    const report = {
+      dropped: [{ section: "file", key: this.path, reason }]
+    };
+    try {
+      await rename(this.path, corruptPath);
+      report.corruptPath = corruptPath;
+    } catch (error2) {
+      report.backupError = error2 instanceof Error ? error2.message : String(error2);
+    }
+    this.loadReport = report;
+    return createEmptyState();
+  }
+}
+async function defaultWriteBackup(targetPath, content) {
+  for (let attempt = 0;; attempt += 1) {
+    const candidate = attempt === 0 ? targetPath : `${targetPath}-${attempt}`;
+    try {
+      await writeFile3(candidate, content, { encoding: "utf8", mode: 384, flag: "wx" });
+      return candidate;
+    } catch (error2) {
+      if (error2.code !== "EEXIST" || attempt >= 9) {
+        throw error2;
+      }
+    }
   }
 }
+var STATE_FILE_VERSION = 1;
 var init_state_store = __esm(() => {
   init_private_file();
   init_types();
@@ -12685,14 +13098,23 @@ class ScheduledTaskService {
       return task;
     });
   }
-  listPending() {
+  listPending(chatKey) {
+    return this.listPendingAllChats().filter((task) => task.chat_key === chatKey);
+  }
+  listPendingAllChats() {
     return Object.values(this.state.scheduled_tasks).filter((task) => task.status === "pending").sort((left, right) => left.execute_at.localeCompare(right.execute_at));
   }
-  async cancelPending(inputId) {
+  async cancelPending(inputId, chatKey) {
+    return await this.cancelPendingWhere(inputId, (task) => task.chat_key === chatKey);
+  }
+  async cancelPendingAnyChat(inputId) {
+    return await this.cancelPendingWhere(inputId, () => true);
+  }
+  async cancelPendingWhere(inputId, allowed) {
     return await this.mutate(async () => {
       const id = normalizeId(inputId);
       const task = this.state.scheduled_tasks[id];
-      if (!task || task.status !== "pending")
+      if (!task || task.status !== "pending" || !allowed(task))
         return false;
       task.status = "cancelled";
       task.cancelled_at = this.now().toISOString();
@@ -12724,7 +13146,7 @@ class ScheduledTaskService {
   async claimDueTasks() {
     return await this.mutate(async () => {
       const nowMs = this.now().getTime();
-      const due = this.listPending().filter((task) => Date.parse(task.execute_at) <= nowMs);
+      const due = this.listPendingAllChats().filter((task) => Date.parse(task.execute_at) <= nowMs);
       if (due.length === 0)
         return [];
       const at = this.now().toISOString();
@@ -12733,7 +13155,16 @@ class ScheduledTaskService {
         task.triggered_at = at;
         this.claimedInThisSession.add(task.id);
       }
-      await this.save();
+      try {
+        await this.save();
+      } catch (error2) {
+        for (const task of due) {
+          task.status = "pending";
+          delete task.triggered_at;
+          this.claimedInThisSession.delete(task.id);
+        }
+        throw error2;
+      }
       return due.map((task) => ({ ...task }));
     });
   }
@@ -12791,20 +13222,20 @@ var init_scheduled_service = () => {};
 
 // src/plugins/plugin-home.ts
 import { readFileSync as readFileSync2 } from "node:fs";
-import { copyFile, mkdir as mkdir6, readFile as readFile6, writeFile as writeFile4 } from "node:fs/promises";
+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 dirname6, join as join6 } from "node:path";
+import { dirname as dirname4, join as join6 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function resolveCoreRoot() {
   try {
-    let dir = dirname6(fileURLToPath2(import.meta.url));
+    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"));
         if (pkg.name && CORE_ROOT_NAMES.includes(pkg.name))
           return dir;
       } catch {}
-      const parent = dirname6(dir);
+      const parent = dirname4(dir);
       if (parent === dir)
         break;
       dir = parent;
@@ -12822,7 +13253,7 @@ async function ensureCoreResolution(pluginHome) {
   for (const name of SHIM_SPECIFIERS) {
     const targetDir = join6(pluginHome, "node_modules", name);
     const dstJs = join6(targetDir, "plugin-api.js");
-    await mkdir6(targetDir, { recursive: true });
+    await mkdir4(targetDir, { recursive: true });
     try {
       await copyFile(srcJs, dstJs);
     } catch (error2) {
@@ -12865,7 +13296,7 @@ async function normalizePluginHomeManifest(pluginHome) {
   const manifestPath = join6(pluginHome, "package.json");
   let raw;
   try {
-    raw = await readFile6(manifestPath, "utf8");
+    raw = await readFile7(manifestPath, "utf8");
   } catch {
     return false;
   }
@@ -12883,7 +13314,7 @@ async function normalizePluginHomeManifest(pluginHome) {
   return true;
 }
 async function ensurePluginHome(pluginHome) {
-  await mkdir6(pluginHome, { recursive: true, mode: 448 });
+  await mkdir4(pluginHome, { recursive: true, mode: 448 });
   await writeFile4(join6(pluginHome, "package.json"), JSON.stringify({ private: true, type: "module" }, null, 2) + `
 `, { flag: "wx" }).catch((error2) => {
     if (error2.code !== "EEXIST")
@@ -15499,7 +15930,7 @@ function createConversationExecutor() {
 var DEFAULT_SESSION_KEY = "__chat__";
 
 // src/channels/media-store.ts
-import { access as access2, mkdir as mkdir7, readdir, rm as rm5, stat, writeFile as writeFile5 } from "node:fs/promises";
+import { access as access2, mkdir as mkdir5, readdir, rm as rm5, stat, writeFile as writeFile5 } from "node:fs/promises";
 import path7 from "node:path";
 
 class RuntimeMediaStore {
@@ -15517,7 +15948,7 @@ class RuntimeMediaStore {
     const safeMessageId = safePathSegment(input.messageId || "message");
     const baseFileName = sanitizeMediaFileName(input.fileName ?? "attachment", input.mimeType);
     const dir = path7.join(this.rootDir, input.channelId, safeChatKey, safeMessageId);
-    await mkdir7(dir, { recursive: true });
+    await mkdir5(dir, { recursive: true, mode: 448 });
     const resolvedRoot = path7.resolve(this.rootDir);
     const resolvedFile = path7.resolve(path7.join(dir, await uniqueFileName(dir, baseFileName)));
     if (!isPathInside(resolvedFile, resolvedRoot)) {
@@ -16906,15 +17337,6 @@ async function handleSlashCommand(content, ctx, receivedAt, eventTimestamp) {
         await drainPendingFinalForJx(ctx);
         return { handled: true };
       }
-      case "/logout": {
-        if (listWeixinAccountIds().length === 0) {
-          await sendReply(ctx, t().weixin.noAccountsLoggedIn);
-          return { handled: true };
-        }
-        clearAllWeixinAccounts();
-        await sendReply(ctx, t().weixin.logoutSuccess);
-        return { handled: true };
-      }
       default:
         return { handled: false };
     }
@@ -16927,7 +17349,6 @@ async function handleSlashCommand(content, ctx, receivedAt, eventTimestamp) {
   }
 }
 var init_slash_commands = __esm(() => {
-  init_accounts();
   init_logger();
   init_i18n();
   init_final_heads_up();
@@ -16943,14 +17364,14 @@ function normalizeMediaArray(media) {
 }
 
 // src/logging/rotating-file-writer.ts
-import { readdir as readdir2, rename, rm as rm6, stat as stat2 } from "node:fs/promises";
-import { basename, dirname as dirname7, join as join8 } from "node:path";
+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";
 async function rotateIfNeeded(filePath, incomingSize, maxSizeBytes, maxFiles) {
   let currentSize = 0;
   try {
     currentSize = (await stat2(filePath)).size;
   } catch (error2) {
-    if (!isMissingFileError2(error2)) {
+    if (!isMissingFileError3(error2)) {
       throw error2;
     }
   }
@@ -16968,24 +17389,24 @@ async function rotateIfNeeded(filePath, incomingSize, maxSizeBytes, maxFiles) {
   for (let index = maxFiles - 1;index >= 1; index -= 1) {
     const source = `${filePath}.${index}`;
     try {
-      await rename(source, `${filePath}.${index + 1}`);
+      await rename2(source, `${filePath}.${index + 1}`);
     } catch (error2) {
-      if (!isMissingFileError2(error2)) {
+      if (!isMissingFileError3(error2)) {
         throw error2;
       }
     }
   }
-  await rename(filePath, `${filePath}.1`);
+  await rename2(filePath, `${filePath}.1`);
 }
 async function cleanupExpiredRotatedLogs(filePath, retentionDays, now) {
-  const parentDir = dirname7(filePath);
+  const parentDir = dirname5(filePath);
   const prefix = `${basename(filePath)}.`;
   const cutoff = now().getTime() - retentionDays * 24 * 60 * 60 * 1000;
   let files = [];
   try {
     files = await readdir2(parentDir);
   } catch (error2) {
-    if (isMissingFileError2(error2)) {
+    if (isMissingFileError3(error2)) {
       return;
     }
     throw error2;
@@ -16995,23 +17416,31 @@ async function cleanupExpiredRotatedLogs(filePath, retentionDays, now) {
       continue;
     }
     const candidate = join8(parentDir, file);
-    const details = await stat2(candidate);
+    let details;
+    try {
+      details = await stat2(candidate);
+    } catch (error2) {
+      if (isMissingFileError3(error2)) {
+        continue;
+      }
+      throw error2;
+    }
     if (details.mtime.getTime() < cutoff) {
       await rm6(candidate, { force: true });
     }
   }
 }
-function isMissingFileError2(error2) {
+function isMissingFileError3(error2) {
   return typeof error2 === "object" && error2 !== null && "code" in error2 && error2.code === "ENOENT";
 }
 var init_rotating_file_writer = () => {};
 
 // src/perf/perf-log-writer.ts
 import { appendFile as fsAppendFile, mkdir as fsMkdir } from "node:fs/promises";
-import { dirname as dirname8 } from "node:path";
+import { dirname as dirname6 } from "node:path";
 function createPerfLogWriter(options) {
   const append = options.appendImpl ?? ((p, d) => fsAppendFile(p, d, "utf8"));
-  const mkdir8 = options.mkdirImpl ?? ((p, o) => fsMkdir(p, o).then(() => {
+  const mkdir6 = options.mkdirImpl ?? ((p, o) => fsMkdir(p, o).then(() => {
     return;
   }));
   const now = options.now ?? (() => new Date);
@@ -17058,7 +17487,7 @@ function createPerfLogWriter(options) {
       return;
     const data = batch.join("");
     try {
-      await mkdir8(dirname8(options.filePath), { recursive: true });
+      await mkdir6(dirname6(options.filePath), { recursive: true, mode: 448 });
       await rotateIfNeeded(options.filePath, Buffer.byteLength(data), options.maxSizeBytes, options.maxFiles);
       await append(options.filePath, data);
       consecutiveFailures = 0;
@@ -17589,13 +18018,39 @@ async function handleWeixinMessageTurn(full, deps) {
             deps.errLog(`weixin.final.dropped reason=backgrounded_no_store kind=text chatKey=${to}`);
           } else {
             const rawChunks = chunkFinalText(finalText, MAX_FINAL_CHUNK_BYTES);
+            const sendAllParkedNotice = async (count) => {
+              try {
+                await sendMessageWeixin({
+                  to,
+                  text: t().misc.finalAllParked(count),
+                  opts: { baseUrl: deps.baseUrl, token: deps.token, contextToken }
+                });
+              } catch (noticeErr) {
+                deps.errLog(`weixin.final.parked_notice_failed chatKey=${to} err=${String(noticeErr)}`);
+              }
+            };
+            const buildPendingChunk = (text, seq, total) => {
+              const entry = { text, seq, total };
+              if (contextToken !== undefined)
+                entry.contextToken = contextToken;
+              if (deps.accountId !== undefined)
+                entry.accountId = deps.accountId;
+              return entry;
+            };
             if (rawChunks.length > 0) {
               const total = rawChunks.length;
               if (total === 1) {
                 const reserved = deps.reserveFinal ? deps.reserveFinal(to) : true;
                 if (!reserved) {
-                  finalDropped = true;
-                  deps.errLog(`weixin.final.dropped reason=quota_exhausted kind=text chatKey=${to}`);
+                  if (deps.enqueuePendingFinal) {
+                    deps.enqueuePendingFinal(to, [buildPendingChunk(rawChunks[0], 1, 1)]);
+                    finalChunksPending = 1;
+                    deps.errLog(`weixin.final.parked reason=quota_exhausted kind=text chatKey=${to}`);
+                    await sendAllParkedNotice(1);
+                  } else {
+                    finalDropped = true;
+                    deps.errLog(`weixin.final.dropped reason=quota_exhausted kind=text chatKey=${to}`);
+                  }
                 } else {
                   await sendMessageWeixin({
                     to,
@@ -17652,16 +18107,11 @@ ${buildFinalHeadsUp({
                 const restToPark = prefixed.slice(sent);
                 finalChunksPending = restToPark.length;
                 if (restToPark.length > 0 && deps.enqueuePendingFinal) {
-                  const pending = restToPark.map((text, idx) => {
-                    const seq = sent + idx + 1;
-                    const entry = { text, seq, total };
-                    if (contextToken !== undefined)
-                      entry.contextToken = contextToken;
-                    if (deps.accountId !== undefined)
-                      entry.accountId = deps.accountId;
-                    return entry;
-                  });
+                  const pending = restToPark.map((text, idx) => buildPendingChunk(text, sent + idx + 1, total));
                   deps.enqueuePendingFinal(to, pending);
+                  if (sent === 0) {
+                    await sendAllParkedNotice(restToPark.length);
+                  }
                 }
               }
             }
@@ -17857,7 +18307,7 @@ function shouldFetchTypingConfig(textBody) {
   const command = parseSlashCommand(textBody);
   if (!command)
     return true;
-  return !["/cancel", "/stop", "/jx", "/echo", "/toggle-debug", "/logout"].includes(command);
+  return !["/cancel", "/stop", "/jx", "/echo", "/toggle-debug"].includes(command);
 }
 async function monitorWeixinProvider(opts) {
   const {
@@ -18580,7 +19030,7 @@ ${buildFinalHeadsUp({
     let sent = 0;
     for (let index = 0;index < wave.length; index += 1) {
       if (!deps.reserveFinal(quotaKey)) {
-        await deps.logger.info("scheduled.final_dropped", "scheduled turn final response dropped due to quota", { chatKey: input.chatKey, reason: "quota_exhausted", chunk: index + 1, total });
+        await deps.logger.info(deps.enqueuePendingFinal ? "scheduled.final_parked" : "scheduled.final_dropped", deps.enqueuePendingFinal ? "scheduled turn final response parked due to quota" : "scheduled turn final response dropped due to quota", { chatKey: input.chatKey, reason: "quota_exhausted", chunk: index + 1, total });
         break;
       }
       const delivered = await sendTextViaAvailableAccount(wave[index], "scheduled.final_send_failed");
@@ -18589,7 +19039,7 @@ ${buildFinalHeadsUp({
       sent += 1;
     }
     const restToPark = chunks.slice(sent);
-    if (total > 1 && restToPark.length > 0 && deps.enqueuePendingFinal) {
+    if (restToPark.length > 0 && deps.enqueuePendingFinal) {
       const pending = restToPark.map((text, index) => {
         const entry = { text, seq: sent + index + 1, total };
         if (deliveryContextToken)
@@ -18599,6 +19049,12 @@ ${buildFinalHeadsUp({
         return entry;
       });
       deps.enqueuePendingFinal(quotaKey, pending);
+      if (sent === 0) {
+        const noticeDelivered = await sendTextViaAvailableAccount(t().misc.finalAllParked(restToPark.length), "scheduled.final_parked_notice_failed");
+        if (!noticeDelivered) {
+          await deps.logger.info("scheduled.final_parked_notice_failed", "scheduled parked-final notice could not be delivered", { chatKey: input.chatKey, parked: restToPark.length });
+        }
+      }
     }
   }
   async function sendTextViaAvailableAccount(text, errorEvent) {
@@ -18636,8 +19092,8 @@ var init_scheduled_turn = __esm(() => {
 });
 
 // src/weixin/monitor/consumer-lock.ts
-import { mkdir as mkdir8, open as open3, readFile as readFile7, rm as rm7 } from "node:fs/promises";
-import { dirname as dirname9, join as join9 } from "node:path";
+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 { homedir as homedir4 } from "node:os";
 function createWeixinConsumerLock(options = {}) {
   const lockFilePath = options.lockFilePath ?? join9(coreHomeDir(homedir4()), "runtime", "weixin-consumer.lock.json");
@@ -18645,7 +19101,7 @@ function createWeixinConsumerLock(options = {}) {
   const onDiagnostic = options.onDiagnostic;
   return {
     async acquire(meta2) {
-      await mkdir8(dirname9(lockFilePath), { recursive: true });
+      await mkdir6(dirname7(lockFilePath), { recursive: true, mode: 448 });
       while (true) {
         try {
           const handle = await open3(lockFilePath, "wx");
@@ -18718,7 +19174,7 @@ function createWeixinConsumerLock(options = {}) {
 }
 async function loadLockMetadata(path14) {
   try {
-    const raw = await readFile7(path14, "utf8");
+    const raw = await readFile8(path14, "utf8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed.pid !== "number" || !parsed.mode || !parsed.configPath || !parsed.statePath) {
       return null;
@@ -18783,6 +19239,13 @@ class WeixinChannel {
   logout() {
     logout();
   }
+  stop() {
+    this.agent = null;
+    this.quota = null;
+    this.logger = null;
+    this.markDelivered = null;
+    this.markFailed = null;
+  }
   createConsumerLock(options) {
     return createWeixinConsumerLock({
       ...options?.lockFilePath ? { lockFilePath: options.lockFilePath } : {},
@@ -19363,8 +19826,8 @@ var init_bootstrap = __esm(() => {
 });
 
 // src/logging/app-logger.ts
-import { appendFile, chmod as chmod2, mkdir as mkdir9 } from "node:fs/promises";
-import { dirname as dirname11 } from "node:path";
+import { appendFile, chmod as chmod3, mkdir as mkdir7 } from "node:fs/promises";
+import { dirname as dirname9 } from "node:path";
 function createNoopAppLogger() {
   return {
     debug: async () => {},
@@ -19378,6 +19841,7 @@ function createAppLogger(options) {
   const now = options.now ?? (() => new Date);
   let writeChain = Promise.resolve();
   let modeEnsured = false;
+  let writeErrorLatched = false;
   return {
     debug: async (event, message, context) => {
       await enqueueWrite("debug", event, message, context);
@@ -19389,14 +19853,21 @@ function createAppLogger(options) {
       await enqueueWrite("error", event, message, context);
     },
     cleanup: async () => {
-      await cleanupExpiredRotatedLogs(options.filePath, options.retentionDays, now);
+      try {
+        await cleanupExpiredRotatedLogs(options.filePath, options.retentionDays, now);
+      } catch {}
     },
     flush: async () => {
       await writeChain;
     }
   };
   function enqueueWrite(level, event, message, context = {}) {
-    const writePromise = writeChain.catch(() => {}).then(() => writeLog2(level, event, message, context));
+    const writePromise = writeChain.then(() => writeLog2(level, event, message, context)).catch((error2) => {
+      if (!writeErrorLatched) {
+        writeErrorLatched = true;
+        console.error("[xacpx] app-logger: log file write failed — further write errors will be suppressed.", error2 instanceof Error ? error2.message : String(error2));
+      }
+    });
     writeChain = writePromise;
     return writePromise;
   }
@@ -19405,13 +19876,14 @@ function createAppLogger(options) {
       return;
     }
     const line = formatLogLine(now(), level, event, message, context);
-    await mkdir9(dirname11(options.filePath), { recursive: true });
+    await mkdir7(dirname9(options.filePath), { recursive: true, mode: 448 });
     if (!modeEnsured) {
       modeEnsured = true;
-      await chmod2(options.filePath, 384).catch(() => {});
+      await chmod3(options.filePath, 384).catch(() => {});
     }
     await rotateIfNeeded(options.filePath, Buffer.byteLength(line), options.maxSizeBytes, options.maxFiles);
     await appendFile(options.filePath, line, { encoding: "utf8", mode: 384 });
+    writeErrorLatched = false;
   }
 }
 function formatLogLine(time3, level, event, message, context) {
@@ -19440,7 +19912,7 @@ var init_app_logger = __esm(() => {
 });
 
 // src/transport/acpx-session-index.ts
-import { readFile as readFile11 } from "node:fs/promises";
+import { readFile as readFile12 } from "node:fs/promises";
 import { homedir as homedir5 } from "node:os";
 import { resolve as resolve2 } from "node:path";
 async function resolveSessionAgentCommandFromIndex(session3) {
@@ -19449,7 +19921,7 @@ async function resolveSessionAgentCommandFromIndex(session3) {
     return;
   }
   try {
-    const raw = await readFile11(resolve2(home, ".acpx", "sessions", "index.json"), "utf8");
+    const raw = await readFile12(resolve2(home, ".acpx", "sessions", "index.json"), "utf8");
     const parsed = JSON.parse(raw);
     const targetCwd = resolve2(session3.cwd);
     const match = parsed.entries?.find((entry) => entry.name === session3.transportSession && entry.cwd === targetCwd && typeof entry.agentCommand === "string" && entry.agentCommand.trim().length > 0);
@@ -19631,7 +20103,9 @@ function parseCommand(input) {
   if (!trimmed.startsWith("/")) {
     return { kind: "prompt", text: trimmed };
   }
-  const parts = tokenizeCommand(trimmed);
+  const tokens = tokenizeCommand(trimmed);
+  const parts = tokens.map((token) => token.value);
+  const rawTail = (index) => index < tokens.length ? trimmed.slice(tokens[index]?.start ?? 0) : "";
   const command = normalizeCommand(parts[0] ?? "");
   if (command === "/help" && parts.length === 1)
     return { kind: "help" };
@@ -19740,7 +20214,7 @@ function parseCommand(input) {
     return { kind: "invalid", text: trimmed, recognizedCommand: "/session" };
   }
   if (command === "/group" && parts[1] === "new" && parts.length > 2) {
-    const title = parts.slice(2).join(" ");
+    const title = rawTail(2);
     if (title.trim().length > 0) {
       return { kind: "group.new", title };
     }
@@ -19764,7 +20238,7 @@ function parseCommand(input) {
       }
       break;
     }
-    const task = parts.slice(index).join(" ");
+    const task = rawTail(index);
     if (groupId.trim().length > 0 && targetAgent.trim().length > 0 && task.trim().length > 0) {
       return {
         kind: "group.delegate",
@@ -19818,7 +20292,7 @@ function parseCommand(input) {
     return { kind: "agent.rm", name: parts[2] };
   }
   if ((command === "/delegate" || command === "/dg") && parts[1]) {
-    const parsedDelegate = parseDelegateRequest(parts);
+    const parsedDelegate = parseDelegateRequest(parts, rawTail);
     if (parsedDelegate) {
       return parsedDelegate;
     }
@@ -19846,7 +20320,11 @@ function parseCommand(input) {
     if (parts[1] === "cancel" && parts[2] && parts.length === 3) {
       return { kind: "later.cancel", id: parts[2] };
     }
-    return { kind: "later.create", tokens: parts.slice(1) };
+    return {
+      kind: "later.create",
+      tokens: parts.slice(1),
+      tails: tokens.slice(1).map((_, index) => rawTail(index + 1))
+    };
   }
   if (command === "/workspace" && parts[1] === "new" && parts[2]) {
     const name = parts[2];
@@ -20099,17 +20577,18 @@ function readNativeAttachCommand(parts, identifierIndex) {
   return { kind: "session.native.attach", identifier };
 }
 function normalizeCommand(command) {
-  if (command === "/ss")
+  const lowered = command.toLowerCase();
+  if (lowered === "/ss")
     return "/session";
-  if (command === "/ws")
+  if (lowered === "/ws")
     return "/workspace";
-  if (command === "/pm")
+  if (lowered === "/pm")
     return "/permission";
-  if (command === "/stop")
+  if (lowered === "/stop")
     return "/cancel";
-  if (command === "/lt")
+  if (lowered === "/lt")
     return "/later";
-  return command;
+  return lowered;
 }
 function isRecognizedCommand(command) {
   return isKnownXacpxCommandPrefix(command);
@@ -20132,31 +20611,41 @@ function toNonInteractivePermission(value) {
 function tokenizeCommand(input) {
   const tokens = [];
   let current = "";
-  let quote = null;
+  let start2 = -1;
+  let closingQuote = null;
+  let offset = 0;
   for (const char of input) {
-    if (quote) {
-      if (char === quote) {
-        quote = null;
+    const charStart = offset;
+    offset += char.length;
+    if (closingQuote) {
+      if (char === closingQuote) {
+        closingQuote = null;
       } else {
         current += char;
       }
       continue;
     }
-    if (char === '"' || char === "'") {
-      quote = char;
+    const close = QUOTE_PAIRS[char];
+    if (close) {
+      if (start2 === -1)
+        start2 = charStart;
+      closingQuote = close;
       continue;
     }
     if (/\s/.test(char)) {
       if (current.length > 0) {
-        tokens.push(current);
+        tokens.push({ value: current, start: start2 });
         current = "";
       }
+      start2 = -1;
       continue;
     }
+    if (start2 === -1)
+      start2 = charStart;
     current += char;
   }
   if (current.length > 0) {
-    tokens.push(current);
+    tokens.push({ value: current, start: start2 });
   }
   return tokens;
 }
@@ -20199,7 +20688,7 @@ function parseListFilterFlags(parts, validStatuses) {
   }
   return { filter, ok: true };
 }
-function parseDelegateRequest(parts) {
+function parseDelegateRequest(parts, rawTail) {
   const targetAgent = parts[1];
   if (!targetAgent) {
     return null;
@@ -20227,7 +20716,7 @@ function parseDelegateRequest(parts) {
     }
     break;
   }
-  const task = parts.slice(index).join(" ");
+  const task = rawTail(index);
   if (task.trim().length === 0) {
     return null;
   }
@@ -20239,9 +20728,16 @@ function parseDelegateRequest(parts) {
     task
   };
 }
-var TASK_STATUS_VALUES, GROUP_STATUS_VALUES;
+var QUOTE_PAIRS, TASK_STATUS_VALUES, GROUP_STATUS_VALUES;
 var init_parse_command = __esm(() => {
   init_command_list();
+  QUOTE_PAIRS = {
+    '"': '"',
+    "'": "'",
+    "“": "”",
+    "‘": "’",
+    "＂": "＂"
+  };
   TASK_STATUS_VALUES = [
     "pending",
     "needs_confirmation",
@@ -20254,7 +20750,50 @@ var init_parse_command = __esm(() => {
 });
 
 // src/commands/command-policy.ts
+function isInternalScheduledTurn(metadata) {
+  return Boolean(metadata?.scheduledSessionAlias || metadata?.scheduledSessionDescriptor);
+}
+function resolveChannelOwnerIds(config4, channel) {
+  if (!config4 || !channel) {
+    return;
+  }
+  let configured = false;
+  const ids = new Set;
+  if (config4.channel?.type === channel && config4.channel.ownerIds) {
+    configured = true;
+    for (const id of config4.channel.ownerIds)
+      ids.add(id);
+  }
+  for (const entry of config4.channels ?? []) {
+    if ((entry.type === channel || entry.id === channel) && entry.ownerIds) {
+      configured = true;
+      for (const id of entry.ownerIds)
+        ids.add(id);
+    }
+  }
+  return configured ? [...ids] : undefined;
+}
+function withEffectiveOwner(metadata, config4) {
+  if (!metadata?.channel || isInternalScheduledTurn(metadata)) {
+    return metadata;
+  }
+  const ownerIds = resolveChannelOwnerIds(config4, metadata.channel);
+  if (ownerIds === undefined) {
+    return metadata;
+  }
+  const isOwner = metadata.isOwner === true || typeof metadata.senderId === "string" && ownerIds.includes(metadata.senderId);
+  return { ...metadata, isOwner };
+}
 function authorizeCommandForChat(command, metadata) {
+  if (metadata?.channel && !isInternalScheduledTurn(metadata) && metadata.chatType !== "direct" && metadata.chatType !== "group") {
+    if (GROUP_PUBLIC_COMMAND_KINDS.has(command.kind)) {
+      return { allowed: true };
+    }
+    return {
+      allowed: false,
+      reason: "chat-type-missing"
+    };
+  }
   if (metadata?.chatType !== "group") {
     return { allowed: true };
   }
@@ -20269,7 +20808,14 @@ function authorizeCommandForChat(command, metadata) {
     reason: "group-owner-required"
   };
 }
-function renderCommandAccessDenied(command) {
+function renderCommandAccessDenied(command, reason) {
+  if (reason === "chat-type-missing") {
+    return [
+      `⚠️ ${renderCommandLabel(command)}${t().misc.commandAccessDeniedChatTypeMissingSuffix}`,
+      t().misc.commandAccessDeniedChatTypeMissingHint
+    ].join(`
+`);
+  }
   return [
     `⚠️ ${renderCommandLabel(command)}${t().misc.commandAccessDeniedSuffix}`,
     t().misc.commandAccessDeniedHint
@@ -20395,13 +20941,18 @@ async function handlePermissionModeSet(context, mode) {
     return { text: p.noWritableConfig };
   }
   const previous = cloneAppConfig(context.config);
+  const previousRaw = await context.configStore.getRawValue(["transport", "permissionMode"]);
   const updated = await context.configStore.updateTransport({
     permissionMode: mode
   });
   try {
     await context.transport.updatePermissionPolicy?.(updated.transport);
   } catch (error2) {
-    await context.configStore.save(previous);
+    if (previousRaw.present) {
+      await context.configStore.setRawValue(["transport", "permissionMode"], previousRaw.value);
+    } else {
+      await context.configStore.unsetRawValue(["transport", "permissionMode"]);
+    }
     context.replaceConfig(previous);
     throw error2;
   }
@@ -20417,13 +20968,18 @@ async function handlePermissionAutoSet(context, policy) {
     return { text: p.noWritableConfig };
   }
   const previous = cloneAppConfig(context.config);
+  const previousRaw = await context.configStore.getRawValue(["transport", "nonInteractivePermissions"]);
   const updated = await context.configStore.updateTransport({
     nonInteractivePermissions: policy
   });
   try {
     await context.transport.updatePermissionPolicy?.(updated.transport);
   } catch (error2) {
-    await context.configStore.save(previous);
+    if (previousRaw.present) {
+      await context.configStore.setRawValue(["transport", "nonInteractivePermissions"], previousRaw.value);
+    } else {
+      await context.configStore.unsetRawValue(["transport", "nonInteractivePermissions"]);
+    }
     context.replaceConfig(previous);
     throw error2;
   }
@@ -20473,99 +21029,83 @@ async function handleConfigSet(context, path14, rawValue) {
   if (!context.config || !context.configStore) {
     return { text: c.noWritableConfig };
   }
-  const previous = cloneAppConfig(context.config);
-  const updated = cloneAppConfig(context.config);
-  const result = applySupportedConfigUpdate(updated, path14, rawValue);
-  if ("error" in result) {
-    return { text: result.error };
+  const plan = planSupportedConfigUpdate(context.config, path14, rawValue);
+  if ("error" in plan) {
+    return { text: plan.error };
   }
-  await context.configStore.save(updated);
+  const previousConfig = cloneAppConfig(context.config);
+  const previousRaw = await context.configStore.getRawValue(plan.rawPath);
+  const updated = await context.configStore.setRawValue(plan.rawPath, plan.value);
   if (path14 === "transport.permissionMode" || path14 === "transport.nonInteractivePermissions" || path14 === "transport.permissionPolicy") {
     try {
       await context.transport.updatePermissionPolicy?.(updated.transport);
     } catch (error2) {
-      await context.configStore.save(previous);
-      context.replaceConfig(previous);
+      if (previousRaw.present) {
+        await context.configStore.setRawValue(plan.rawPath, previousRaw.value);
+      } else {
+        await context.configStore.unsetRawValue(plan.rawPath);
+      }
+      context.replaceConfig(previousConfig);
       throw error2;
     }
   }
   context.replaceConfig(updated);
-  return { text: c.updated(path14, result.renderedValue) };
+  return { text: c.updated(path14, plan.renderedValue) };
 }
-function applySupportedConfigUpdate(config4, path14, rawValue) {
+function planSupportedConfigUpdate(config4, path14, rawValue) {
   const c = t().config;
   switch (path14) {
     case "language": {
       if (!isLocale(rawValue))
         return { error: c.languageInvalid };
-      config4.language = rawValue;
-      return { renderedValue: rawValue };
+      return { rawPath: ["language"], value: rawValue, renderedValue: rawValue };
     }
     case "transport.type": {
       const parsed = parseEnum(rawValue, ["acpx-cli", "acpx-bridge"]);
       if (!parsed)
         return { error: c.transportTypeInvalid };
-      config4.transport.type = parsed;
-      return { renderedValue: parsed };
+      return { rawPath: ["transport", "type"], value: parsed, renderedValue: parsed };
     }
     case "transport.command":
       if (!rawValue.trim())
         return { error: c.transportCommandEmpty };
-      config4.transport.command = rawValue;
-      return { renderedValue: rawValue };
+      return { rawPath: ["transport", "command"], value: rawValue, renderedValue: rawValue };
     case "transport.sessionInitTimeoutMs": {
       const parsed = parsePositiveNumber(rawValue, "transport.sessionInitTimeoutMs");
       if ("error" in parsed)
         return parsed;
-      config4.transport.sessionInitTimeoutMs = parsed.value;
-      return { renderedValue: String(parsed.value) };
+      return { rawPath: ["transport", "sessionInitTimeoutMs"], value: parsed.value, renderedValue: String(parsed.value) };
     }
     case "transport.permissionMode": {
       const parsed = parseEnum(rawValue, ["approve-all", "approve-reads", "deny-all"]);
       if (!parsed)
         return { error: c.transportPermissionModeInvalid };
-      config4.transport.permissionMode = parsed;
-      return { renderedValue: parsed };
+      return { rawPath: ["transport", "permissionMode"], value: parsed, renderedValue: parsed };
     }
     case "transport.nonInteractivePermissions": {
       const parsed = parseEnum(rawValue, ["deny", "fail"]);
       if (!parsed)
         return { error: c.transportNonInteractiveInvalid };
-      config4.transport.nonInteractivePermissions = parsed;
-      return { renderedValue: parsed };
+      return { rawPath: ["transport", "nonInteractivePermissions"], value: parsed, renderedValue: parsed };
     }
     case "transport.permissionPolicy":
       if (!rawValue.trim())
         return { error: c.transportPermissionPolicyEmpty };
-      config4.transport.permissionPolicy = rawValue;
-      return { renderedValue: rawValue };
+      return { rawPath: ["transport", "permissionPolicy"], value: rawValue, renderedValue: rawValue };
     case "logging.level": {
       const parsed = parseEnum(rawValue, ["error", "info", "debug"]);
       if (!parsed)
         return { error: c.loggingLevelInvalid };
-      config4.logging.level = parsed;
-      return { renderedValue: parsed };
-    }
-    case "logging.maxSizeBytes": {
-      const parsed = parsePositiveNumber(rawValue, "logging.maxSizeBytes");
-      if ("error" in parsed)
-        return parsed;
-      config4.logging.maxSizeBytes = parsed.value;
-      return { renderedValue: String(parsed.value) };
-    }
-    case "logging.maxFiles": {
-      const parsed = parsePositiveNumber(rawValue, "logging.maxFiles");
-      if ("error" in parsed)
-        return parsed;
-      config4.logging.maxFiles = parsed.value;
-      return { renderedValue: String(parsed.value) };
+      return { rawPath: ["logging", "level"], value: parsed, renderedValue: parsed };
     }
+    case "logging.maxSizeBytes":
+    case "logging.maxFiles":
     case "logging.retentionDays": {
-      const parsed = parsePositiveNumber(rawValue, "logging.retentionDays");
+      const field = path14.slice("logging.".length);
+      const parsed = parsePositiveNumber(rawValue, path14);
       if ("error" in parsed)
         return parsed;
-      config4.logging.retentionDays = parsed.value;
-      return { renderedValue: String(parsed.value) };
+      return { rawPath: ["logging", field], value: parsed.value, renderedValue: String(parsed.value) };
     }
     case "channel.type":
       return { error: c.channelTypeDisabled };
@@ -20573,15 +21113,15 @@ function applySupportedConfigUpdate(config4, path14, rawValue) {
       const parsed = parseEnum(rawValue, ["stream", "final", "verbose"]);
       if (!parsed)
         return { error: c.channelReplyModeInvalid };
-      config4.channel.replyMode = parsed;
-      return { renderedValue: parsed };
+      return { rawPath: ["channel", "replyMode"], value: parsed, renderedValue: parsed };
     }
     case "wechat.replyMode": {
       const parsed = parseEnum(rawValue, ["stream", "final", "verbose"]);
       if (!parsed)
         return { error: c.wechatReplyModeInvalid };
-      config4.channel.replyMode = parsed;
       return {
+        rawPath: ["channel", "replyMode"],
+        value: parsed,
         renderedValue: c.wechatReplyModeMapped(parsed)
       };
     }
@@ -20589,42 +21129,30 @@ function applySupportedConfigUpdate(config4, path14, rawValue) {
   const agentMatch = path14.match(/^agents\.([^.]+)\.(driver|command)$/);
   if (agentMatch) {
     const [, name, field] = agentMatch;
-    if (!name || !field) {
+    if (!name || !field || isPrototypePollutingKey(name)) {
       return { error: c.pathNotSupported(path14) };
     }
-    const agent3 = config4.agents[name];
-    if (!agent3) {
+    if (!Object.hasOwn(config4.agents, name)) {
       return { error: c.agentNotFound(name) };
     }
     if (!rawValue.trim()) {
       return { error: c.fieldEmpty(path14) };
     }
-    if (field === "driver") {
-      agent3.driver = rawValue;
-    } else {
-      agent3.command = rawValue;
-    }
-    return { renderedValue: rawValue };
+    return { rawPath: ["agents", name, field], value: rawValue, renderedValue: rawValue };
   }
   const workspaceMatch = path14.match(/^workspaces\.([^.]+)\.(cwd|description)$/);
   if (workspaceMatch) {
     const [, name, field] = workspaceMatch;
-    if (!name || !field) {
+    if (!name || !field || isPrototypePollutingKey(name)) {
       return { error: c.pathNotSupported(path14) };
     }
-    const workspace3 = config4.workspaces[name];
-    if (!workspace3) {
+    if (!Object.hasOwn(config4.workspaces, name)) {
       return { error: c.workspaceNotFound(name) };
     }
     if (!rawValue.trim()) {
       return { error: c.fieldEmpty(path14) };
     }
-    if (field === "cwd") {
-      workspace3.cwd = rawValue;
-    } else {
-      workspace3.description = rawValue;
-    }
-    return { renderedValue: rawValue };
+    return { rawPath: ["workspaces", name, field], value: rawValue, renderedValue: rawValue };
   }
   const channelMatch = path14.match(/^channels\.([^.]+)\.replyMode$/);
   if (channelMatch) {
@@ -20640,11 +21168,21 @@ function applySupportedConfigUpdate(config4, path14, rawValue) {
     if (!parsed) {
       return { error: c.channelRuntimeReplyModeInvalid(id) };
     }
-    channel.replyMode = parsed;
-    return { renderedValue: parsed };
+    return {
+      rawPath: [
+        "channels",
+        { id, createWith: { id: channel.id, type: channel.type, enabled: channel.enabled } },
+        "replyMode"
+      ],
+      value: parsed,
+      renderedValue: parsed
+    };
   }
   return { error: c.pathNotSupported(path14) };
 }
+function isPrototypePollutingKey(key) {
+  return key === "__proto__" || key === "constructor" || key === "prototype";
+}
 function parseEnum(value, allowed) {
   return allowed.includes(value) ? value : null;
 }
@@ -21186,6 +21724,10 @@ async function handleSessions(context, chatKey) {
 async function handleSessionNew(context, chatKey, alias, agent3, workspace3) {
   const channelId = getChannelIdFromChatKey(chatKey);
   const internalAlias = scopeDisplayAliasToInternal(channelId, alias);
+  const existing = context.sessions.getResolvedSessionByInternalAlias(internalAlias);
+  if (existing) {
+    return { text: t().session.sessionAlreadyExists(alias, existing.agent, existing.workspace) };
+  }
   const session3 = context.lifecycle.resolveSession(internalAlias, agent3, workspace3, `${workspace3}:${internalAlias}`);
   const releaseTransportReservation = await context.lifecycle.reserveTransportSession(session3.transportSession);
   try {
@@ -21456,7 +21998,9 @@ async function handleSessionRemove(context, chatKey, alias) {
     }
   }
   const sharedAliasCount = context.sessions.countAliasesSharingTransport(session3.transportSession, internalAlias);
+  const wasCurrentInThisChat = context.sessions.peekCurrentSessionAlias(chatKey) === internalAlias;
   const { wasActive } = await context.sessions.removeSession(internalAlias);
+  const promotedAlias = wasCurrentInThisChat ? context.sessions.peekCurrentSessionAlias(chatKey) || undefined : undefined;
   let orchestrationPurgeWarning;
   if (context.orchestration) {
     try {
@@ -21494,7 +22038,7 @@ async function handleSessionRemove(context, chatKey, alias) {
   const s = t().session;
   const lines = [s.sessionRemoved(alias)];
   if (wasActive) {
-    lines.push(s.sessionRemovedWasActive);
+    lines.push(promotedAlias ? s.sessionRemovedWasActivePromoted(toDisplaySessionAlias(promotedAlias)) : s.sessionRemovedWasActive);
   }
   if (!shouldTeardownTransport) {
     lines.push(s.sessionTransportShared(session3.transportSession, sharedAliasCount));
@@ -21516,7 +22060,7 @@ async function promptWithSession(context, session3, chatKey, text, reply, replyC
   if (context.orchestration) {
     try {
       await context.orchestration.recordCoordinatorRouteContext?.({
-        coordinatorSession: session3.transportSession,
+        coordinatorSession: stableCoordinatorSession(session3.transportSession),
         chatKey,
         sessionAlias: session3.alias,
         ...replyContextToken ? { replyContextToken } : {},
@@ -21599,7 +22143,7 @@ async function preparePromptWithFallback(context, session3, chatKey, text, reply
   try {
     return await buildCoordinatorPrompt({
       orchestration: orchestration3,
-      coordinatorSession: session3.transportSession,
+      coordinatorSession: stableCoordinatorSession(session3.transportSession),
       chatKey,
       userText: text,
       ...replyContextToken ? { replyContextToken } : {},
@@ -21934,6 +22478,7 @@ async function handleDelegateRequest(context, chatKey, targetAgent, task, role,
   if (!session3) {
     return { text: t().orchestration.noCurrentSession };
   }
+  const coordinatorSession = stableCoordinatorSession(session3.transportSession);
   const orchestration3 = getOrchestration(context);
   if (!orchestration3) {
     return { text: renderOrchestrationUnavailable() };
@@ -21941,7 +22486,7 @@ async function handleDelegateRequest(context, chatKey, targetAgent, task, role,
   const result = await orchestration3.requestDelegate({
     sourceHandle: session3.transportSession,
     sourceKind: "coordinator",
-    coordinatorSession: session3.transportSession,
+    coordinatorSession,
     workspace: session3.workspace,
     targetAgent,
     task,
@@ -21958,12 +22503,13 @@ async function handleGroupCreate(context, chatKey, title) {
   if (!session3) {
     return { text: t().orchestration.noCurrentSession };
   }
+  const coordinatorSession = stableCoordinatorSession(session3.transportSession);
   const orchestration3 = getOrchestration(context);
   if (!orchestration3) {
     return { text: renderOrchestrationUnavailable() };
   }
   const group = await orchestration3.createGroup({
-    coordinatorSession: session3.transportSession,
+    coordinatorSession,
     title
   });
   return { text: renderGroupCreated(group) };
@@ -21973,12 +22519,13 @@ async function handleGroupList(context, chatKey, filter) {
   if (!session3) {
     return { text: t().orchestration.noCurrentSession };
   }
+  const coordinatorSession = stableCoordinatorSession(session3.transportSession);
   const orchestration3 = getOrchestration(context);
   if (!orchestration3) {
     return { text: renderOrchestrationUnavailable() };
   }
   const groups = await orchestration3.listGroupSummaries({
-    coordinatorSession: session3.transportSession,
+    coordinatorSession,
     ...filter ?? {}
   });
   return { text: renderGroupList(groups) };
@@ -21988,13 +22535,14 @@ async function handleGroupGet(context, chatKey, groupId) {
   if (!session3) {
     return { text: t().orchestration.noCurrentSession };
   }
+  const coordinatorSession = stableCoordinatorSession(session3.transportSession);
   const orchestration3 = getOrchestration(context);
   if (!orchestration3) {
     return { text: renderOrchestrationUnavailable() };
   }
   const group = await orchestration3.getGroupSummary({
     groupId,
-    coordinatorSession: session3.transportSession
+    coordinatorSession
   });
   if (!group) {
     return { text: t().orchestration.groupNotFound };
@@ -22006,20 +22554,21 @@ async function handleGroupCancel(context, chatKey, groupId) {
   if (!session3) {
     return { text: t().orchestration.noCurrentSession };
   }
+  const coordinatorSession = stableCoordinatorSession(session3.transportSession);
   const orchestration3 = getOrchestration(context);
   if (!orchestration3) {
     return { text: renderOrchestrationUnavailable() };
   }
   const group = await orchestration3.getGroupSummary({
     groupId,
-    coordinatorSession: session3.transportSession
+    coordinatorSession
   });
   if (!group) {
     return { text: t().orchestration.groupNotFound };
   }
   const cancelled = await orchestration3.cancelGroup({
     groupId,
-    coordinatorSession: session3.transportSession
+    coordinatorSession
   });
   return { text: renderGroupCancelSuccess(cancelled) };
 }
@@ -22028,13 +22577,14 @@ async function handleGroupDelegate(context, chatKey, groupId, targetAgent, task,
   if (!session3) {
     return { text: t().orchestration.noCurrentSession };
   }
+  const coordinatorSession = stableCoordinatorSession(session3.transportSession);
   const orchestration3 = getOrchestration(context);
   if (!orchestration3) {
     return { text: renderOrchestrationUnavailable() };
   }
   const group = await orchestration3.getGroupSummary({
     groupId,
-    coordinatorSession: session3.transportSession
+    coordinatorSession
   });
   if (!group) {
     return { text: t().orchestration.groupNotFound };
@@ -22046,12 +22596,13 @@ async function handleTaskList(context, chatKey, filter) {
   if (!session3) {
     return { text: t().orchestration.noCurrentSession };
   }
+  const coordinatorSession = stableCoordinatorSession(session3.transportSession);
   const orchestration3 = getOrchestration(context);
   if (!orchestration3) {
     return { text: renderOrchestrationUnavailable() };
   }
   const tasks = await orchestration3.listTasks({
-    coordinatorSession: session3.transportSession,
+    coordinatorSession,
     ...filter ?? {}
   });
   return { text: renderTaskList2(tasks) };
@@ -22061,12 +22612,13 @@ async function handleTaskGet(context, chatKey, taskId) {
   if (!session3) {
     return { text: t().orchestration.noCurrentSession };
   }
+  const coordinatorSession = stableCoordinatorSession(session3.transportSession);
   const orchestration3 = getOrchestration(context);
   if (!orchestration3) {
     return { text: renderOrchestrationUnavailable() };
   }
   const task = await orchestration3.getTask(taskId);
-  if (!task || task.coordinatorSession !== session3.transportSession) {
+  if (!task || !sameCoordinatorSession(task.coordinatorSession, coordinatorSession)) {
     return { text: t().orchestration.taskNotFound };
   }
   return { text: renderTaskSummary2(task) };
@@ -22076,12 +22628,13 @@ async function handleTaskApprove(context, chatKey, taskId) {
   if (!session3) {
     return { text: t().orchestration.noCurrentSession };
   }
+  const coordinatorSession = stableCoordinatorSession(session3.transportSession);
   const orchestration3 = getOrchestration(context);
   if (!orchestration3) {
     return { text: renderOrchestrationUnavailable() };
   }
   const task = await orchestration3.getTask(taskId);
-  if (!task || task.coordinatorSession !== session3.transportSession) {
+  if (!task || !sameCoordinatorSession(task.coordinatorSession, coordinatorSession)) {
     return { text: t().orchestration.taskNotFound };
   }
   if (task.status !== "needs_confirmation") {
@@ -22089,7 +22642,7 @@ async function handleTaskApprove(context, chatKey, taskId) {
   }
   const approved = await orchestration3.approveTask({
     taskId,
-    coordinatorSession: session3.transportSession
+    coordinatorSession
   });
   return { text: renderTaskApprovalSuccess2(approved) };
 }
@@ -22098,12 +22651,13 @@ async function handleTaskReject(context, chatKey, taskId) {
   if (!session3) {
     return { text: t().orchestration.noCurrentSession };
   }
+  const coordinatorSession = stableCoordinatorSession(session3.transportSession);
   const orchestration3 = getOrchestration(context);
   if (!orchestration3) {
     return { text: renderOrchestrationUnavailable() };
   }
   const task = await orchestration3.getTask(taskId);
-  if (!task || task.coordinatorSession !== session3.transportSession) {
+  if (!task || !sameCoordinatorSession(task.coordinatorSession, coordinatorSession)) {
     return { text: t().orchestration.taskNotFound };
   }
   if (task.status !== "needs_confirmation") {
@@ -22111,7 +22665,7 @@ async function handleTaskReject(context, chatKey, taskId) {
   }
   const rejected = await orchestration3.cancelTask({
     taskId,
-    coordinatorSession: session3.transportSession
+    coordinatorSession
   });
   return { text: renderTaskRejectSuccess(rejected) };
 }
@@ -22120,17 +22674,18 @@ async function handleTaskCancel(context, chatKey, taskId) {
   if (!session3) {
     return { text: t().orchestration.noCurrentSession };
   }
+  const coordinatorSession = stableCoordinatorSession(session3.transportSession);
   const orchestration3 = getOrchestration(context);
   if (!orchestration3) {
     return { text: renderOrchestrationUnavailable() };
   }
   const task = await orchestration3.getTask(taskId);
-  if (!task || task.coordinatorSession !== session3.transportSession) {
+  if (!task || !sameCoordinatorSession(task.coordinatorSession, coordinatorSession)) {
     return { text: t().orchestration.taskNotFound };
   }
   const cancelled = await orchestration3.requestTaskCancellation({
     taskId,
-    coordinatorSession: session3.transportSession
+    coordinatorSession
   });
   return { text: renderTaskCancelSuccess(cancelled) };
 }
@@ -22139,11 +22694,12 @@ async function handleTasksClean(context, chatKey) {
   if (!session3) {
     return { text: t().orchestration.noCurrentSession };
   }
+  const coordinatorSession = stableCoordinatorSession(session3.transportSession);
   const orchestration3 = getOrchestration(context);
   if (!orchestration3) {
     return { text: renderOrchestrationUnavailable() };
   }
-  const result = await orchestration3.cleanTasks(session3.transportSession);
+  const result = await orchestration3.cleanTasks(coordinatorSession);
   return { text: renderTasksCleanResult(result.removedTasks, result.removedBindings) };
 }
 async function getCurrentSession(context, chatKey) {
@@ -22310,7 +22866,7 @@ async function handleWorkspaceCreate(context, workspaceName, cwd, options = {})
     name = allocateWorkspaceName(base, context.config.workspaces);
     notice = w.nameSanitized(workspaceName, name);
   }
-  const updated = await context.configStore.upsertWorkspace(name, normalizedCwd);
+  const updated = await context.configStore.upsertWorkspace(name, cwd);
   context.replaceConfig(updated);
   const savedLine = w.saved(name);
   return { text: notice ? `${notice}
@@ -22426,10 +22982,10 @@ function validateResult(executeAt, messageStartIndex, tokens, now, pastTodayValu
   if (tokens.slice(messageStartIndex).join(" ").trim().length === 0)
     return { ok: false, code: "missing_message" };
   const delta = executeAt.getTime() - now.getTime();
+  if (isNaN(delta) || delta > LATER_MAX_DELAY_MS)
+    return { ok: false, code: "out_of_range" };
   if (delta < LATER_MIN_DELAY_MS)
     return { ok: false, code: "too_soon" };
-  if (delta > LATER_MAX_DELAY_MS)
-    return { ok: false, code: "out_of_range" };
   return { ok: true, executeAt, messageStartIndex };
 }
 var WEEKDAYS, ZH_MIN = "分钟", ZH_HOUR = "小时", ZH_DAY_UNIT = "天", ZH_TODAY = "今天", ZH_TOMORROW = "明天", ZH_DAY_AFTER = "后天", ZH_AFTER = "后", ZH_RELATIVE_RE;
@@ -22505,16 +23061,17 @@ function laterHelp() {
 function handleLaterHelp() {
   return { text: renderLaterHelp() };
 }
-async function handleLaterCreate(tokens, scheduled, chatKey, currentSession, defaultMode, accountId, replyContextToken) {
+async function handleLaterCreate(tokens, tails, scheduled, chatKey, currentSession, defaultMode, accountId, replyContextToken) {
   const l = t().later;
-  let rest = tokens;
+  let restStart = 0;
   const seenFlags = new Set;
   let flagMode;
-  while (rest.length > 0 && (rest[0] === "--bind" || rest[0] === "--temp")) {
-    seenFlags.add(rest[0]);
-    flagMode = rest[0] === "--bind" ? "bound" : "temp";
-    rest = rest.slice(1);
+  while (restStart < tokens.length && (tokens[restStart] === "--bind" || tokens[restStart] === "--temp")) {
+    seenFlags.add(tokens[restStart] ?? "");
+    flagMode = tokens[restStart] === "--bind" ? "bound" : "temp";
+    restStart += 1;
   }
+  const rest = tokens.slice(restStart);
   if (seenFlags.size > 1) {
     return { text: l.bindAndTempMutuallyExclusive };
   }
@@ -22535,7 +23092,7 @@ async function handleLaterCreate(tokens, scheduled, chatKey, currentSession, def
   if (!result.ok) {
     return { text: renderTimeParseError(result.code, result.value) };
   }
-  const message = rest.slice(result.messageStartIndex).join(" ").trim();
+  const message = (tails[restStart + result.messageStartIndex] ?? "").trim();
   if (message.startsWith("/")) {
     return {
       text: [
@@ -22559,12 +23116,12 @@ async function handleLaterCreate(tokens, scheduled, chatKey, currentSession, def
   });
   return { text: renderTaskCreated(task, toDisplaySessionAlias(currentSession.alias)) };
 }
-function handleLaterList(scheduled) {
-  const tasks = scheduled.listPending();
+function handleLaterList(scheduled, chatKey) {
+  const tasks = scheduled.listPending(chatKey);
   return { text: renderLaterList(tasks, (alias) => toDisplaySessionAlias(alias)) };
 }
-async function handleLaterCancel(id, scheduled) {
-  const ok = await scheduled.cancelPending(id);
+async function handleLaterCancel(id, scheduled, chatKey) {
+  const ok = await scheduled.cancelPending(id, chatKey);
   const displayId = id.replace(/^#/, "").toLowerCase();
   if (ok) {
     return { text: t().later.cancelSuccess(displayId) };
@@ -23401,7 +23958,7 @@ var init_session_recovery_handler = __esm(() => {
 // src/recovery/auto-install-optional-dep.ts
 import { spawn as spawn5 } from "node:child_process";
 import { createWriteStream } from "node:fs";
-import { mkdir as mkdir10 } from "node:fs/promises";
+import { mkdir as mkdir8 } from "node:fs/promises";
 import { homedir as homedir6 } from "node:os";
 import { join as join14 } from "node:path";
 async function autoInstallOptionalDep(pkg, parentPackages, options = {}) {
@@ -23519,7 +24076,7 @@ ${err.message}`, reason: "spawn" });
   });
 }, defaultLogSink = async () => {
   const dir = join14(coreHomeDir(homedir6()), "logs");
-  await mkdir10(dir, { recursive: true });
+  await mkdir8(dir, { recursive: true });
   const timestamp = new Date().toISOString().replace(/[:.]/g, "").replace(/-/g, "");
   const path14 = join14(dir, `auto-install-${timestamp}.log`);
   const stream = createWriteStream(path14, { flags: "a" });
@@ -23548,7 +24105,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 dirname12, join as join15 } from "node:path";
+import { dirname as dirname10, join as join15 } 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))?$/, "");
 }
@@ -23621,7 +24178,7 @@ function defaultResolveFromCwd(name, cwd) {
     const pkgJson = require2.resolve(`${name}/package.json`, {
       paths: [cwd, ...require2.resolve.paths(name) ?? []]
     });
-    return dirname12(pkgJson);
+    return dirname10(pkgJson);
   } catch {
     return null;
   }
@@ -23756,11 +24313,11 @@ async function handleSessionResetCommand(context, ops, chatKey) {
       chatKey,
       native: wasNative && Boolean(freshAgentSessionId)
     });
-    if (wasNative && context.transport.removeSession && context.sessions.countAliasesSharingTransport(previous.transportSession) === 0) {
+    if (context.transport.removeSession && context.sessions.countAliasesSharingTransport(previous.transportSession) === 0) {
       try {
         await context.transport.removeSession(previous);
       } catch (error2) {
-        await context.logger.info("session.reset.close_previous_failed", "failed to close previous native session after reset", {
+        await context.logger.info("session.reset.close_previous_failed", "failed to close previous session after reset", {
           transportSession: previous.transportSession,
           error: error2 instanceof Error ? error2.message : String(error2)
         });
@@ -23822,9 +24379,20 @@ class CommandRouter {
       chatKey,
       kind: command.kind
     });
+    await this.refreshConfigFromStore();
+    perfSpan?.mark("router.config_refreshed");
+    metadata = withEffectiveOwner(metadata, this.config);
     const access4 = authorizeCommandForChat(command, metadata);
     perfSpan?.mark("router.authorized", { decision: access4.allowed ? "allow" : "deny" });
     if (!access4.allowed) {
+      if (access4.reason === "chat-type-missing") {
+        await this.logger.error("channel.chat_type_missing", "channel turn carried no chatType; denying privileged command (channel metadata contract violation)", {
+          chatKey,
+          kind: command.kind,
+          channel: metadata?.channel,
+          senderId: metadata?.senderId
+        });
+      }
       await this.logger.info("command.blocked", "blocked command by chat policy", {
         chatKey,
         kind: command.kind,
@@ -23832,10 +24400,8 @@ class CommandRouter {
         channel: metadata?.channel,
         senderId: metadata?.senderId
       });
-      return { text: renderCommandAccessDenied(command) };
+      return { text: renderCommandAccessDenied(command, access4.reason) };
     }
-    await this.refreshConfigFromStore();
-    perfSpan?.mark("router.config_refreshed");
     return await this.executeCommand(chatKey, command.kind, startedAt, async () => {
       switch (command.kind) {
         case "invalid":
@@ -23937,7 +24503,7 @@ class CommandRouter {
         case "later.list":
           if (!this.scheduled)
             return { text: t().later.serviceNotEnabled };
-          return handleLaterList(this.scheduled);
+          return handleLaterList(this.scheduled, chatKey);
         case "later.create": {
           if (!this.scheduled)
             return { text: t().later.serviceNotEnabled };
@@ -23945,12 +24511,12 @@ class CommandRouter {
             return { text: renderLaterUnsupportedChannel() };
           }
           const currentSession = await this.sessions.getCurrentSession(chatKey);
-          return await handleLaterCreate(command.tokens, this.scheduled, chatKey, currentSession ? { alias: currentSession.alias, agent: currentSession.agent, workspace: currentSession.workspace } : null, this.config?.later?.defaultMode === "bind" ? "bound" : "temp", accountId, replyContextToken);
+          return await handleLaterCreate(command.tokens, command.tails, this.scheduled, chatKey, currentSession ? { alias: currentSession.alias, agent: currentSession.agent, workspace: currentSession.workspace } : null, this.config?.later?.defaultMode === "bind" ? "bound" : "temp", accountId, replyContextToken);
         }
         case "later.cancel":
           if (!this.scheduled)
             return { text: t().later.serviceNotEnabled };
-          return await handleLaterCancel(command.id, this.scheduled);
+          return await handleLaterCancel(command.id, this.scheduled, chatKey);
         case "prompt": {
           const sessionContext = this.createSessionHandlerContext(undefined, perfSpan);
           if (metadata?.scheduledSessionDescriptor) {
@@ -24204,7 +24770,7 @@ class CommandRouter {
     return await this.measureTransportCall("has_session", session3, () => this.transport.hasSession(session3));
   }
   async promptTransportSession(session3, text, reply, replyContext, media, abortSignal, onToolEvent, onThought, perfSpan) {
-    session3.mcpCoordinatorSession ??= session3.transportSession;
+    session3.mcpCoordinatorSession ??= stableCoordinatorSession(session3.transportSession);
     let done = false;
     let abortRequested = false;
     let cancelOnAbort;
@@ -24454,8 +25020,8 @@ var init_console_agent = __esm(() => {
 });
 
 // src/orchestration/orchestration-server.ts
-import { rm as rm8 } from "node:fs/promises";
-import { createConnection as createConnection2, createServer } from "node:net";
+import { chmod as chmod4, rm as rm8 } from "node:fs/promises";
+import { createServer } from "node:net";
 
 class OrchestrationServer {
   endpoint;
@@ -24501,6 +25067,7 @@ class OrchestrationServer {
       });
     });
     await this.listenWithUnixSocketRecovery();
+    await this.hardenUnixSocketPermissions();
     this.started = true;
   }
   async stop() {
@@ -24683,23 +25250,25 @@ class OrchestrationServer {
     if (!task) {
       return null;
     }
-    if (task.coordinatorSession !== coordinatorSession) {
+    if (!sameCoordinatorSession(task.coordinatorSession, coordinatorSession)) {
       return null;
     }
     return task;
   }
   parseRequestDelegateRpcInput(params) {
-    requireOnlyKeys(params, ["sourceHandle", "targetAgent", "task", "cwd", "role", "groupId"], "params");
+    requireOnlyKeys(params, ["sourceHandle", "targetAgent", "task", "cwd", "role", "groupId", "parallel"], "params");
     const cwd = requireOptionalString(params, "cwd");
     const role = requireOptionalString(params, "role");
     const groupId = requireOptionalString(params, "groupId");
+    const parallel = requireOptionalBoolean(params, "parallel");
     return {
       sourceHandle: requireString(params, "sourceHandle"),
       targetAgent: requireString(params, "targetAgent"),
       task: requireString(params, "task"),
       ...cwd !== undefined ? { cwd } : {},
       ...role !== undefined ? { role } : {},
-      ...groupId !== undefined ? { groupId } : {}
+      ...groupId !== undefined ? { groupId } : {},
+      ...parallel !== undefined ? { parallel } : {}
     };
   }
   parseTaskListFilter(params) {
@@ -24782,6 +25351,17 @@ class OrchestrationServer {
       whatIsNeeded: requireString(params, "whatIsNeeded")
     };
   }
+  async hardenUnixSocketPermissions() {
+    if (this.endpoint.kind !== "unix") {
+      return;
+    }
+    const chmodFile = this.deps.chmodFile ?? chmod4;
+    try {
+      await chmodFile(this.endpoint.path, 384);
+    } catch (error2) {
+      this.deps.onSocketHardenError?.(error2);
+    }
+  }
   async cleanupEndpoint() {
     if (this.endpoint.kind !== "unix") {
       return;
@@ -24948,29 +25528,6 @@ function requireTaskQuestions(params, key) {
     };
   });
 }
-async function canConnectToEndpoint(path14) {
-  return await new Promise((resolve3) => {
-    const socket = createConnection2(path14);
-    let settled = false;
-    const finish = (result) => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      socket.destroy();
-      resolve3(result);
-    };
-    socket.once("connect", () => finish(true));
-    socket.once("error", (error2) => {
-      const code = error2.code;
-      if (code === "ENOENT" || code === "ECONNREFUSED") {
-        finish(false);
-        return;
-      }
-      finish(true);
-    });
-  });
-}
 async function listen(server, path14) {
   await new Promise((resolve3, reject) => {
     const onError = (error2) => {
@@ -24993,6 +25550,7 @@ var OrchestrationInvalidRequestError, ORCHESTRATION_RPC_METHODS;
 var init_orchestration_server = __esm(() => {
   init_orchestration_ipc();
   init_task_watch_timeouts();
+  init_endpoint_probe();
   OrchestrationInvalidRequestError = class OrchestrationInvalidRequestError extends Error {
   };
   ORCHESTRATION_RPC_METHODS = new Set([
@@ -25193,7 +25751,7 @@ class OrchestrationService {
   async getGroupSummary(input) {
     const state = await this.deps.loadState();
     const group = this.ensureGroups(state)[input.groupId];
-    if (!group || group.coordinatorSession !== input.coordinatorSession) {
+    if (!group || !sameCoordinatorSession(group.coordinatorSession, input.coordinatorSession)) {
       return null;
     }
     return this.buildGroupSummary(group, Object.values(state.orchestration.tasks).filter((task) => task.groupId === input.groupId));
@@ -25205,7 +25763,7 @@ class OrchestrationService {
     const now = this.deps.now().getTime();
     const sortField = input.sort ?? "updatedAt";
     const order = input.order ?? "desc";
-    return Object.values(this.ensureGroups(state)).filter((group) => group.coordinatorSession === input.coordinatorSession).map((group) => ({
+    return Object.values(this.ensureGroups(state)).filter((group) => sameCoordinatorSession(group.coordinatorSession, input.coordinatorSession)).map((group) => ({
       group,
       summary: this.buildGroupSummary(group, tasks.filter((task) => task.groupId === group.groupId))
     })).filter(({ summary }) => {
@@ -25695,7 +26253,7 @@ class OrchestrationService {
         const workerSession = task.workerSession;
         const taskStillOwnsWorkerSession = current?.workerSession === workerSession;
         const currentBinding = state.orchestration.workerBindings[workerSession];
-        const bindingStillBelongsToThisStartup = currentBinding?.sourceHandle === workerSession && currentBinding.coordinatorSession === task.coordinatorSession && currentBinding.workspace === task.workspace && currentBinding.cwd === task.cwd && currentBinding.targetAgent === task.targetAgent && currentBinding.role === task.role;
+        const bindingStillBelongsToThisStartup = currentBinding?.sourceHandle === workerSession && sameCoordinatorSession(currentBinding.coordinatorSession, task.coordinatorSession) && currentBinding.workspace === task.workspace && currentBinding.cwd === task.cwd && currentBinding.targetAgent === task.targetAgent && currentBinding.role === task.role;
         const otherActiveOwner = Object.values(state.orchestration.tasks).some((candidate) => candidate.taskId !== task.taskId && candidate.workerSession === workerSession && (!this.isTerminalStatus(candidate.status) || candidate.reviewPending !== undefined));
         const restoreOrDeleteBinding = () => {
           if (!bindingStillBelongsToThisStartup || otherActiveOwner) {
@@ -25754,7 +26312,7 @@ class OrchestrationService {
       current.updatedAt = now;
       this.bumpGroupUpdated(state, current.groupId, now);
       const currentBinding = state.orchestration.workerBindings[workerSession];
-      const bindingStillBelongsToThisStartup = currentBinding?.sourceHandle === workerSession && currentBinding.coordinatorSession === task.coordinatorSession && currentBinding.workspace === task.workspace && currentBinding.cwd === task.cwd && currentBinding.targetAgent === task.targetAgent && currentBinding.role === task.role;
+      const bindingStillBelongsToThisStartup = currentBinding?.sourceHandle === workerSession && sameCoordinatorSession(currentBinding.coordinatorSession, task.coordinatorSession) && currentBinding.workspace === task.workspace && currentBinding.cwd === task.cwd && currentBinding.targetAgent === task.targetAgent && currentBinding.role === task.role;
       const otherActiveOwner = Object.values(state.orchestration.tasks).some((candidate) => candidate.taskId !== task.taskId && candidate.workerSession === workerSession && (!this.isTerminalStatus(candidate.status) || candidate.reviewPending !== undefined));
       if (bindingStillBelongsToThisStartup && !otherActiveOwner) {
         if (input.previousBinding) {
@@ -25773,7 +26331,7 @@ class OrchestrationService {
       const state = await this.deps.loadState();
       const workerSession = task.workerSession;
       const currentBinding = state.orchestration.workerBindings[workerSession];
-      const bindingStillBelongsToThisStartup = currentBinding?.sourceHandle === workerSession && currentBinding.coordinatorSession === task.coordinatorSession && currentBinding.workspace === task.workspace && currentBinding.cwd === task.cwd && currentBinding.targetAgent === task.targetAgent && currentBinding.role === task.role;
+      const bindingStillBelongsToThisStartup = currentBinding?.sourceHandle === workerSession && sameCoordinatorSession(currentBinding.coordinatorSession, task.coordinatorSession) && currentBinding.workspace === task.workspace && currentBinding.cwd === task.cwd && currentBinding.targetAgent === task.targetAgent && currentBinding.role === task.role;
       if (!bindingStillBelongsToThisStartup) {
         return false;
       }
@@ -25946,7 +26504,7 @@ class OrchestrationService {
     while (true) {
       const state = await this.deps.loadState();
       const task = state.orchestration.tasks[input.taskId];
-      if (!task || task.coordinatorSession !== input.coordinatorSession) {
+      if (!task || !sameCoordinatorSession(task.coordinatorSession, input.coordinatorSession)) {
         return { status: "not_found", task: null, events: [], nextAfterSeq: afterSeq };
       }
       const snapshot = { ...task };
@@ -26004,7 +26562,8 @@ class OrchestrationService {
     return await this.mutate(async () => {
       const state = await this.deps.loadState();
       const now = this.deps.now().toISOString();
-      const existing = this.ensureCoordinatorRoutes(state)[input.coordinatorSession];
+      const routeKey = stableCoordinatorSession(input.coordinatorSession);
+      const existing = this.ensureCoordinatorRoutes(state)[routeKey];
       const sameChat = existing?.chatKey === input.chatKey;
       const hasAccountId = input.accountId !== undefined;
       const hasReplyContextToken = input.replyContextToken !== undefined;
@@ -26018,14 +26577,14 @@ class OrchestrationService {
         replyContextToken: existing.replyContextToken
       } : undefined;
       const route = {
-        coordinatorSession: input.coordinatorSession,
+        coordinatorSession: routeKey,
         chatKey: input.chatKey,
         ...input.sessionAlias ? { sessionAlias: input.sessionAlias } : {},
         ...replyRoute ? replyRoute : {},
         ...buildCoordinatorRouteChatMetadata(input, sameChat ? existing : undefined),
         updatedAt: now
       };
-      this.ensureCoordinatorRoutes(state)[input.coordinatorSession] = route;
+      this.ensureCoordinatorRoutes(state)[routeKey] = route;
       await this.deps.saveState(state);
       return { ...route };
     });
@@ -26269,7 +26828,7 @@ class OrchestrationService {
         return task;
       });
       const now = this.deps.now().toISOString();
-      const route = this.snapshotCoordinatorDeliveryRoute(this.ensureCoordinatorRoutes(state)[input.coordinatorSession]);
+      const route = this.snapshotCoordinatorDeliveryRoute(this.ensureCoordinatorRoutes(state)[stableCoordinatorSession(input.coordinatorSession)]);
       if (coordinatorState.activePackageId) {
         const activePackage = this.ensureHumanQuestionPackages(state)[coordinatorState.activePackageId];
         if (!activePackage) {
@@ -26371,7 +26930,7 @@ class OrchestrationService {
       if (!packageRecord) {
         throw new Error(`package "${input.packageId}" does not exist`);
       }
-      if (packageRecord.coordinatorSession !== input.coordinatorSession) {
+      if (!sameCoordinatorSession(packageRecord.coordinatorSession, input.coordinatorSession)) {
         throw new Error(`package "${input.packageId}" belongs to coordinator "${packageRecord.coordinatorSession}", not "${input.coordinatorSession}"`);
       }
       if (packageRecord.status !== "active") {
@@ -26386,7 +26945,7 @@ class OrchestrationService {
       }
       let route = this.resolveFrozenPackageMessageRoute(message);
       if (!route) {
-        route = this.snapshotCoordinatorDeliveryRoute(this.ensureCoordinatorRoutes(state)[input.coordinatorSession]) ?? null;
+        route = this.snapshotCoordinatorDeliveryRoute(this.ensureCoordinatorRoutes(state)[stableCoordinatorSession(input.coordinatorSession)]) ?? null;
         if (route) {
           Object.assign(message, this.serializeFrozenDeliveryRoute(route));
         }
@@ -26455,7 +27014,7 @@ class OrchestrationService {
     if (this.isExternalCoordinatorSession(state, coordinatorSession)) {
       return null;
     }
-    const coordinatorState = state.orchestration.coordinatorQuestionState[coordinatorSession];
+    const coordinatorState = state.orchestration.coordinatorQuestionState[stableCoordinatorSession(coordinatorSession)];
     const activePackageId = coordinatorState?.activePackageId;
     if (!activePackageId) {
       return null;
@@ -26595,7 +27154,7 @@ class OrchestrationService {
       const bindings = state.orchestration.workerBindings;
       const terminalTaskIds = [];
       for (const [taskId, task] of Object.entries(tasks)) {
-        if (task.coordinatorSession === coordinatorSession && this.isTerminalStatus(task.status) && task.reviewPending === undefined) {
+        if (sameCoordinatorSession(task.coordinatorSession, coordinatorSession) && this.isTerminalStatus(task.status) && task.reviewPending === undefined) {
           terminalTaskIds.push(taskId);
         }
       }
@@ -26605,7 +27164,7 @@ class OrchestrationService {
       const remainingWorkerSessions = new Set(Object.values(tasks).map((task) => task.workerSession).filter(Boolean));
       let removedBindings = 0;
       for (const [workerSession, binding] of Object.entries(bindings)) {
-        if (binding.coordinatorSession !== coordinatorSession) {
+        if (!sameCoordinatorSession(binding.coordinatorSession, coordinatorSession)) {
           continue;
         }
         if (!remainingWorkerSessions.has(workerSession)) {
@@ -26625,16 +27184,17 @@ class OrchestrationService {
   }
   async listSessionBlockingTasks(transportSession) {
     const state = await this.deps.loadState();
-    return Object.values(state.orchestration.tasks).filter((task) => (!this.isTerminalStatus(task.status) || task.reviewPending !== undefined) && (task.coordinatorSession === transportSession || task.workerSession === transportSession)).map((task) => ({ ...task }));
+    return Object.values(state.orchestration.tasks).filter((task) => (!this.isTerminalStatus(task.status) || task.reviewPending !== undefined) && (sameCoordinatorSession(task.coordinatorSession, transportSession) || task.workerSession !== undefined && sameCoordinatorSession(task.workerSession, transportSession))).map((task) => ({ ...task }));
   }
   async purgeSessionReferences(transportSession) {
     return await this.mutate(async () => {
       const state = await this.deps.loadState();
+      const sessionIdentity = stableCoordinatorSession(transportSession);
       const tasks = state.orchestration.tasks;
       const bindings = state.orchestration.workerBindings;
       const removedTaskIds = [];
       for (const [taskId, task] of Object.entries(tasks)) {
-        if (this.isTerminalStatus(task.status) && task.reviewPending === undefined && (task.coordinatorSession === transportSession || task.workerSession === transportSession)) {
+        if (this.isTerminalStatus(task.status) && task.reviewPending === undefined && (sameCoordinatorSession(task.coordinatorSession, transportSession) || task.workerSession !== undefined && sameCoordinatorSession(task.workerSession, transportSession))) {
           removedTaskIds.push(taskId);
         }
       }
@@ -26644,14 +27204,14 @@ class OrchestrationService {
       const remainingWorkerSessions = new Set(Object.values(tasks).map((task) => task.workerSession).filter(Boolean));
       let removedBindings = 0;
       for (const [workerSession, binding] of Object.entries(bindings)) {
-        const shouldPurgeBinding = workerSession === transportSession || binding.coordinatorSession === transportSession;
+        const shouldPurgeBinding = sameCoordinatorSession(workerSession, transportSession) || sameCoordinatorSession(binding.coordinatorSession, transportSession);
         if (shouldPurgeBinding && !remainingWorkerSessions.has(workerSession)) {
           delete bindings[workerSession];
           removedBindings += 1;
         }
       }
-      const removedEmptyGroups = this.removeEmptyGroupsForCoordinator(state, transportSession);
-      const removedCoordinatorMetadata = this.removeCoordinatorMetadataIfUnused(state, transportSession);
+      const removedEmptyGroups = this.removeEmptyGroupsForCoordinator(state, sessionIdentity);
+      const removedCoordinatorMetadata = this.removeCoordinatorMetadataIfUnused(state, sessionIdentity);
       if (removedTaskIds.length > 0 || removedBindings > 0 || removedEmptyGroups || removedCoordinatorMetadata) {
         await this.deps.saveState(state);
       }
@@ -26661,106 +27221,28 @@ class OrchestrationService {
       };
     });
   }
-  async purgeExpiredResetCoordinators(input) {
-    try {
-      if (!Number.isFinite(input.cutoffDays) || input.cutoffDays < 0) {
-        throw new Error(`cutoffDays must be a non-negative number, got ${String(input.cutoffDays)}`);
-      }
-      const result = await this.mutate(async () => {
-        const state = await this.deps.loadState();
-        const candidates = this.collectResetCoordinatorCandidates(state);
-        const activeTransportSessions = new Set(Object.values(state.sessions).map((session3) => session3.transport_session));
-        const MS_PER_DAY = 24 * 60 * 60 * 1000;
-        const cutoffMs = input.cutoffDays * MS_PER_DAY;
-        const nowMs = this.deps.now().getTime();
-        let purgedCoordinators = 0;
-        const removed = {
-          tasks: 0,
-          workerBindings: 0,
-          groups: 0,
-          coordinatorRoutes: 0,
-          humanQuestionPackages: 0,
-          coordinatorQuestionState: 0
-        };
-        for (const coordinatorSession of candidates) {
-          if (activeTransportSessions.has(coordinatorSession)) {
-            continue;
-          }
-          const activityAtMs = this.resolveResetCoordinatorActivityAtMs(state, coordinatorSession);
-          if (activityAtMs === null) {
-            continue;
-          }
-          if (nowMs - activityAtMs <= cutoffMs) {
-            continue;
-          }
-          const delta = this.cascadeRemoveCoordinatorRecords(state, coordinatorSession);
-          const changed = delta.tasks > 0 || delta.workerBindings > 0 || delta.groups > 0 || delta.coordinatorRoutes > 0 || delta.humanQuestionPackages > 0 || delta.coordinatorQuestionState > 0;
-          if (!changed) {
-            continue;
-          }
-          purgedCoordinators += 1;
-          removed.tasks += delta.tasks;
-          removed.workerBindings += delta.workerBindings;
-          removed.groups += delta.groups;
-          removed.coordinatorRoutes += delta.coordinatorRoutes;
-          removed.humanQuestionPackages += delta.humanQuestionPackages;
-          removed.coordinatorQuestionState += delta.coordinatorQuestionState;
-        }
-        const removedAny = removed.tasks > 0 || removed.workerBindings > 0 || removed.groups > 0 || removed.coordinatorRoutes > 0 || removed.humanQuestionPackages > 0 || removed.coordinatorQuestionState > 0;
-        if (removedAny) {
-          await this.deps.saveState(state);
-        }
-        return {
-          candidates: candidates.length,
-          purgedCoordinators,
-          removed
-        };
-      });
-      if (this.deps.logger) {
-        this.deps.logger.info("orchestration.reset_gc.completed", "reset coordinator gc completed", {
-          trigger: input.trigger,
-          cutoffDays: input.cutoffDays,
-          candidates: result.candidates,
-          purgedCoordinators: result.purgedCoordinators,
-          deletedCounts: result.removed
-        });
-      }
-      return result;
-    } catch (error2) {
-      const logger2 = this.deps.logger;
-      if (logger2) {
-        const message = error2 instanceof Error ? error2.message : String(error2);
-        logger2.error("orchestration.reset_gc.failed", "reset coordinator gc failed", {
-          trigger: input.trigger,
-          cutoffDays: input.cutoffDays,
-          message
-        });
-      }
-      throw error2;
-    }
-  }
   async listPendingCoordinatorResults(coordinatorSession) {
     const state = await this.deps.loadState();
     if (this.isExternalCoordinatorSession(state, coordinatorSession)) {
       return [];
     }
-    return Object.values(state.orchestration.tasks).filter((task) => task.coordinatorSession === coordinatorSession && this.canInjectTaskIntoCoordinator(state, task) && (task.injectionPending === true || task.coordinatorInjectedAt === undefined)).sort((left, right) => left.updatedAt.localeCompare(right.updatedAt)).map((task) => ({ ...task }));
+    return Object.values(state.orchestration.tasks).filter((task) => sameCoordinatorSession(task.coordinatorSession, coordinatorSession) && this.canInjectTaskIntoCoordinator(state, task) && (task.injectionPending === true || task.coordinatorInjectedAt === undefined)).sort((left, right) => left.updatedAt.localeCompare(right.updatedAt)).map((task) => ({ ...task }));
   }
   async listPendingCoordinatorBlockers(coordinatorSession) {
     const state = await this.deps.loadState();
     if (this.isExternalCoordinatorSession(state, coordinatorSession)) {
       return [];
     }
-    const coordinatorState = state.orchestration.coordinatorQuestionState[coordinatorSession];
+    const coordinatorState = state.orchestration.coordinatorQuestionState[stableCoordinatorSession(coordinatorSession)];
     const hiddenQueuedQuestionKeys = coordinatorState?.activePackageId ? new Set((coordinatorState.queuedQuestions ?? []).map((entry) => `${entry.taskId}:${entry.questionId}`)) : null;
-    return Object.values(state.orchestration.tasks).filter((task) => task.coordinatorSession === coordinatorSession && task.status === "blocked" && task.openQuestion?.status === "open" && !hiddenQueuedQuestionKeys?.has(`${task.taskId}:${task.openQuestion.questionId}`)).sort((left, right) => left.updatedAt.localeCompare(right.updatedAt)).map((task) => ({ ...task }));
+    return Object.values(state.orchestration.tasks).filter((task) => sameCoordinatorSession(task.coordinatorSession, coordinatorSession) && task.status === "blocked" && task.openQuestion?.status === "open" && !hiddenQueuedQuestionKeys?.has(`${task.taskId}:${task.openQuestion.questionId}`)).sort((left, right) => left.updatedAt.localeCompare(right.updatedAt)).map((task) => ({ ...task }));
   }
   async listContestedCoordinatorResults(coordinatorSession) {
     const state = await this.deps.loadState();
     if (this.isExternalCoordinatorSession(state, coordinatorSession)) {
       return [];
     }
-    return Object.values(state.orchestration.tasks).filter((task) => task.coordinatorSession === coordinatorSession && task.reviewPending !== undefined).sort((left, right) => left.updatedAt.localeCompare(right.updatedAt)).map((task) => ({ ...task }));
+    return Object.values(state.orchestration.tasks).filter((task) => sameCoordinatorSession(task.coordinatorSession, coordinatorSession) && task.reviewPending !== undefined).sort((left, right) => left.updatedAt.localeCompare(right.updatedAt)).map((task) => ({ ...task }));
   }
   async listPendingCoordinatorGroups(coordinatorSession) {
     const state = await this.deps.loadState();
@@ -26769,7 +27251,7 @@ class OrchestrationService {
     }
     const groups = this.ensureGroups(state);
     const tasks = Object.values(state.orchestration.tasks);
-    return Object.values(groups).filter((group) => group.coordinatorSession === coordinatorSession).filter((group) => {
+    return Object.values(groups).filter((group) => sameCoordinatorSession(group.coordinatorSession, coordinatorSession)).filter((group) => {
       const groupTasks = tasks.filter((task) => task.groupId === group.groupId);
       return this.canInjectGroupIntoCoordinator(state, group.groupId, groupTasks);
     }).sort((left, right) => left.updatedAt.localeCompare(right.updatedAt)).map((group) => ({ ...group }));
@@ -26984,7 +27466,7 @@ class OrchestrationService {
       if (input.sourceHandle !== undefined && task.sourceHandle !== input.sourceHandle) {
         throw new Error(`task "${input.taskId}" belongs to source "${task.sourceHandle}", not "${input.sourceHandle}"`);
       }
-      if (input.coordinatorSession !== undefined && task.coordinatorSession !== input.coordinatorSession) {
+      if (input.coordinatorSession !== undefined && !sameCoordinatorSession(task.coordinatorSession, input.coordinatorSession)) {
         throw new Error(`task "${input.taskId}" belongs to coordinator "${task.coordinatorSession}", not "${input.coordinatorSession}"`);
       }
       if (this.isTerminalStatus(task.status)) {
@@ -27411,11 +27893,11 @@ class OrchestrationService {
         ...binding.cwd ? { cwd: binding.cwd } : {}
       };
     }
-    const coordinatorSession = Object.values(state.sessions).find((session3) => session3.transport_session === sourceHandle);
+    const coordinatorSession = Object.values(state.sessions).find((session3) => sameCoordinatorSession(session3.transport_session, sourceHandle));
     if (coordinatorSession) {
       return {
         sourceKind: "coordinator",
-        coordinatorSession: sourceHandle,
+        coordinatorSession: stableCoordinatorSession(sourceHandle),
         workspace: coordinatorSession.workspace
       };
     }
@@ -27453,7 +27935,7 @@ class OrchestrationService {
     if (role && policy.allowedAgentRequestRoles.length > 0 && !policy.allowedAgentRequestRoles.includes(role)) {
       throw new Error(`role "${role}" is not allowed for agent-requested delegation`);
     }
-    const outstandingRequests = Object.values(state.orchestration.tasks).filter((task) => task.coordinatorSession === coordinatorSession && task.sourceKind !== "human" && (task.status === "needs_confirmation" || task.status === "running" || task.status === "queued"));
+    const outstandingRequests = Object.values(state.orchestration.tasks).filter((task) => sameCoordinatorSession(task.coordinatorSession, coordinatorSession) && task.sourceKind !== "human" && (task.status === "needs_confirmation" || task.status === "running" || task.status === "queued"));
     if (outstandingRequests.length >= policy.maxPendingAgentRequestsPerCoordinator) {
       throw new Error("agent-requested delegation quota exceeded for this coordinator");
     }
@@ -27557,13 +28039,13 @@ class OrchestrationService {
     if (!filter) {
       return true;
     }
-    return (filter.sourceHandle === undefined || task.sourceHandle === filter.sourceHandle) && (filter.coordinatorSession === undefined || task.coordinatorSession === filter.coordinatorSession) && (filter.workspace === undefined || task.workspace === filter.workspace) && (filter.targetAgent === undefined || task.targetAgent === filter.targetAgent) && (filter.role === undefined || task.role === filter.role) && (filter.status === undefined || task.status === filter.status);
+    return (filter.sourceHandle === undefined || task.sourceHandle === filter.sourceHandle) && (filter.coordinatorSession === undefined || sameCoordinatorSession(task.coordinatorSession, filter.coordinatorSession)) && (filter.workspace === undefined || task.workspace === filter.workspace) && (filter.targetAgent === undefined || task.targetAgent === filter.targetAgent) && (filter.role === undefined || task.role === filter.role) && (filter.status === undefined || task.status === filter.status);
   }
   isTerminalStatus(status) {
     return status === "completed" || status === "failed" || status === "cancelled";
   }
   assertCoordinatorOwnership(task, coordinatorSession) {
-    if (task.coordinatorSession !== coordinatorSession) {
+    if (!sameCoordinatorSession(task.coordinatorSession, coordinatorSession)) {
       throw new Error(`task "${task.taskId}" belongs to coordinator "${task.coordinatorSession}", not "${coordinatorSession}"`);
     }
   }
@@ -27576,7 +28058,7 @@ class OrchestrationService {
     if (!group) {
       throw new Error(`group "${groupId}" does not exist`);
     }
-    if (group.coordinatorSession !== coordinatorSession) {
+    if (!sameCoordinatorSession(group.coordinatorSession, coordinatorSession)) {
       throw new Error(`group "${groupId}" belongs to coordinator "${group.coordinatorSession}", not "${coordinatorSession}"`);
     }
   }
@@ -27587,13 +28069,14 @@ class OrchestrationService {
     return state.orchestration.humanQuestionPackages;
   }
   ensureCoordinatorQuestionState(state, coordinatorSession) {
+    const key = stableCoordinatorSession(coordinatorSession);
     if (!("coordinatorQuestionState" in state.orchestration) || !state.orchestration.coordinatorQuestionState) {
       state.orchestration.coordinatorQuestionState = {};
     }
-    state.orchestration.coordinatorQuestionState[coordinatorSession] ??= {
+    state.orchestration.coordinatorQuestionState[key] ??= {
       queuedQuestions: []
     };
-    return state.orchestration.coordinatorQuestionState[coordinatorSession];
+    return state.orchestration.coordinatorQuestionState[key];
   }
   ensureCoordinatorRoutes(state) {
     if (!("coordinatorRoutes" in state.orchestration) || !state.orchestration.coordinatorRoutes) {
@@ -27774,7 +28257,7 @@ class OrchestrationService {
     const referencedGroupIds = new Set(Object.values(state.orchestration.tasks).map((task) => task.groupId).filter((groupId) => typeof groupId === "string"));
     let removedAny = false;
     for (const [groupId, group] of Object.entries(groups)) {
-      if (group.coordinatorSession !== coordinatorSession) {
+      if (!sameCoordinatorSession(group.coordinatorSession, coordinatorSession)) {
         continue;
       }
       if (!referencedGroupIds.has(groupId)) {
@@ -27785,125 +28268,30 @@ class OrchestrationService {
     return removedAny;
   }
   removeCoordinatorMetadataIfUnused(state, coordinatorSession) {
-    const hasCoordinatorTasks = Object.values(state.orchestration.tasks).some((task) => task.coordinatorSession === coordinatorSession);
-    const hasCoordinatorBindings = Object.values(state.orchestration.workerBindings).some((binding) => binding.coordinatorSession === coordinatorSession);
+    const key = stableCoordinatorSession(coordinatorSession);
+    const hasCoordinatorTasks = Object.values(state.orchestration.tasks).some((task) => sameCoordinatorSession(task.coordinatorSession, coordinatorSession));
+    const hasCoordinatorBindings = Object.values(state.orchestration.workerBindings).some((binding) => sameCoordinatorSession(binding.coordinatorSession, coordinatorSession));
     if (hasCoordinatorTasks || hasCoordinatorBindings) {
       return false;
     }
     let removedAny = false;
     const packages = this.ensureHumanQuestionPackages(state);
     for (const [packageId, packageRecord] of Object.entries(packages)) {
-      if (packageRecord.coordinatorSession === coordinatorSession) {
+      if (sameCoordinatorSession(packageRecord.coordinatorSession, coordinatorSession)) {
         delete packages[packageId];
         removedAny = true;
       }
     }
-    if (state.orchestration.coordinatorQuestionState?.[coordinatorSession] !== undefined) {
-      delete state.orchestration.coordinatorQuestionState[coordinatorSession];
+    if (state.orchestration.coordinatorQuestionState?.[key] !== undefined) {
+      delete state.orchestration.coordinatorQuestionState[key];
       removedAny = true;
     }
-    if (state.orchestration.coordinatorRoutes?.[coordinatorSession] !== undefined) {
-      delete state.orchestration.coordinatorRoutes[coordinatorSession];
+    if (state.orchestration.coordinatorRoutes?.[key] !== undefined) {
+      delete state.orchestration.coordinatorRoutes[key];
       removedAny = true;
     }
     return removedAny;
   }
-  isResetCoordinatorSession(coordinatorSession) {
-    return coordinatorSession.includes(":reset-");
-  }
-  collectResetCoordinatorCandidates(state) {
-    const candidates = new Set;
-    for (const coordinatorSession of Object.keys(state.orchestration.coordinatorRoutes ?? {})) {
-      if (this.isResetCoordinatorSession(coordinatorSession)) {
-        candidates.add(coordinatorSession);
-      }
-    }
-    for (const task of Object.values(state.orchestration.tasks ?? {})) {
-      if (this.isResetCoordinatorSession(task.coordinatorSession)) {
-        candidates.add(task.coordinatorSession);
-      }
-    }
-    return [...candidates];
-  }
-  parseDateMs(value) {
-    if (!value) {
-      return null;
-    }
-    const ms = new Date(value).getTime();
-    return Number.isFinite(ms) ? ms : null;
-  }
-  resolveResetCoordinatorActivityAtMs(state, coordinatorSession) {
-    const routeUpdatedAt = state.orchestration.coordinatorRoutes?.[coordinatorSession]?.updatedAt;
-    const routeMs = this.parseDateMs(routeUpdatedAt);
-    let tasksMs = null;
-    for (const task of Object.values(state.orchestration.tasks ?? {})) {
-      if (task.coordinatorSession !== coordinatorSession) {
-        continue;
-      }
-      const candidate = this.parseDateMs(task.updatedAt);
-      if (candidate === null) {
-        continue;
-      }
-      tasksMs = tasksMs === null ? candidate : Math.max(tasksMs, candidate);
-    }
-    if (routeMs === null && tasksMs === null) {
-      return null;
-    }
-    if (routeMs === null) {
-      return tasksMs;
-    }
-    if (tasksMs === null) {
-      return routeMs;
-    }
-    return Math.max(routeMs, tasksMs);
-  }
-  cascadeRemoveCoordinatorRecords(state, coordinatorSession) {
-    const removed = {
-      tasks: 0,
-      workerBindings: 0,
-      groups: 0,
-      coordinatorRoutes: 0,
-      humanQuestionPackages: 0,
-      coordinatorQuestionState: 0
-    };
-    const tasks = state.orchestration.tasks;
-    for (const [taskId, task] of Object.entries(tasks ?? {})) {
-      if (task.coordinatorSession === coordinatorSession) {
-        delete tasks[taskId];
-        removed.tasks += 1;
-      }
-    }
-    const workerBindings = state.orchestration.workerBindings;
-    for (const [workerSession, binding] of Object.entries(workerBindings ?? {})) {
-      if (binding.coordinatorSession === coordinatorSession) {
-        delete workerBindings[workerSession];
-        removed.workerBindings += 1;
-      }
-    }
-    const groups = this.ensureGroups(state);
-    for (const [groupId, group] of Object.entries(groups ?? {})) {
-      if (group.coordinatorSession === coordinatorSession) {
-        delete groups[groupId];
-        removed.groups += 1;
-      }
-    }
-    if (state.orchestration.coordinatorRoutes?.[coordinatorSession] !== undefined) {
-      delete state.orchestration.coordinatorRoutes[coordinatorSession];
-      removed.coordinatorRoutes += 1;
-    }
-    const packages = this.ensureHumanQuestionPackages(state);
-    for (const [packageId, packageRecord] of Object.entries(packages ?? {})) {
-      if (packageRecord.coordinatorSession === coordinatorSession) {
-        delete packages[packageId];
-        removed.humanQuestionPackages += 1;
-      }
-    }
-    if (state.orchestration.coordinatorQuestionState?.[coordinatorSession] !== undefined) {
-      delete state.orchestration.coordinatorQuestionState[coordinatorSession];
-      removed.coordinatorQuestionState += 1;
-    }
-    return removed;
-  }
   bumpGroupUpdated(state, groupId, now) {
     if (!groupId) {
       return;
@@ -28077,7 +28465,7 @@ class OrchestrationService {
       }
       const validQueuedQuestions = coordinatorState.queuedQuestions.filter((entry) => {
         const task = state.orchestration.tasks[entry.taskId];
-        return task?.coordinatorSession === coordinatorSession && task.status === "blocked" && task.openQuestion?.status === "open" && task.openQuestion.questionId === entry.questionId;
+        return task !== undefined && sameCoordinatorSession(task.coordinatorSession, coordinatorSession) && task.status === "blocked" && task.openQuestion?.status === "open" && task.openQuestion.questionId === entry.questionId;
       });
       if (validQueuedQuestions.length !== coordinatorState.queuedQuestions.length) {
         coordinatorState.queuedQuestions = validQueuedQuestions;
@@ -28455,18 +28843,39 @@ class ScheduledTaskScheduler {
       return;
     this.ticking = true;
     try {
-      const dueTasks = await this.service.claimDueTasks();
+      let dueTasks;
+      try {
+        dueTasks = await this.service.claimDueTasks();
+      } catch (claimError) {
+        await this.logger?.error("scheduled.claim.failed", "claimDueTasks threw; skipping tick", { message: claimError instanceof Error ? claimError.message : String(claimError) });
+        return;
+      }
       for (const task of dueTasks) {
         try {
           await this.dispatchWithTimeout(task);
-          await this.service.markExecuted(task.id);
         } catch (error2) {
           const message = error2 instanceof Error ? error2.message : String(error2);
           await this.logger?.error("scheduled.dispatch.failed", "failed to dispatch scheduled task", {
             taskId: task.id,
             message
           });
-          await this.service.markFailed(task.id, error2);
+          try {
+            await this.service.markFailed(task.id, error2);
+          } catch (markError) {
+            await this.logger?.error("scheduled.dispatch.mark_failed", "markFailed threw; task state may be stale", {
+              taskId: task.id,
+              message: markError instanceof Error ? markError.message : String(markError)
+            });
+          }
+          continue;
+        }
+        try {
+          await this.service.markExecuted(task.id);
+        } 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,
+            message: markError instanceof Error ? markError.message : String(markError)
+          });
         }
       }
     } finally {
@@ -28566,7 +28975,7 @@ async function createScheduledTaskFromRoute(input, deps) {
   if (coordinatorSession.length === 0) {
     throw new Error("coordinatorSession must be a non-empty string");
   }
-  const route = deps.state.orchestration.coordinatorRoutes[coordinatorSession];
+  const route = deps.state.orchestration.coordinatorRoutes[stableCoordinatorSession(coordinatorSession)];
   if (!route) {
     throw new Error(`no chat route is recorded for coordinator session "${coordinatorSession}"`);
   }
@@ -28593,7 +29002,7 @@ async function createScheduledTaskFromRoute(input, deps) {
   if (!session3) {
     throw new Error(`session "${route.sessionAlias}" recorded for coordinator session "${coordinatorSession}" was not found`);
   }
-  if (session3.transportSession !== coordinatorSession) {
+  if (!sameCoordinatorSession(session3.transportSession, coordinatorSession)) {
     throw new Error(`session "${route.sessionAlias}" is no longer attached to coordinator session "${coordinatorSession}"`);
   }
   const executeAt = parseRouteScheduledTime(input.timeText, deps.now?.() ?? new Date);
@@ -28646,12 +29055,12 @@ var init_scheduled_route_create = __esm(() => {
 
 // src/scheduled/scheduled-route-manage.ts
 async function listScheduledTasksFromRoute(input, deps) {
-  resolveOwnedCoordinatorRoute(input.coordinatorSession, deps.state, "scheduled_list");
-  return deps.scheduled.listPending();
+  const route = resolveOwnedCoordinatorRoute(input.coordinatorSession, deps.state, "scheduled_list");
+  return deps.scheduled.listPending(route.chatKey);
 }
 async function cancelScheduledTaskFromRoute(input, deps) {
-  resolveOwnedCoordinatorRoute(input.coordinatorSession, deps.state, "scheduled_cancel");
-  const cancelled = await deps.scheduled.cancelPending(input.id);
+  const route = resolveOwnedCoordinatorRoute(input.coordinatorSession, deps.state, "scheduled_cancel");
+  const cancelled = await deps.scheduled.cancelPending(input.id, route.chatKey);
   return { id: normalizeId(input.id), cancelled };
 }
 function resolveOwnedCoordinatorRoute(coordinatorSession, state, label) {
@@ -28659,7 +29068,7 @@ function resolveOwnedCoordinatorRoute(coordinatorSession, state, label) {
   if (session3.length === 0) {
     throw new Error("coordinatorSession must be a non-empty string");
   }
-  const route = state.orchestration.coordinatorRoutes[session3];
+  const route = state.orchestration.coordinatorRoutes[stableCoordinatorSession(session3)];
   if (!route) {
     throw new Error(`no chat route is recorded for coordinator session "${session3}"`);
   }
@@ -28696,25 +29105,37 @@ class SessionService {
     const seen = new Set;
     const resolved = [];
     for (const session3 of Object.values(this.state.sessions)) {
-      if (seen.has(session3.transport_session)) {
+      let candidate;
+      try {
+        candidate = this.toResolvedSession(session3);
+      } catch {
         continue;
       }
-      seen.add(session3.transport_session);
-      try {
-        resolved.push(this.toResolvedSession(session3));
-      } catch {}
+      const key = JSON.stringify([
+        candidate.agent,
+        candidate.agentCommand ?? null,
+        candidate.cwd,
+        candidate.transportSession
+      ]);
+      if (seen.has(key)) {
+        continue;
+      }
+      seen.add(key);
+      resolved.push(candidate);
     }
     return resolved;
   }
   resolveSession(alias, agent3, workspace3, transportSession) {
     this.validateSession(alias, agent3, workspace3);
+    const existing = this.state.sessions[alias];
+    const sameAgentExisting = existing && existing.agent === agent3 ? existing : undefined;
     return this.toResolvedSession({
       alias,
       agent: agent3,
       workspace: workspace3,
       transport_session: transportSession,
-      transport_agent_command: this.state.sessions[alias]?.transport_agent_command,
-      created_at: this.state.sessions[alias]?.created_at ?? new Date().toISOString(),
+      transport_agent_command: sameAgentExisting?.transport_agent_command,
+      created_at: existing?.created_at ?? new Date().toISOString(),
       last_used_at: new Date().toISOString()
     });
   }
@@ -28751,9 +29172,10 @@ class SessionService {
     return this.state.chat_contexts[chatKey]?.current_session;
   }
   async getPreferredSessionForTransport(transportSession) {
-    const matches = Object.values(this.state.sessions).filter((session3) => session3.transport_session === transportSession).sort((left, right) => right.last_used_at.localeCompare(left.last_used_at));
-    const expectedAlias = transportSession.split(":").at(-1);
-    const expectedWorkspace = transportSession.split(":")[0];
+    const target = stableCoordinatorSession(transportSession);
+    const matches = Object.values(this.state.sessions).filter((session3) => stableCoordinatorSession(session3.transport_session) === target).sort((left, right) => right.last_used_at.localeCompare(left.last_used_at));
+    const expectedAlias = target.split(":").at(-1);
+    const expectedWorkspace = target.split(":")[0];
     const preferred = matches.find((session3) => session3.alias === expectedAlias && session3.workspace === expectedWorkspace) ?? matches[0];
     return preferred ? this.toResolvedSession(preferred) : null;
   }
@@ -28785,10 +29207,13 @@ class SessionService {
       const previousCurrent = prevCtx?.current_session;
       const carriedPrevious = previousCurrent && previousCurrent !== internalAlias ? previousCurrent : prevCtx?.previous_session;
       session3.last_used_at = new Date().toISOString();
-      this.state.chat_contexts[chatKey] = {
-        current_session: internalAlias,
-        ...carriedPrevious ? { previous_session: carriedPrevious } : {}
-      };
+      const nextCtx = { ...prevCtx, current_session: internalAlias };
+      if (carriedPrevious) {
+        nextCtx.previous_session = carriedPrevious;
+      } else {
+        delete nextCtx.previous_session;
+      }
+      this.state.chat_contexts[chatKey] = nextCtx;
       await this.persist();
       return {
         alias: toDisplaySessionAlias(session3.alias),
@@ -28815,10 +29240,13 @@ class SessionService {
       }
       const currentInternal = ctx?.current_session;
       prevSession.last_used_at = new Date().toISOString();
-      this.state.chat_contexts[chatKey] = {
-        current_session: prevInternal,
-        ...currentInternal && currentInternal !== prevInternal ? { previous_session: currentInternal } : {}
-      };
+      const nextCtx = { ...ctx, current_session: prevInternal };
+      if (currentInternal && currentInternal !== prevInternal) {
+        nextCtx.previous_session = currentInternal;
+      } else {
+        delete nextCtx.previous_session;
+      }
+      this.state.chat_contexts[chatKey] = nextCtx;
       await this.persist();
       return {
         alias: toDisplaySessionAlias(prevSession.alias),
@@ -28989,13 +29417,26 @@ class SessionService {
       const wasActive = Object.values(this.state.chat_contexts).some((ctx) => ctx.current_session === alias);
       delete this.state.sessions[alias];
       for (const [chatKey, ctx] of Object.entries(this.state.chat_contexts)) {
-        if (ctx.current_session === alias) {
-          delete this.state.chat_contexts[chatKey];
-          continue;
-        }
         if (ctx.previous_session === alias) {
           delete ctx.previous_session;
         }
+        if (ctx.current_session === alias) {
+          if (ctx.previous_session) {
+            ctx.current_session = ctx.previous_session;
+            delete ctx.previous_session;
+          } else {
+            ctx.current_session = "";
+          }
+        }
+        if (ctx.background_results && alias in ctx.background_results) {
+          delete ctx.background_results[alias];
+          if (Object.keys(ctx.background_results).length === 0) {
+            delete ctx.background_results;
+          }
+        }
+        if (!ctx.current_session && !ctx.previous_session && !ctx.background_results) {
+          delete this.state.chat_contexts[chatKey];
+        }
       }
       await this.persist();
       return { wasActive };
@@ -29109,6 +29550,7 @@ class SessionService {
         throw new Error(`transport session "${transportSession}" conflicts with an external coordinator`);
       }
       const existingSession = this.state.sessions[alias];
+      const sameAgentExisting = existingSession && existingSession.agent === agent3 ? existingSession : undefined;
       const now = new Date(this.now()).toISOString();
       const normalizedTransportAgentCommand = transportAgentCommand?.trim();
       const session3 = {
@@ -29121,9 +29563,9 @@ class SessionService {
         agent_session_title: native?.title ?? undefined,
         agent_session_updated_at: native?.updatedAt,
         attached_at: native ? now : undefined,
-        ...normalizedTransportAgentCommand ? { transport_agent_command: normalizedTransportAgentCommand } : existingSession?.transport_agent_command ? { transport_agent_command: existingSession.transport_agent_command } : {},
-        mode_id: existingSession?.mode_id,
-        reply_mode: existingSession?.reply_mode,
+        ...normalizedTransportAgentCommand ? { transport_agent_command: normalizedTransportAgentCommand } : sameAgentExisting?.transport_agent_command ? { transport_agent_command: sameAgentExisting.transport_agent_command } : {},
+        mode_id: sameAgentExisting?.mode_id,
+        reply_mode: sameAgentExisting?.reply_mode,
         created_at: existingSession?.created_at ?? now,
         last_used_at: now
       };
@@ -29305,7 +29747,6 @@ async function runConsole(paths, deps) {
   let runtime = null;
   let consumerLock;
   let heartbeatTimer = null;
-  let gcResetTimer = null;
   let consumerLockAcquired = false;
   let daemonRuntimeStarted = false;
   const shutdownController = new AbortController;
@@ -29319,12 +29760,6 @@ async function runConsole(paths, deps) {
     if (deps.afterBuild) {
       await deps.afterBuild(runtime);
     }
-    try {
-      await runtime.orchestration.service.purgeExpiredResetCoordinators({
-        cutoffDays: 7,
-        trigger: "startup"
-      });
-    } catch {}
     try {
       await runtime.orchestration.service.reconcileParallelSlots();
     } catch (reconcileError) {
@@ -29380,6 +29815,7 @@ async function runConsole(paths, deps) {
         throw error2;
       }
     }
+    await runtime.reapStaleQueueOwners();
     if (deps.beforeReady) {
       await deps.beforeReady(runtime);
     }
@@ -29393,10 +29829,6 @@ async function runConsole(paths, deps) {
       heartbeatTimer = setIntervalFn(() => {
         deps.daemonRuntime?.heartbeat().catch(() => {});
       }, deps.heartbeatIntervalMs ?? 30000);
-      const runtimeForGc = runtime;
-      gcResetTimer = setIntervalFn(() => {
-        runtimeForGc.orchestration.service.purgeExpiredResetCoordinators({ cutoffDays: 7, trigger: "interval" }).catch(() => {});
-      }, 86400000);
     }
     const channelStartPromise = deps.channels.startAll({
       agent: runtime.agent,
@@ -29451,7 +29883,6 @@ async function runConsole(paths, deps) {
       signalHandler,
       clearIntervalFn,
       heartbeatTimer,
-      gcResetTimer,
       ...deps.daemonRuntime ? { daemonRuntime: deps.daemonRuntime } : {},
       runtime,
       consumerLock,
@@ -29477,9 +29908,6 @@ async function runCleanupSequence(input) {
   if (input.heartbeatTimer !== null) {
     input.clearIntervalFn(input.heartbeatTimer);
   }
-  if (input.gcResetTimer !== null) {
-    input.clearIntervalFn(input.gcResetTimer);
-  }
   if (input.daemonRuntime && input.runtime) {
     try {
       await input.runtime.orchestration.server.stop();
@@ -29583,15 +30011,15 @@ class AcpxBridgeClient {
         onEvent
       });
       try {
-        const didWrite = this.writeLine(encodeBridgeRequest({
+        this.writeLine(encodeBridgeRequest({
           id,
           method,
           params
-        }));
-        if (didWrite === false) {
-          this.pending.delete(id);
-          reject(new Error("bridge write buffer is full"));
-        }
+        }), (error2) => {
+          if (error2 && this.pending.delete(id)) {
+            reject(error2);
+          }
+        });
       } catch (error2) {
         this.pending.delete(id);
         reject(error2);
@@ -29671,6 +30099,17 @@ class AcpxBridgeClient {
     }
   }
 }
+function buildBridgeSpawnEnv(options = {}) {
+  return {
+    XACPX_LANG: getLocale(),
+    XACPX_BRIDGE_ACPX_COMMAND: options.acpxCommand ?? "acpx",
+    XACPX_BRIDGE_PERMISSION_MODE: options.permissionMode ?? "approve-all",
+    XACPX_BRIDGE_NON_INTERACTIVE_PERMISSIONS: options.nonInteractivePermissions ?? "deny",
+    ...typeof options.permissionPolicy === "string" && options.permissionPolicy.trim().length > 0 ? { XACPX_BRIDGE_PERMISSION_POLICY: options.permissionPolicy } : {},
+    ...typeof options.queueOwnerTtlSeconds === "number" && Number.isFinite(options.queueOwnerTtlSeconds) ? { XACPX_BRIDGE_QUEUE_OWNER_TTL_SECONDS: String(options.queueOwnerTtlSeconds) } : {},
+    ...typeof options.sessionInitTimeoutMs === "number" && Number.isFinite(options.sessionInitTimeoutMs) && options.sessionInitTimeoutMs > 0 ? { XACPX_BRIDGE_SESSION_INIT_TIMEOUT_MS: String(options.sessionInitTimeoutMs) } : {}
+  };
+}
 function buildBridgeSpawnSpec(options) {
   if (options.execPath.endsWith("bun")) {
     return {
@@ -29693,15 +30132,17 @@ async function spawnAcpxBridgeClient(options = {}) {
     cwd: options.cwd ?? process.cwd(),
     env: {
       ...process.env,
-      XACPX_LANG: getLocale(),
-      XACPX_BRIDGE_ACPX_COMMAND: options.acpxCommand ?? "acpx",
-      XACPX_BRIDGE_PERMISSION_MODE: options.permissionMode ?? "approve-all",
-      XACPX_BRIDGE_NON_INTERACTIVE_PERMISSIONS: options.nonInteractivePermissions ?? "deny",
-      ...typeof options.queueOwnerTtlSeconds === "number" && Number.isFinite(options.queueOwnerTtlSeconds) ? { XACPX_BRIDGE_QUEUE_OWNER_TTL_SECONDS: String(options.queueOwnerTtlSeconds) } : {}
+      ...buildBridgeSpawnEnv(options)
     },
     stdio: ["pipe", "pipe", "inherit"]
   });
-  const client = new AcpxBridgeClient((line) => child.stdin.write(line));
+  const client = manageBridgeChild(child);
+  await client.waitUntilReady();
+  return client;
+}
+function manageBridgeChild(child) {
+  const client = new AcpxBridgeClient((line, onWriteError) => child.stdin.write(line, onWriteError));
+  child.stdin.on("error", () => {});
   const output = createInterface({
     input: child.stdout,
     crlfDelay: Infinity
@@ -29727,7 +30168,6 @@ async function spawnAcpxBridgeClient(options = {}) {
       await terminateProcessTree(child.pid ?? 0, { detachedProcessGroup: false });
     }
   };
-  await client.waitUntilReady();
   return client;
 }
 function awaitable(executor) {
@@ -30569,19 +31009,19 @@ var init_streaming_prompt = __esm(() => {
 
 // src/transport/acpx-cli/node-pty-helper.ts
 import { chmod as chmodFs } from "node:fs/promises";
-import { dirname as dirname13, join as join16 } from "node:path";
+import { dirname as dirname11, join as join16 } from "node:path";
 function resolveNodePtyHelperPath(packageJsonPath, platform, arch) {
   if (platform === "win32") {
     return null;
   }
-  return join16(dirname13(packageJsonPath), "prebuilds", `${platform}-${arch}`, "spawn-helper");
+  return join16(dirname11(packageJsonPath), "prebuilds", `${platform}-${arch}`, "spawn-helper");
 }
-async function ensureNodePtyHelperExecutable(helperPath, chmod3 = chmodFs) {
+async function ensureNodePtyHelperExecutable(helperPath, chmod5 = chmodFs) {
   if (!helperPath) {
     return;
   }
   try {
-    await chmod3(helperPath, 493);
+    await chmod5(helperPath, 493);
   } catch (error2) {
     if (error2.code === "ENOENT") {
       return;
@@ -30594,7 +31034,7 @@ 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 readFile12, unlink } from "node:fs/promises";
+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) {
@@ -30757,7 +31197,7 @@ async function terminateAcpxQueueOwner(sessionId) {
   const lockPath = queueLockFilePath(sessionId);
   let owner;
   try {
-    owner = JSON.parse(await readFile12(lockPath, "utf8"));
+    owner = JSON.parse(await readFile13(lockPath, "utf8"));
   } catch {
     return;
   }
@@ -31416,10 +31856,11 @@ async function reapQueueOwners(acpxCommand, targets, deps = {}) {
   const timeoutMs = deps.timeoutMs ?? 5000;
   const seen = new Set;
   const unique = targets.filter((target) => {
-    if (seen.has(target.transportSession)) {
+    const key = JSON.stringify([target.agent, target.agentCommand ?? null, target.cwd, target.transportSession]);
+    if (seen.has(key)) {
       return false;
     }
-    seen.add(target.transportSession);
+    seen.add(key);
     return true;
   });
   let terminated = 0;
@@ -31503,6 +31944,17 @@ var init_queue_owner_reaper = __esm(() => {
 });
 
 // src/transport/collect-reap-targets.ts
+function collectReapTargets(sessions, orchestration3, config4) {
+  return [
+    ...sessions.listAllResolvedSessions().map((session3) => ({
+      agent: session3.agent,
+      ...session3.agentCommand ? { agentCommand: session3.agentCommand } : {},
+      cwd: session3.cwd,
+      transportSession: session3.transportSession
+    })),
+    ...workerBindingReapTargets(orchestration3, config4)
+  ];
+}
 function workerBindingReapTargets(orchestration3, config4) {
   const targets = [];
   for (const [workerSession, binding] of Object.entries(orchestration3.workerBindings)) {
@@ -31560,10 +32012,21 @@ class MessageChannelRegistry {
       throw new Error("all channels failed to start");
     }
   }
-  stopAll() {
+  async stopAll() {
+    let firstError;
     for (const channel of this.channels.values()) {
-      channel.logout();
+      try {
+        if (channel.stop) {
+          await channel.stop();
+        } else {
+          channel.logout();
+        }
+      } catch (error2) {
+        firstError ??= error2;
+      }
     }
+    if (firstError !== undefined)
+      throw firstError;
   }
   getByChatKey(chatKey) {
     return this.channels.get(getChannelIdFromChatKey(chatKey)) ?? null;
@@ -31811,7 +32274,7 @@ __export(exports_main, {
 });
 import { randomUUID as randomUUID3 } from "node:crypto";
 import { homedir as homedir9 } from "node:os";
-import { dirname as dirname14, join as join18 } from "node:path";
+import { dirname as dirname12, join as join18 } from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 function startProgressHeartbeat(orchestration3, config4, logger2, channel) {
   const thresholdSeconds = config4.orchestration.progressHeartbeatSeconds;
@@ -31883,6 +32346,35 @@ async function buildApp(paths, deps = {}) {
   const acpxCommand = resolveAcpxCommand({ configuredCommand: config4.transport.command });
   const stateStore = new StateStore(paths.statePath);
   const state = await stateStore.load();
+  const stateLoadReport = stateStore.lastLoadReport;
+  if (stateLoadReport) {
+    for (const record3 of stateLoadReport.dropped) {
+      await logger2.error("state.record_quarantined", "dropped malformed state.json record", {
+        statePath: paths.statePath,
+        section: record3.section,
+        key: record3.key,
+        reason: record3.reason
+      });
+    }
+    if (stateLoadReport.corruptPath) {
+      await logger2.error("state.file_corrupt", "state.json was unreadable; renamed aside and starting empty", {
+        statePath: paths.statePath,
+        corruptPath: stateLoadReport.corruptPath
+      });
+    }
+    if (stateLoadReport.quarantinePath) {
+      await logger2.error("state.file_quarantined", "original state.json backed up before dropping records", {
+        statePath: paths.statePath,
+        quarantinePath: stateLoadReport.quarantinePath
+      });
+    }
+    if (stateLoadReport.backupError) {
+      await logger2.error("state.quarantine_backup_failed", "failed to back up the original state.json", {
+        statePath: paths.statePath,
+        message: stateLoadReport.backupError
+      });
+    }
+  }
   const stateMutex = new AsyncMutex;
   const debouncedStateStore = new DebouncedStateStore({
     delegate: stateStore,
@@ -31902,7 +32394,9 @@ async function buildApp(paths, deps = {}) {
     bridgeEntryPath: resolveBridgeEntryPath(),
     permissionMode: config4.transport.permissionMode,
     nonInteractivePermissions: config4.transport.nonInteractivePermissions,
-    ...typeof config4.transport.queueOwnerTtlSeconds === "number" ? { queueOwnerTtlSeconds: config4.transport.queueOwnerTtlSeconds } : {}
+    ...typeof config4.transport.permissionPolicy === "string" ? { permissionPolicy: config4.transport.permissionPolicy } : {},
+    ...typeof config4.transport.queueOwnerTtlSeconds === "number" ? { queueOwnerTtlSeconds: config4.transport.queueOwnerTtlSeconds } : {},
+    ...typeof config4.transport.sessionInitTimeoutMs === "number" ? { sessionInitTimeoutMs: config4.transport.sessionInitTimeoutMs } : {}
   })))) : deps.createCliTransport?.(acpxCommand) ?? new AcpxCliTransport({ ...config4.transport, command: acpxCommand });
   const quota = new QuotaManager({
     onInbound: (chatKey) => {
@@ -32224,7 +32718,7 @@ async function buildApp(paths, deps = {}) {
       }
     },
     findReusableWorkerSession: async ({ coordinatorSession, workspace: workspace3, cwd, targetAgent, role }) => {
-      const binding = Object.entries(state.orchestration.workerBindings).find(([, current]) => current.ephemeral !== true && current.coordinatorSession === coordinatorSession && current.workspace === workspace3 && current.cwd === cwd && current.targetAgent === targetAgent && current.role === role);
+      const binding = Object.entries(state.orchestration.workerBindings).find(([, current]) => current.ephemeral !== true && sameCoordinatorSession(current.coordinatorSession, coordinatorSession) && current.workspace === workspace3 && current.cwd === cwd && current.targetAgent === targetAgent && current.role === role);
       return binding?.[0] ?? null;
     },
     logger: logger2
@@ -32255,6 +32749,9 @@ async function buildApp(paths, deps = {}) {
   const progressHeartbeatInterval = startProgressHeartbeat(orchestration3, config4, logger2, deps.channel ?? null);
   const orchestrationEndpoint = createOrchestrationEndpoint(paths.orchestrationSocketPath ?? resolveOrchestrationSocketPathFromConfigPath(paths.configPath));
   const orchestrationServer = new OrchestrationServer(orchestrationEndpoint, orchestration3, {
+    onSocketHardenError: (error2) => {
+      logger2.error("orchestration.socket.chmod_failed", "failed to restrict orchestration socket to owner-only (0600); falling back to runtime dir permissions", { message: error2 instanceof Error ? error2.message : String(error2) });
+    },
     createScheduledTaskFromRoute: async (input) => await createScheduledTaskFromRoute(input, {
       state,
       config: config4,
@@ -32282,6 +32779,33 @@ async function buildApp(paths, deps = {}) {
     }),
     logger: logger2
   });
+  const reapWarmQueueOwners = async (phase) => {
+    try {
+      const targets = collectReapTargets(sessions, state.orchestration, config4);
+      if (targets.length === 0) {
+        return;
+      }
+      const { terminated, attempted } = await reapQueueOwners(acpxCommand, targets, {
+        onError: (target, error2) => {
+          logger2.info("transport.queue_owner_reap.failed", "failed to reap queue owner", {
+            phase,
+            transport_session: target.transportSession,
+            error: error2 instanceof Error ? error2.message : String(error2)
+          }).catch(() => {});
+        }
+      });
+      await logger2.info("transport.queue_owner_reap.completed", "reaped warm queue owners", {
+        phase,
+        terminated,
+        attempted
+      }).catch(() => {});
+    } catch (err) {
+      await logger2.error("transport.queue_owner_reap.error", "queue owner reap failed", {
+        phase,
+        error: err instanceof Error ? err.message : String(err)
+      }).catch(() => {});
+    }
+  };
   return {
     agent: agent3,
     router: router3,
@@ -32302,41 +32826,14 @@ async function buildApp(paths, deps = {}) {
       service: scheduledService,
       scheduler: scheduledScheduler
     },
+    reapStaleQueueOwners: () => reapWarmQueueOwners("startup"),
     dispose: async () => {
       scheduledScheduler.stop();
       if (progressHeartbeatInterval !== undefined) {
         clearInterval(progressHeartbeatInterval);
       }
       await Promise.allSettled([...pendingWorkerDispatches]);
-      try {
-        const targets = [
-          ...sessions.listAllResolvedSessions().map((session3) => ({
-            agent: session3.agent,
-            ...session3.agentCommand ? { agentCommand: session3.agentCommand } : {},
-            cwd: session3.cwd,
-            transportSession: session3.transportSession
-          })),
-          ...workerBindingReapTargets(state.orchestration, config4)
-        ];
-        if (targets.length > 0) {
-          const { terminated, attempted } = await reapQueueOwners(acpxCommand, targets, {
-            onError: (target, error2) => {
-              logger2.info("transport.queue_owner_reap.failed", "failed to reap queue owner on shutdown", {
-                transport_session: target.transportSession,
-                error: error2 instanceof Error ? error2.message : String(error2)
-              }).catch(() => {});
-            }
-          });
-          await logger2.info("transport.queue_owner_reap.completed", "reaped warm queue owners on shutdown", {
-            terminated,
-            attempted
-          }).catch(() => {});
-        }
-      } catch (err) {
-        await logger2.error("transport.queue_owner_reap.error", "queue owner reap failed during shutdown", {
-          error: err instanceof Error ? err.message : String(err)
-        }).catch(() => {});
-      }
+      await reapWarmQueueOwners("shutdown");
       await debouncedStateStore.dispose();
       if ("dispose" in transport && typeof transport.dispose === "function") {
         await transport.dispose();
@@ -32392,7 +32889,7 @@ async function main() {
   }
 }
 async function prepareChannelMedia(configPath, config4) {
-  const runtimeDir = join18(dirname14(configPath), "runtime");
+  const runtimeDir = join18(dirname12(configPath), "runtime");
   const mediaRootDir = join18(runtimeDir, "media");
   const mediaStore = new RuntimeMediaStore({ rootDir: mediaRootDir });
   await mediaStore.cleanupExpired().catch((error2) => {
@@ -32407,7 +32904,7 @@ function resolveRuntimePaths() {
     throw new Error("Unable to resolve the current user home directory");
   }
   const configPath = coreEnv("CONFIG") ?? join18(coreHomeDir(home), "config.json");
-  const runtimeDir = join18(dirname14(configPath), "runtime");
+  const runtimeDir = join18(dirname12(configPath), "runtime");
   return {
     configPath,
     statePath: coreEnv("STATE") ?? join18(coreHomeDir(home), "state.json"),
@@ -32422,12 +32919,12 @@ function resolveBridgeEntryPath() {
   return fileURLToPath5(new URL("./bridge/bridge-main.ts", import.meta.url));
 }
 function resolveAppLogPath(configPath) {
-  const rootDir = dirname14(configPath);
+  const rootDir = dirname12(configPath);
   const runtimeDir = join18(rootDir, "runtime");
   return join18(runtimeDir, "app.log");
 }
 function resolvePerfLogPath(configPath) {
-  const rootDir = dirname14(configPath);
+  const rootDir = dirname12(configPath);
   const runtimeDir = join18(rootDir, "runtime");
   return join18(runtimeDir, "perf.log");
 }
@@ -32823,7 +33320,7 @@ var init_orchestration_health = __esm(() => {
 // src/doctor/checks/runtime-check.ts
 import { constants } from "node:fs";
 import { access as access4, stat as stat3 } from "node:fs/promises";
-import { dirname as dirname15 } from "node:path";
+import { dirname as dirname13 } from "node:path";
 import { homedir as homedir11 } from "node:os";
 async function checkRuntime(options = {}) {
   const home = options.home ?? process.env.HOME ?? homedir11();
@@ -32924,7 +33421,7 @@ async function checkFileCreatable(label, path15, probe, platform) {
         detail: `${label}: ${path15} (unusable: ${formatError6(error2)})`
       };
     }
-    const parentCheck = await checkCreatableAncestorDirectory(dirname15(path15), probe, platform);
+    const parentCheck = await checkCreatableAncestorDirectory(dirname13(path15), probe, platform);
     if (!parentCheck.ok) {
       return {
         ok: false,
@@ -32960,7 +33457,7 @@ async function checkCreatableAncestorDirectory(path15, probe, platform) {
         blockingPath: path15
       };
     }
-    const parent = dirname15(path15);
+    const parent = dirname13(path15);
     if (parent === path15) {
       return {
         ok: false,
@@ -33485,11 +33982,13 @@ async function defaultCheckOrchestrationHealth(deps) {
   }
   try {
     const store = new StateStore(deps.runtimePaths.statePath);
-    return await checkOrchestrationHealth({
-      loadState: () => store.load(),
+    const inspection = await store.inspect();
+    const result = await checkOrchestrationHealth({
+      loadState: async () => inspection.state,
       now: () => new Date,
       heartbeatThresholdSeconds: config4.orchestration.progressHeartbeatSeconds
     });
+    return applyStateInspectionReport(result, inspection.report, deps.runtimePaths.statePath);
   } catch (error2) {
     return {
       id: "orchestration",
@@ -33500,6 +33999,27 @@ async function defaultCheckOrchestrationHealth(deps) {
     };
   }
 }
+function applyStateInspectionReport(result, report, statePath) {
+  if (!report) {
+    return result;
+  }
+  const fileCorrupt = report.dropped.some((record3) => record3.section === "file");
+  const details = [
+    ...result.details ?? [],
+    `state path: ${statePath}`,
+    ...report.dropped.map((record3) => record3.section === "file" ? `state.json is unreadable: ${record3.reason}` : `invalid state record ${record3.section}["${record3.key}"]: ${record3.reason}`)
+  ];
+  return {
+    ...result,
+    severity: result.severity === "fail" ? "fail" : "warn",
+    summary: fileCorrupt ? `state.json is unreadable and will be reset (renamed to state.json.corrupt-*) at next daemon startup; ${result.summary}` : `state.json has ${report.dropped.length} invalid record(s) that will be quarantined at next daemon startup; ${result.summary}`,
+    details,
+    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"
+    ]
+  };
+}
 function formatError9(error2) {
   return error2 instanceof Error ? error2.message : String(error2);
 }
@@ -33542,7 +34062,7 @@ var init_doctor2 = __esm(async () => {
 init_core_home();
 import { randomUUID as randomUUID4 } from "node:crypto";
 import { homedir as homedir13 } from "node:os";
-import { dirname as dirname16, join as join20, sep } from "node:path";
+import { dirname as dirname14, join as join20, sep } from "node:path";
 import { fileURLToPath as fileURLToPath7 } from "node:url";
 
 // src/runtime/migrate-core-home.ts
@@ -33626,8 +34146,8 @@ init_daemon_files();
 
 // src/daemon/daemon-runtime.ts
 init_daemon_status();
-import { mkdir as mkdir5, rm as rm3, writeFile as writeFile3 } from "node:fs/promises";
-import { dirname as dirname5 } from "node:path";
+init_private_runtime_dir();
+import { rm as rm3, writeFile as writeFile2 } from "node:fs/promises";
 
 class DaemonRuntime {
   paths;
@@ -33653,8 +34173,8 @@ class DaemonRuntime {
       stdout_log: this.paths.stdoutLog,
       stderr_log: this.paths.stderrLog
     };
-    await mkdir5(dirname5(this.paths.pidFile), { recursive: true });
-    await writeFile3(this.paths.pidFile, `${this.options.pid}
+    await ensurePrivateRuntimeDir(this.paths.runtimeDir);
+    await writeFile2(this.paths.pidFile, `${this.options.pid}
 `);
     await this.statusStore.save(this.currentStatus);
   }
@@ -46059,6 +46579,9 @@ function requireHome(env) {
   return home;
 }
 
+// src/mcp/xacpx-mcp-server.ts
+init_endpoint_probe();
+
 // src/mcp/xacpx-mcp-tools.ts
 init_task_watch_timeouts();
 init_quota_errors();
@@ -46326,7 +46849,7 @@ function buildXacpxMcpToolRegistry(input) {
     });
     tools.push({
       name: "scheduled_list",
-      description: "List pending one-shot scheduled tasks (global). Use to recover task ids before cancelling, or to see what is scheduled. Owner-only in group chats. Routing and account are resolved from the current session; pass no other arguments.",
+      description: "List pending one-shot scheduled tasks created in the current chat. Use to recover task ids before cancelling, or to see what is scheduled. Owner-only in group chats. Routing and account are resolved from the current session; pass no other arguments.",
       inputSchema: exports_external.object({}).strict(),
       handler: async () => await asToolResult(async () => {
         const tasks = await transport.scheduledList({ coordinatorSession });
@@ -46344,7 +46867,7 @@ function buildXacpxMcpToolRegistry(input) {
     });
     tools.push({
       name: "scheduled_cancel",
-      description: "Cancel a pending scheduled task by id. Owner-only in group chats. Returns whether a pending task with that id was found and cancelled. Routing is resolved from the current session.",
+      description: "Cancel a pending scheduled task by id (only tasks created in the current chat). Owner-only in group chats. Returns whether a pending task with that id was found and cancelled. Routing is resolved from the current session.",
       inputSchema: exports_external.object({
         id: exports_external.string().min(1).describe("The scheduled task id, e.g. 'k8f2' (a leading # is allowed).")
       }).strict(),
@@ -46574,7 +47097,7 @@ function formatToolError(error2) {
 init_orchestration_ipc();
 init_task_watch_timeouts();
 import { randomUUID } from "node:crypto";
-import { createConnection } from "node:net";
+import { createConnection as createConnection2 } from "node:net";
 
 class OrchestrationClient {
   endpoint;
@@ -46642,7 +47165,7 @@ class OrchestrationClient {
   async request(method, params, timeoutMs = this.timeoutMs) {
     const id = this.createId();
     return await new Promise((resolve, reject) => {
-      const socket = createConnection(this.endpoint.path);
+      const socket = createConnection2(this.endpoint.path);
       let buffer = "";
       let settled = false;
       let timer;
@@ -47285,7 +47808,9 @@ function installMcpStdioShutdownHooks(options) {
   const setIntervalFn = options.setIntervalFn ?? ((callback, ms) => setInterval(callback, ms));
   const clearIntervalFn = options.clearIntervalFn ?? ((handle) => clearInterval(handle));
   const parentPid = options.parentPid ?? process.ppid;
-  const parentCheckIntervalMs = options.parentCheckIntervalMs ?? parseParentCheckIntervalMs(coreEnv("MCP_PARENT_CHECK_INTERVAL_MS"));
+  const parentCheckIntervalMs = options.parentCheckIntervalMs ?? parseIntervalMs(coreEnv("MCP_PARENT_CHECK_INTERVAL_MS"), 5000);
+  const endpointCheckIntervalMs = options.endpointCheckIntervalMs ?? parseIntervalMs(coreEnv("MCP_ENDPOINT_CHECK_INTERVAL_MS"), 1e4);
+  const endpointFailureThreshold = options.endpointFailureThreshold ?? 3;
   let disposed = false;
   let triggered = false;
   const triggerShutdown = (reason, context) => {
@@ -47318,6 +47843,31 @@ function installMcpStdioShutdownHooks(options) {
     }, parentCheckIntervalMs);
     parentTimer.unref?.();
   }
+  let endpointTimer;
+  const probeEndpoint = options.probeEndpoint;
+  if (probeEndpoint && endpointCheckIntervalMs > 0 && endpointFailureThreshold > 0) {
+    let consecutiveDead = 0;
+    let probing = false;
+    const runEndpointCheck = async () => {
+      if (disposed || triggered || probing)
+        return;
+      probing = true;
+      try {
+        if (await probeEndpoint()) {
+          consecutiveDead = 0;
+          return;
+        }
+        consecutiveDead += 1;
+        if (consecutiveDead >= endpointFailureThreshold) {
+          triggerShutdown("daemon_endpoint_dead", { consecutiveFailures: consecutiveDead });
+        }
+      } catch {} finally {
+        probing = false;
+      }
+    };
+    endpointTimer = setIntervalFn(runEndpointCheck, endpointCheckIntervalMs);
+    endpointTimer.unref?.();
+  }
   return () => {
     if (disposed)
       return;
@@ -47332,13 +47882,16 @@ function installMcpStdioShutdownHooks(options) {
     if (parentTimer) {
       clearIntervalFn(parentTimer);
     }
+    if (endpointTimer) {
+      clearIntervalFn(endpointTimer);
+    }
   };
 }
-function parseParentCheckIntervalMs(raw) {
+function parseIntervalMs(raw, fallback) {
   if (raw === undefined || raw.trim().length === 0)
-    return 5000;
+    return fallback;
   const parsed = Number(raw);
-  return Number.isFinite(parsed) && parsed >= 0 ? parsed : 5000;
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback;
 }
 function errorContext(error2) {
   const record3 = error2;
@@ -47357,7 +47910,8 @@ function defaultIsProcessRunning3(pid) {
   }
 }
 async function runXacpxMcpServer(options) {
-  const transport = options.transport ?? createOrchestrationTransport(options.endpoint ?? resolveDefaultOrchestrationEndpoint(process.env, process.platform));
+  const endpoint = options.endpoint ?? resolveDefaultOrchestrationEndpoint(process.env, process.platform);
+  const transport = options.transport ?? createOrchestrationTransport(endpoint);
   const server = createXacpxMcpServer({
     transport,
     ...options.coordinatorSession ? { coordinatorSession: options.coordinatorSession } : {},
@@ -47390,6 +47944,7 @@ async function runXacpxMcpServer(options) {
     stdin,
     stdout,
     shutdown,
+    probeEndpoint: () => canConnectToEndpoint(endpoint.path, 4000),
     onDiagnostic: options.onDiagnostic
   });
   await server.connect(stdio);
@@ -47422,7 +47977,6 @@ function sanitizeMcpClientName(input) {
     fallback: "mcp-host"
   });
 }
-
 // src/mcp/parse-string-flag.ts
 function parseStringFlag(args, env, options) {
   let fromFlag = null;
@@ -47523,7 +48077,10 @@ async function maybeRunFirstUseOnboarding(input) {
   const agentExisted = Boolean(input.config.agents[agentName]);
   input.config.workspaces[workspaceName] = { cwd };
   input.config.agents[agentName] = template;
-  await input.saveConfig(input.config);
+  await input.saveFirstRunConfig({
+    workspace: { name: workspaceName, cwd },
+    agent: { name: agentName, config: template }
+  });
   const alias = `${workspaceName}:${agentName}`;
   input.deps.print(t().misc.onboardingCreatedWorkspace(workspaceName, alias));
   return {
@@ -47546,8 +48103,8 @@ function resolveTemplateChoice(answer, names) {
 // src/cli-update.ts
 init_plugin_home();
 import { spawn as spawn4 } from "node:child_process";
-import { readFile as readFile8 } from "node:fs/promises";
-import { dirname as dirname10, join as join11 } from "node:path";
+import { readFile as readFile9 } from "node:fs/promises";
+import { dirname as dirname8, join as join11 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // src/plugins/package-manager.ts
@@ -47555,9 +48112,14 @@ 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";
+function shellSpawnPlan(args) {
+  const shell = process.platform === "win32";
+  return { shell, args: shell ? args.map((arg) => `"${arg}"`) : args };
+}
 async function defaultRunCommand(command, args, options) {
   await new Promise((resolve, reject) => {
-    const child = spawn3(command, args, { cwd: options.cwd, stdio: "inherit" });
+    const plan = shellSpawnPlan(args);
+    const child = spawn3(command, plan.args, { cwd: options.cwd, stdio: "inherit", shell: plan.shell });
     child.on("error", reject);
     child.on("exit", (code) => {
       if (code === 0)
@@ -47569,7 +48131,8 @@ async function defaultRunCommand(command, args, options) {
 }
 async function silentRun(command, args, options) {
   await new Promise((resolve, reject) => {
-    const child = spawn3(command, args, { cwd: options.cwd, stdio: "ignore" });
+    const plan = shellSpawnPlan(args);
+    const child = spawn3(command, plan.args, { cwd: options.cwd, stdio: "ignore", shell: plan.shell });
     child.on("error", reject);
     child.on("exit", (code) => {
       if (code === 0)
@@ -47658,7 +48221,6 @@ async function handleUpdateCli(args, deps) {
       kind: "plugin",
       name: plugin.name,
       currentVersion: plugin.version,
-      pinned: Boolean(plugin.version),
       latestVersion: await latestOf(plugin.name)
     });
   }
@@ -47667,12 +48229,12 @@ async function handleUpdateCli(args, deps) {
     const target = targets[index];
     deps.print(`${index + 1}. ${formatTarget(target)}`);
   }
-  const unavailable = targets.filter((target) => !target.latestVersion || target.kind === "plugin" && !target.pinned);
+  const unavailable = targets.filter((target) => !target.latestVersion);
   if (all && unavailable.length > 0) {
     deps.print(t().cliUpdate.unavailableAborted(unavailable.map((target) => target.name).join(", ")));
     return 1;
   }
-  const candidates = targets.filter((target) => target.latestVersion && (target.kind !== "plugin" || target.pinned) && (target.successorPackage ? true : target.currentVersion !== target.latestVersion));
+  const candidates = targets.filter((target) => target.latestVersion && (target.successorPackage ? true : target.currentVersion !== target.latestVersion));
   const selected = await selectTargets(targets, candidates, { all, explicitTarget: explicitTargets[0], deps });
   if (!selected.ok) {
     deps.print(selected.message);
@@ -47746,7 +48308,7 @@ async function handleUpdateCli(args, deps) {
   }
   if (selected.targets.some((target) => target.kind === "plugin")) {
     config4.plugins = updatedPlugins;
-    await deps.saveConfig(config4);
+    await deps.savePlugins(updatedPlugins);
   }
   return 0;
 }
@@ -47765,8 +48327,6 @@ async function selectTargets(targets, candidates, input) {
       return { ok: false, message: t().cliUpdate.targetNotFound(input.explicitTarget), exitCode: 1 };
     if (!target.latestVersion)
       return { ok: false, message: t().cliUpdate.targetVersionUnknown(target.name), exitCode: 1 };
-    if (target.kind === "plugin" && !target.pinned)
-      return { ok: false, message: t().cliUpdate.targetNotPinned(target.name), exitCode: 1 };
     if (!target.successorPackage && target.currentVersion === target.latestVersion)
       return { ok: true, targets: [] };
     return { ok: true, targets: [target] };
@@ -47790,8 +48350,6 @@ async function selectTargets(targets, candidates, input) {
     const target = targets[index - 1];
     if (!target.latestVersion)
       return { ok: false, message: t().cliUpdate.targetVersionUnknown(target.name), exitCode: 1 };
-    if (target.kind === "plugin" && !target.pinned)
-      return { ok: false, message: t().cliUpdate.targetNotPinned(target.name), exitCode: 1 };
     if (!target.successorPackage && target.currentVersion === target.latestVersion)
       continue;
     if (!selected.includes(target))
@@ -47860,9 +48418,10 @@ function compareSemver2(a, b) {
     return 0;
   return left.prerelease ? -1 : 1;
 }
+var spawnUsesShell = () => process.platform === "win32";
 async function runCapture(command, args) {
   return await new Promise((resolve, reject) => {
-    const child = spawn4(command, args, { stdio: ["ignore", "pipe", "pipe"] });
+    const child = spawn4(command, args, { stdio: ["ignore", "pipe", "pipe"], shell: spawnUsesShell() });
     let stdout2 = "";
     let stderr = "";
     child.stdout.setEncoding("utf8");
@@ -47879,7 +48438,7 @@ async function runCapture(command, args) {
 }
 async function runInherit(command, args) {
   await new Promise((resolve, reject) => {
-    const child = spawn4(command, args, { stdio: "inherit" });
+    const child = spawn4(command, args, { stdio: "inherit", shell: spawnUsesShell() });
     child.on("error", reject);
     child.on("exit", (code) => {
       if (code === 0)
@@ -47891,10 +48450,10 @@ async function runInherit(command, args) {
 }
 async function readPackageName() {
   try {
-    const here = dirname10(fileURLToPath3(import.meta.url));
+    const here = dirname8(fileURLToPath3(import.meta.url));
     for (const candidate of [join11(here, "..", "package.json"), join11(here, "..", "..", "package.json")]) {
       try {
-        const parsed = JSON.parse(await readFile8(candidate, "utf8"));
+        const parsed = JSON.parse(await readFile9(candidate, "utf8"));
         if (typeof parsed.name === "string" && parsed.name.trim())
           return parsed.name.trim();
       } catch {}
@@ -48136,7 +48695,7 @@ async function addChannel(type, rawArgs, deps) {
     return 1;
   }
   config4.channels = [...config4.channels ?? [], candidate];
-  await deps.saveConfig(config4);
+  await deps.saveChannels(config4.channels);
   deps.print(t().channelCli.channelAdded(type));
   for (const line of provider.renderSummary(candidate))
     deps.print(line);
@@ -48237,7 +48796,7 @@ async function removeChannel(type, rawArgs, deps) {
     return 1;
   }
   config4.channels = config4.channels.filter((entry) => entry.id !== channel.id);
-  await deps.saveConfig(config4);
+  await deps.saveChannels(config4.channels);
   deps.print(t().channelCli.channelRemoved(channel.id));
   return await maybeRestartAfterMutation(restartFlags.restart, deps);
 }
@@ -48259,7 +48818,7 @@ async function setChannelEnabled(type, enabled, rawArgs, deps) {
     return 1;
   }
   channel.enabled = enabled;
-  await deps.saveConfig(config4);
+  await deps.saveChannels(config4.channels);
   deps.print(t().channelCli.channelEnabledToggled(channel.id, enabled));
   return await maybeRestartAfterMutation(restartFlags.restart, deps);
 }
@@ -48281,7 +48840,7 @@ async function setChannelReplyMode(type, mode, rawArgs, deps) {
     return 1;
   }
   channel.replyMode = mode;
-  await deps.saveConfig(config4);
+  await deps.saveChannels(config4.channels);
   deps.print(t().channelCli.channelReplyModeSet(channel.id, mode));
   return await maybeRestartAfterMutation(restartFlags.restart, deps);
 }
@@ -48427,7 +48986,7 @@ async function addChannelAccount(type, accountId, rawArgs, deps) {
     deps.print(validation.map((issue2) => issue2.message).join("；"));
     return 1;
   }
-  await deps.saveConfig(config4);
+  await deps.saveChannels(config4.channels);
   deps.print(t().channelCli.channelAccountAdded(type, accountId));
   if (reEnabledChannel)
     deps.print(t().channelCli.channelReEnabled(type));
@@ -48467,7 +49026,7 @@ async function removeChannelAccount(type, accountId, rawArgs, deps) {
       return 1;
     }
     config4.channels = config4.channels.filter((channel) => channel.id !== existing.id);
-    await deps.saveConfig(config4);
+    await deps.saveChannels(config4.channels);
     deps.print(t().channelCli.channelAccountRemovedWithChannel(type, accountId));
     return await maybeRestartAfterMutation(restartFlags.restart, deps);
   }
@@ -48484,7 +49043,7 @@ async function removeChannelAccount(type, accountId, rawArgs, deps) {
     deps.print(t().channelCli.channelAccountDefaultSwitched(options.defaultAccount));
   }
   existing.options = options;
-  await deps.saveConfig(config4);
+  await deps.saveChannels(config4.channels);
   deps.print(t().channelCli.channelAccountRemoved(type, accountId));
   return await maybeRestartAfterMutation(restartFlags.restart, deps);
 }
@@ -48538,7 +49097,7 @@ async function setChannelAccountEnabled(type, accountId, enabled, rawArgs, deps)
     return 1;
   }
   existing.options = options;
-  await deps.saveConfig(config4);
+  await deps.saveChannels(config4.channels);
   deps.print(t().channelCli.channelAccountEnabledToggled(type, accountId, enabled));
   return await maybeRestartAfterMutation(restartFlags.restart, deps);
 }
@@ -48546,7 +49105,7 @@ async function setChannelAccountEnabled(type, accountId, enabled, rawArgs, deps)
 // src/plugins/plugin-cli.ts
 init_core_home();
 init_plugin_home();
-import { readFile as readFile10 } from "node:fs/promises";
+import { readFile as readFile11 } from "node:fs/promises";
 import { isAbsolute, join as join13, resolve } from "node:path";
 init_plugin_loader();
 init_validate_plugin();
@@ -48556,14 +49115,15 @@ init_channel_scope();
 init_plugin_loader();
 init_validate_plugin();
 init_known_plugins();
-import { readFile as readFile9 } from "node:fs/promises";
+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 readFile9(join12(pluginHome, "package.json"), "utf8");
+    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 ?? {})) {
@@ -48587,8 +49147,8 @@ async function inspectPlugins(input) {
   }
   const importPlugin = input.importPlugin ?? importPluginFromHome;
   const allConfigured = input.config.plugins;
-  const filterByName = input.pluginName ?? null;
-  if (filterByName && !allConfigured.some((plugin) => plugin.name === filterByName)) {
+  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) => {
@@ -48635,6 +49195,8 @@ async function inspectPlugins(input) {
   }
   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);
@@ -48662,12 +49224,31 @@ async function inspectPlugins(input) {
 init_known_plugins();
 init_plugin_renames();
 init_i18n();
+function findPluginSpecViolation(spec, platform) {
+  if (spec.includes('"'))
+    return "double-quote";
+  if (platform === "win32" && spec.includes("%"))
+    return "percent-on-windows";
+  return null;
+}
+function invalidSpecMessage(specs, platform) {
+  for (const spec of specs) {
+    if (!spec)
+      continue;
+    const violation = findPluginSpecViolation(spec, platform);
+    if (violation === "double-quote")
+      return t().pluginCli.pluginSpecHasDoubleQuote(spec);
+    if (violation === "percent-on-windows")
+      return t().pluginCli.pluginSpecHasPercentOnWindows(spec);
+  }
+  return null;
+}
 function looksLikePath(spec) {
   return spec === "." || spec.startsWith("./") || spec.startsWith("../") || spec.startsWith("/") || spec.startsWith(".\\") || spec.startsWith("..\\") || spec.startsWith("\\") || /^[a-zA-Z]:[\\/]/.test(spec) || isAbsolute(spec);
 }
 async function readDependencyEntries2(pluginHome) {
   try {
-    const raw = await readFile10(join13(pluginHome, "package.json"), "utf8");
+    const raw = await readFile11(join13(pluginHome, "package.json"), "utf8");
     const parsed = JSON.parse(raw);
     const out = {};
     for (const [name, value] of Object.entries(parsed.dependencies ?? {})) {
@@ -48693,7 +49274,7 @@ async function resolveLocalPluginName(installSpec, pluginHome, namesBeforeInstal
       return name;
   }
   try {
-    const raw = await readFile10(join13(installSpec, "package.json"), "utf8");
+    const raw = await readFile11(join13(installSpec, "package.json"), "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed.name === "string" && parsed.name.trim())
       return parsed.name.trim();
@@ -48836,6 +49417,11 @@ async function addPlugin(packageSpec, rawArgs, deps) {
     deps.print(t().pluginCli.unrecognizedArgs(flags.rest.join(" ")));
     return 1;
   }
+  const invalidSpec = invalidSpecMessage([packageSpec, flags.version], deps.platform ?? process.platform);
+  if (invalidSpec) {
+    deps.print(invalidSpec);
+    return 1;
+  }
   const pluginHome = deps.pluginHome ?? resolvePluginHome();
   await ensurePluginHome(pluginHome);
   const installSpec = looksLikePath(packageSpec) && !isAbsolute(packageSpec) ? resolve(process.cwd(), packageSpec) : packageSpec;
@@ -48873,7 +49459,7 @@ async function addPlugin(packageSpec, rawArgs, deps) {
   } else {
     config4.plugins = [...config4.plugins, next];
   }
-  await deps.saveConfig(config4);
+  await deps.savePlugins(config4.plugins);
   deps.print(t().pluginCli.pluginInstalled(recordedName));
   if (summary.channels.length > 0) {
     deps.print(t().pluginCli.providesChannels(summary.channels.join(", ")));
@@ -48899,7 +49485,7 @@ async function removePlugin(packageName, rawArgs, deps) {
   }
   const pluginHome = deps.pluginHome ?? resolvePluginHome();
   const validate = deps.validateInstalledPlugin ?? ((name) => validateInstalledPluginDefault(name, pluginHome));
-  const guard = await dependencyGuard(packageName, config4, validate);
+  const guard = await dependencyGuard(existing.name, config4, validate);
   if (!guard.allow) {
     if (guard.reason)
       deps.print(guard.reason);
@@ -48909,14 +49495,14 @@ async function removePlugin(packageName, rawArgs, deps) {
     await removePluginPackage({ packageName: name, pluginHome });
   });
   try {
-    await remove(packageName);
+    await remove(existing.name);
   } catch (error2) {
-    deps.print(t().pluginCli.pluginUninstallFailed(packageName, describeError(error2)));
+    deps.print(t().pluginCli.pluginUninstallFailed(existing.name, describeError(error2)));
     return 1;
   }
-  config4.plugins = config4.plugins.filter((entry) => entry.name !== packageName);
-  await deps.saveConfig(config4);
-  deps.print(t().pluginCli.pluginRemoved(packageName));
+  config4.plugins = config4.plugins.filter((entry) => entry.name !== existing.name);
+  await deps.savePlugins(config4.plugins);
+  deps.print(t().pluginCli.pluginRemoved(existing.name));
   return await maybeRestartAfterMutation2(flags.restart, deps);
 }
 async function updatePlugins(args, deps) {
@@ -48936,6 +49522,11 @@ async function updatePlugins(args, deps) {
     deps.print("--all cannot be combined with --version");
     return 1;
   }
+  const invalidSpec = invalidSpecMessage([flags.version], deps.platform ?? process.platform);
+  if (invalidSpec) {
+    deps.print(invalidSpec);
+    return 1;
+  }
   const config4 = await deps.loadConfig();
   ensurePluginsArray(config4);
   const pluginHome = deps.pluginHome ?? resolvePluginHome();
@@ -48992,7 +49583,7 @@ async function updatePlugins(args, deps) {
       deps.print(t().pluginCli.providesChannels(summary.channels.join(", ")));
     }
   }
-  await deps.saveConfig(config4);
+  await deps.savePlugins(config4.plugins);
   return await maybeRestartAfterMutation2(flags.restart, deps);
 }
 async function setPluginEnabled(packageName, enabled, rawArgs, deps) {
@@ -49023,7 +49614,7 @@ async function setPluginEnabled(packageName, enabled, rawArgs, deps) {
     }
   }
   existing.enabled = enabled;
-  await deps.saveConfig(config4);
+  await deps.savePlugins(config4.plugins);
   deps.print(t().pluginCli.pluginEnabledToggled(packageName, enabled));
   return await maybeRestartAfterMutation2(flags.restart, deps);
 }
@@ -49205,7 +49796,7 @@ init_i18n();
 init_bootstrap();
 async function prepareMcpCoordinatorStartup(input) {
   const coordinatorSession = input.coordinatorSession.trim();
-  const existingSession = Object.values(input.state.sessions).find((session3) => session3.transport_session === coordinatorSession);
+  const existingSession = Object.values(input.state.sessions).find((session3) => stableCoordinatorSession(session3.transport_session) === stableCoordinatorSession(coordinatorSession));
   const workspace3 = input.workspace?.trim();
   if (workspace3) {
     if (existingSession) {
@@ -49251,10 +49842,10 @@ function createMcpStdioIdentityResolver(input) {
     const workspace3 = input.workspace?.trim() || null;
     const sourceHandle = input.sourceHandle?.trim() || null;
     const resolvedWorkspace = workspace3;
-    const resolvedCoordinatorSession = parsedCoordinatorSession ?? inferExternalCoordinatorSession({
+    const resolvedCoordinatorSession = stableCoordinatorSession(parsedCoordinatorSession ?? inferExternalCoordinatorSession({
       clientName: context.clientName,
       ...resolvedWorkspace ? { workspace: resolvedWorkspace } : { instanceId }
-    });
+    }));
     const startup = await prepareMcpCoordinatorStartup({
       coordinatorSession: resolvedCoordinatorSession,
       ...resolvedWorkspace ? { workspace: resolvedWorkspace } : {},
@@ -49541,7 +50132,9 @@ async function defaultUpdate(args, input) {
   const store = await createCliConfigStore();
   const deps = {
     loadConfig: async () => await store.load(),
-    saveConfig: async (config4) => await store.save(config4),
+    savePlugins: async (plugins) => {
+      await store.replacePlugins(plugins);
+    },
     readCurrentVersion: readVersion,
     print: input.print,
     isInteractive: input.isInteractive ?? defaultIsInteractive,
@@ -49550,6 +50143,27 @@ async function defaultUpdate(args, input) {
   };
   return await handleUpdateCli(args, deps);
 }
+function warnStateLoadReport(store, writeStderr = (text) => process.stderr.write(text)) {
+  const report = store.lastLoadReport;
+  if (!report)
+    return;
+  for (const record3 of report.dropped) {
+    writeStderr(`[xacpx] state.record_quarantined section=${record3.section}${record3.key ? ` key=${record3.key}` : ""} reason=${record3.reason}
+`);
+  }
+  if (report.corruptPath) {
+    writeStderr(`[xacpx] state.file_corrupt unreadable state.json renamed to ${report.corruptPath}
+`);
+  }
+  if (report.quarantinePath) {
+    writeStderr(`[xacpx] state.file_quarantined original state.json backed up to ${report.quarantinePath}
+`);
+  }
+  if (report.backupError) {
+    writeStderr(`[xacpx] state.quarantine_backup_failed ${report.backupError}
+`);
+  }
+}
 async function runOnboardingBeforeStart(input) {
   const runtimePaths = (await init_main().then(() => exports_main)).resolveRuntimePaths();
   await ensureConfigExists(runtimePaths.configPath);
@@ -49557,10 +50171,14 @@ async function runOnboardingBeforeStart(input) {
   const stateStore = new StateStore(runtimePaths.statePath);
   const config4 = await configStore.load();
   const state = await stateStore.load();
+  warnStateLoadReport(stateStore);
   const result = await maybeRunFirstUseOnboarding({
     config: config4,
     state,
-    saveConfig: async (next) => await configStore.save(next),
+    saveFirstRunConfig: async ({ workspace: workspace3, agent: agent3 }) => {
+      await configStore.upsertWorkspace(workspace3.name, workspace3.cwd);
+      await configStore.upsertAgent(agent3.name, agent3.config);
+    },
     deps: {
       print: input.print,
       cwd: input.cwd,
@@ -49771,7 +50389,7 @@ async function handleLaterCli(args, deps) {
 }
 async function laterList(print) {
   const scheduled = await createCliScheduledTaskService();
-  print(renderLaterList(scheduled.listPending(), (alias) => toDisplaySessionAlias(alias)));
+  print(renderLaterList(scheduled.listPendingAllChats(), (alias) => toDisplaySessionAlias(alias)));
   return 0;
 }
 async function laterCancel(rawId, print) {
@@ -49781,7 +50399,7 @@ async function laterCancel(rawId, print) {
     return 1;
   }
   const scheduled = await createCliScheduledTaskService();
-  const ok = await scheduled.cancelPending(id);
+  const ok = await scheduled.cancelPendingAnyChat(id);
   if (!ok) {
     print(t().cli.laterNotFound(id));
     print(t().cli.laterNotFoundHint);
@@ -49794,6 +50412,7 @@ async function createCliScheduledTaskService() {
   const runtimePaths = (await init_main().then(() => exports_main)).resolveRuntimePaths();
   const stateStore = new StateStore(runtimePaths.statePath);
   const state = await stateStore.load();
+  warnStateLoadReport(stateStore);
   return new ScheduledTaskService(state, stateStore);
 }
 function resolveConfigPathForCurrentEnv() {
@@ -49896,14 +50515,12 @@ async function createFirstRunSession(runtime, plan) {
 }
 async function rollbackFirstRunConfig(runtime, plan) {
   try {
-    const config4 = await runtime.configStore.load();
-    if (!plan.rollback.workspaceExisted && config4.workspaces[plan.workspace]) {
-      delete config4.workspaces[plan.workspace];
+    if (!plan.rollback.workspaceExisted) {
+      await runtime.configStore.removeWorkspace(plan.workspace);
     }
-    if (!plan.rollback.agentExisted && config4.agents[plan.agent]) {
-      delete config4.agents[plan.agent];
+    if (!plan.rollback.agentExisted) {
+      await runtime.configStore.removeAgent(plan.agent);
     }
-    await runtime.configStore.save(config4);
   } catch (error2) {
     await runtime.logger.error("onboarding.rollback_failed", "failed to roll back first-run config", {
       alias: plan.alias,
@@ -49935,7 +50552,9 @@ async function defaultMcpStdio(args, deps = {}) {
     await ensureConfigExists(runtimePaths.configPath);
     const config4 = await loadConfig(runtimePaths.configPath);
     availableAgents = Object.keys(config4.agents);
-    const state = await new StateStore(runtimePaths.statePath).load();
+    const stateStore = new StateStore(runtimePaths.statePath);
+    const state = await stateStore.load();
+    warnStateLoadReport(stateStore, deps.stderr ?? ((text) => process.stderr.write(text)));
     const resolveIdentity = createMcpStdioIdentityResolver({
       parsedCoordinatorSession,
       sourceHandle,
@@ -49999,7 +50618,9 @@ async function createChannelCliDeps(input) {
   const controller = input.controller ?? createDefaultController();
   const base = {
     loadConfig: async () => await store.load(),
-    saveConfig: async (config4) => await store.save(config4),
+    saveChannels: async (channels) => {
+      await store.replaceChannels(channels);
+    },
     print: input.print,
     stderr: input.stderr ?? ((text) => process.stderr.write(text)),
     isInteractive: input.isInteractive ?? defaultIsInteractive,
@@ -50022,7 +50643,9 @@ async function createPluginCliDeps(input) {
   const controller = input.controller ?? createDefaultController();
   const base = {
     loadConfig: async () => await store.load(),
-    saveConfig: async (config4) => await store.save(config4),
+    savePlugins: async (plugins) => {
+      await store.replacePlugins(plugins);
+    },
     print: input.print,
     isInteractive: input.isInteractive ?? defaultIsInteractive,
     promptText: input.promptText ?? defaultPromptText,
@@ -50164,7 +50787,7 @@ function safeDaemonLogPaths() {
     const configPath = resolveConfigPathForCurrentEnv();
     const paths = resolveDaemonPathsForCurrentConfig();
     return {
-      appLog: join20(dirname16(configPath), "runtime", "app.log"),
+      appLog: join20(dirname14(configPath), "runtime", "app.log"),
       stderrLog: paths.stderrLog
     };
   } catch {