@ganglion/xacpx 0.9.2 → 0.9.3

package/dist/cli.js

@@ -851,7 +851,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}`,
@@ -1922,7 +1921,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}`,
@@ -11959,6 +11957,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 +12047,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)
@@ -21516,7 +21557,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 +21640,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 +21975,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 +21983,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 +22000,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 +22016,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 +22032,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 +22051,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 +22074,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 +22093,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 +22109,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 +22125,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 +22139,7 @@ async function handleTaskApprove(context, chatKey, taskId) {
   }
   const approved = await orchestration3.approveTask({
     taskId,
-    coordinatorSession: session3.transportSession
+    coordinatorSession
   });
   return { text: renderTaskApprovalSuccess2(approved) };
 }
@@ -22098,12 +22148,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 +22162,7 @@ async function handleTaskReject(context, chatKey, taskId) {
   }
   const rejected = await orchestration3.cancelTask({
     taskId,
-    coordinatorSession: session3.transportSession
+    coordinatorSession
   });
   return { text: renderTaskRejectSuccess(rejected) };
 }
@@ -22120,17 +22171,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 +22191,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) {
@@ -24204,7 +24257,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;
@@ -24455,7 +24508,7 @@ 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 { createServer } from "node:net";
 
 class OrchestrationServer {
   endpoint;
@@ -24683,7 +24736,7 @@ class OrchestrationServer {
     if (!task) {
       return null;
     }
-    if (task.coordinatorSession !== coordinatorSession) {
+    if (!sameCoordinatorSession(task.coordinatorSession, coordinatorSession)) {
       return null;
     }
     return task;
@@ -24948,29 +25001,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 +25023,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 +25224,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 +25236,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 +25726,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 +25785,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 +25804,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 +25977,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 +26035,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 +26050,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 +26301,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 +26403,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 +26418,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 +26487,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 +26627,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 +26637,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 +26657,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 +26677,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 +26694,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 +26724,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 +26939,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 +27366,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 +27408,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 +27512,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 +27531,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 +27542,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 +27730,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 +27741,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 +27938,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;
@@ -28566,7 +28427,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 +28454,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);
@@ -28659,7 +28520,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}"`);
   }
@@ -28751,9 +28612,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;
   }
@@ -29305,7 +29167,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 +29180,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 +29235,7 @@ async function runConsole(paths, deps) {
         throw error2;
       }
     }
+    await runtime.reapStaleQueueOwners();
     if (deps.beforeReady) {
       await deps.beforeReady(runtime);
     }
@@ -29393,10 +29249,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 +29303,6 @@ async function runConsole(paths, deps) {
       signalHandler,
       clearIntervalFn,
       heartbeatTimer,
-      gcResetTimer,
       ...deps.daemonRuntime ? { daemonRuntime: deps.daemonRuntime } : {},
       runtime,
       consumerLock,
@@ -29477,9 +29328,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();
@@ -31503,6 +31351,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)) {
@@ -32224,7 +32083,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
@@ -32282,6 +32141,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 +32188,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();
@@ -46059,6 +45918,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();
@@ -46574,7 +46436,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 +46504,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 +47147,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 +47182,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 +47221,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 +47249,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 +47283,7 @@ async function runXacpxMcpServer(options) {
     stdin,
     stdout,
     shutdown,
+    probeEndpoint: () => canConnectToEndpoint(endpoint.path, 4000),
     onDiagnostic: options.onDiagnostic
   });
   await server.connect(stdio);
@@ -47422,7 +47316,6 @@ function sanitizeMcpClientName(input) {
     fallback: "mcp-host"
   });
 }
-
 // src/mcp/parse-string-flag.ts
 function parseStringFlag(args, env, options) {
   let fromFlag = null;
@@ -47658,7 +47551,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 +47559,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);
@@ -47765,8 +47657,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 +47680,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))
@@ -49205,7 +49093,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 +49139,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 } : {},