@ganglion/xacpx 0.24.3-beta.1 → 0.24.4-beta.0

package/dist/adapters/adapter-catalog.d.ts

@@ -2,12 +2,12 @@ export declare const MANAGED_ADAPTERS: {
     readonly codex: {
         readonly packageName: "@agentclientprotocol/codex-acp";
         readonly binName: "codex-acp";
-        readonly defaultVersion: "1.1.9";
+        readonly defaultVersion: "1.10.0";
     };
     readonly claude: {
         readonly packageName: "@agentclientprotocol/claude-agent-acp";
         readonly binName: "claude-agent-acp";
-        readonly defaultVersion: "0.64.2";
+        readonly defaultVersion: "0.75.1";
     };
 };
 export type ManagedAdapterId = keyof typeof MANAGED_ADAPTERS;

package/dist/bridge/bridge-main.js

@@ -7254,12 +7254,12 @@ var init_adapter_catalog = __esm(() => {
     codex: {
       packageName: "@agentclientprotocol/codex-acp",
       binName: "codex-acp",
-      defaultVersion: "1.1.9"
+      defaultVersion: "1.10.0"
     },
     claude: {
       packageName: "@agentclientprotocol/claude-agent-acp",
       binName: "claude-agent-acp",
-      defaultVersion: "0.64.2"
+      defaultVersion: "0.75.1"
     }
   };
   EXACT_SEMVER = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;

package/dist/bridge/engine/runtime/runtime-worker-main.js

@@ -5789,12 +5789,12 @@ var init_adapter_catalog = __esm(() => {
     codex: {
       packageName: "@agentclientprotocol/codex-acp",
       binName: "codex-acp",
-      defaultVersion: "1.1.9"
+      defaultVersion: "1.10.0"
     },
     claude: {
       packageName: "@agentclientprotocol/claude-agent-acp",
       binName: "claude-agent-acp",
-      defaultVersion: "0.64.2"
+      defaultVersion: "0.75.1"
     }
   };
   EXACT_SEMVER = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;

package/dist/cli.js

@@ -4355,12 +4355,12 @@ var init_adapter_catalog = __esm(() => {
     codex: {
       packageName: "@agentclientprotocol/codex-acp",
       binName: "codex-acp",
-      defaultVersion: "1.1.9"
+      defaultVersion: "1.10.0"
     },
     claude: {
       packageName: "@agentclientprotocol/claude-agent-acp",
       binName: "claude-agent-acp",
-      defaultVersion: "0.64.2"
+      defaultVersion: "0.75.1"
     }
   };
   EXACT_SEMVER = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
@@ -30465,7 +30465,7 @@ function isWorkerBindingRecord(value) {
   if (!isRecord4(value)) {
     return false;
   }
-  return isString(value.sourceHandle) && (value.agentEndpointId === undefined || isAgentEndpointId(value.agentEndpointId)) && isString(value.coordinatorSession) && isString(value.workspace) && isOptionalString(value.cwd) && isString(value.targetAgent) && isOptionalString(value.role) && isOptionalBoolean(value.ephemeral) && isOptionalBoolean(value.guardAcpOutput) && (value.logicalSessionId === undefined || isLogicalSessionId(value.logicalSessionId)) && (value.transportEngine === undefined || value.transportEngine === "cli" || value.transportEngine === "runtime");
+  return isString(value.sourceHandle) && (value.agentEndpointId === undefined || isAgentEndpointId(value.agentEndpointId)) && isString(value.coordinatorSession) && isString(value.workspace) && isOptionalString(value.cwd) && isString(value.targetAgent) && isOptionalString(value.launchAgentCommand) && isOptionalString(value.launchAcpxAgent) && isOptionalString(value.launchRawCommand) && isOptionalString(value.role) && isOptionalBoolean(value.ephemeral) && isOptionalBoolean(value.guardAcpOutput) && (value.logicalSessionId === undefined || isLogicalSessionId(value.logicalSessionId)) && (value.transportEngine === undefined || value.transportEngine === "cli" || value.transportEngine === "runtime");
 }
 function isGroupRecord(value) {
   if (!isRecord4(value)) {
@@ -47989,7 +47989,10 @@ async function retireWorkerBinding(env, workerSession) {
         ...claimed.cwd ? { cwd: claimed.cwd } : {},
         ...claimed.role ? { role: claimed.role } : {},
         logicalSessionId: claimed.logicalSessionId,
-        transportEngine: claimed.transportEngine
+        transportEngine: claimed.transportEngine,
+        ...claimed.launchAgentCommand ? { launchAgentCommand: claimed.launchAgentCommand } : {},
+        ...claimed.launchAcpxAgent ? { launchAcpxAgent: claimed.launchAcpxAgent } : {},
+        ...claimed.launchRawCommand ? { launchRawCommand: claimed.launchRawCommand } : {}
       });
     } catch {
       return "retained";
@@ -48030,6 +48033,15 @@ function shouldGuardWorkerAcpOutput(binding) {
 function workerBindingGuardFields(previousBinding) {
   return previousBinding && previousBinding.guardAcpOutput !== true ? {} : { guardAcpOutput: true };
 }
+function workerBindingLaunchFields(previousBinding) {
+  if (!previousBinding)
+    return {};
+  return {
+    ...previousBinding.launchAgentCommand ? { launchAgentCommand: previousBinding.launchAgentCommand } : {},
+    ...previousBinding.launchAcpxAgent ? { launchAcpxAgent: previousBinding.launchAcpxAgent } : {},
+    ...previousBinding.launchRawCommand ? { launchRawCommand: previousBinding.launchRawCommand } : {}
+  };
+}
 function workerBindingEndpointIdentityFields(previousBinding, createId) {
   if (previousBinding?.agentEndpointId) {
     return { agentEndpointId: previousBinding.agentEndpointId };
@@ -48097,6 +48109,63 @@ async function persistWorkerBindingIdentity(state, input, deps) {
     deps.publish(staged.nextState);
   });
 }
+function stageWorkerBindingLaunch(state, input, launch) {
+  const binding = state.orchestration.workerBindings[input.workerSession];
+  if (!binding) {
+    return { changed: false };
+  }
+  const snapshot = {
+    ...launch.agentCommand ? { launchAgentCommand: launch.agentCommand } : {},
+    ...launch.acpxAgent ? { launchAcpxAgent: launch.acpxAgent } : {},
+    ...launch.rawCommand ? { launchRawCommand: launch.rawCommand } : {}
+  };
+  if (binding.launchAgentCommand === snapshot.launchAgentCommand && binding.launchAcpxAgent === snapshot.launchAcpxAgent && binding.launchRawCommand === snapshot.launchRawCommand) {
+    return { changed: false };
+  }
+  const nextState = structuredClone(state);
+  const nextBinding = nextState.orchestration.workerBindings[input.workerSession];
+  if (!nextBinding) {
+    return { changed: false };
+  }
+  delete nextBinding.launchAgentCommand;
+  delete nextBinding.launchAcpxAgent;
+  delete nextBinding.launchRawCommand;
+  Object.assign(nextBinding, snapshot);
+  return { changed: true, nextState };
+}
+function historicalWorkerReleaseTarget(current, snapshot) {
+  const historicalCommand = snapshot?.launchAgentCommand ?? snapshot?.launchRawCommand;
+  if (!historicalCommand) {
+    return;
+  }
+  if (historicalCommand === current.agentCommand || historicalCommand === current.rawCommand) {
+    return;
+  }
+  return { agentCommand: historicalCommand };
+}
+async function releaseWorkerOwnerSessions(removeSession, current, snapshot) {
+  await removeSession(current);
+  const historical = historicalWorkerReleaseTarget(current, snapshot);
+  if (historical) {
+    await removeSession({
+      ...current,
+      agentCommand: historical.agentCommand,
+      acpxAgent: undefined,
+      rawCommand: undefined,
+      agentArgv: undefined
+    });
+  }
+}
+async function persistWorkerBindingLaunch(state, input, launch, deps) {
+  await deps.runExclusive(async () => {
+    const staged = stageWorkerBindingLaunch(state, input, launch);
+    if (!staged.changed) {
+      return;
+    }
+    await deps.saveNow(staged.nextState);
+    deps.publish(staged.nextState);
+  });
+}
 function resolveWorkerAgentLaunch(agent3, transport, binding) {
   return resolveConfiguredAgentLaunch(agent3, transport, {
     guardAcpOutput: shouldGuardWorkerAcpOutput(binding)
@@ -48202,6 +48271,7 @@ class HumanDelegationService {
             targetAgent: input.targetAgent,
             ...role ? { role } : {},
             ...workerBindingGuardFields(previousBinding),
+            ...workerBindingLaunchFields(previousBinding),
             ...workerBindingEndpointIdentityFields(previousBinding, this.deps.createAgentEndpointId),
             ...identity,
             ...input.parallel ? { ephemeral: true } : {}
@@ -48279,6 +48349,7 @@ class HumanDelegationService {
             targetAgent: input.targetAgent,
             role,
             ...workerBindingGuardFields(previousBinding),
+            ...workerBindingLaunchFields(previousBinding),
             ...workerBindingEndpointIdentityFields(previousBinding, this.deps.createAgentEndpointId),
             ...workerBindingEngineFields(previousBinding),
             ...input.parallel ? { ephemeral: true } : {}
@@ -49928,6 +49999,7 @@ class RpcDelegationService {
               targetAgent: input.targetAgent,
               role: preflight.role,
               ...workerBindingGuardFields(previousBinding),
+              ...workerBindingLaunchFields(previousBinding),
               ...workerBindingEndpointIdentityFields(previousBinding, this.deps.createAgentEndpointId),
               ...identity,
               ...input.parallel ? { ephemeral: true } : {}
@@ -50430,6 +50502,7 @@ class TaskApprovalService {
           targetAgent: currentTask.targetAgent,
           ...currentTask.role ? { role: currentTask.role } : {},
           ...workerBindingGuardFields(previousBinding),
+          ...workerBindingLaunchFields(previousBinding),
           ...workerBindingEndpointIdentityFields(previousBinding, this.deps.createAgentEndpointId),
           ...identity,
           ...currentTask.ephemeralWorkerSession ? { ephemeral: true } : {}
@@ -50485,6 +50558,7 @@ class TaskApprovalService {
           targetAgent: task.targetAgent,
           role: task.role,
           ...workerBindingGuardFields(previousBinding),
+          ...workerBindingLaunchFields(previousBinding),
           ...workerBindingEndpointIdentityFields(previousBinding, this.deps.createAgentEndpointId),
           ...workerBindingEngineFields(previousBinding),
           ...task.ephemeralWorkerSession ? { ephemeral: true } : {}
@@ -51564,6 +51638,7 @@ class WorkerSessionManager {
             ...task.role ? { role: task.role } : {},
             ephemeral: true,
             guardAcpOutput: true,
+            ...workerBindingLaunchFields(previousBinding),
             ...identity
           };
           await this.deps.saveState(state);
@@ -54680,6 +54755,43 @@ class SessionService {
     }
     return resolved;
   }
+  listReapTargets() {
+    const seen = new Set;
+    const targets = [];
+    const push = (target) => {
+      const key = JSON.stringify([target.agent, target.agentCommand ?? null, target.cwd, target.transportSession]);
+      if (seen.has(key)) {
+        return;
+      }
+      seen.add(key);
+      targets.push(target);
+    };
+    for (const session3 of Object.values(this.state.sessions)) {
+      let candidate;
+      try {
+        candidate = this.toResolvedSession(session3);
+      } catch {
+        continue;
+      }
+      push({
+        agent: candidate.agent,
+        ...candidate.agentCommand ? { agentCommand: candidate.agentCommand } : {},
+        ...candidate.acpxAgent ? { acpxAgent: candidate.acpxAgent } : {},
+        ...candidate.rawCommand ? { rawCommand: candidate.rawCommand } : {},
+        cwd: candidate.cwd,
+        transportSession: candidate.transportSession
+      });
+      if (session3.transport_agent_command) {
+        push({
+          agent: candidate.agent,
+          agentCommand: session3.transport_agent_command,
+          cwd: candidate.cwd,
+          transportSession: candidate.transportSession
+        });
+      }
+    }
+    return targets;
+  }
   listAllResolvedLogicalSessions() {
     const resolved = [];
     for (const session3 of Object.values(this.state.sessions)) {
@@ -60658,14 +60770,7 @@ 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 } : {},
-      ...session3.acpxAgent ? { acpxAgent: session3.acpxAgent } : {},
-      ...session3.rawCommand ? { rawCommand: session3.rawCommand } : {},
-      cwd: session3.cwd,
-      transportSession: session3.transportSession
-    })),
+    ...sessions.listReapTargets(),
     ...workerBindingReapTargets(orchestration3, config4)
   ];
 }
@@ -60689,6 +60794,15 @@ function workerBindingReapTargets(orchestration3, config4) {
       cwd,
       transportSession: workerSession
     });
+    const historicalCommand = binding.launchAgentCommand ?? binding.launchRawCommand;
+    if (historicalCommand && historicalCommand !== launch.agentCommand && historicalCommand !== launch.rawCommand) {
+      targets.push({
+        agent: binding.targetAgent,
+        agentCommand: historicalCommand,
+        cwd,
+        transportSession: workerSession
+      });
+    }
   }
   return targets;
 }
@@ -65203,6 +65317,15 @@ async function buildApp(paths, deps = {}) {
       publish: (nextState) => replaceRuntimeState(state, nextState),
       runExclusive: (critical) => stateMutex.run(critical)
     });
+    const agentConfig = config4.agents[input.targetAgent];
+    if (agentConfig) {
+      const launch = resolveWorkerAgentLaunch(agentConfig, config4.transport, state.orchestration.workerBindings[input.workerSession]);
+      await persistWorkerBindingLaunch(state, { workerSession: input.workerSession }, launch, {
+        saveNow: (nextState) => debouncedStateStore.saveNow(nextState),
+        publish: (nextState) => replaceRuntimeState(state, nextState),
+        runExclusive: (critical) => stateMutex.run(critical)
+      });
+    }
   };
   const resolveWorkerRuntimeSession = (input, bindingSnapshot) => {
     const binding = bindingSnapshot ?? state.orchestration.workerBindings[input.workerSession];
@@ -65437,7 +65560,10 @@ async function buildApp(paths, deps = {}) {
       workspace: workspace3,
       cwd,
       logicalSessionId,
-      transportEngine
+      transportEngine,
+      launchAgentCommand,
+      launchAcpxAgent,
+      launchRawCommand
     }) => {
       const session3 = resolveWorkerRuntimeSession({
         workerSession,
@@ -65457,7 +65583,7 @@ async function buildApp(paths, deps = {}) {
       if (!transport.removeSession) {
         throw new Error(`transport cannot converge worker "${workerSession}": no removeSession operation`);
       }
-      await transport.removeSession(session3);
+      await releaseWorkerOwnerSessions((candidate) => transport.removeSession(candidate), session3, { launchAgentCommand, launchAcpxAgent, launchRawCommand });
     },
     resumeWorkerTask: async ({
       taskId,

package/dist/daemon/daemon-files.d.ts

@@ -0,0 +1,28 @@
+export declare const RUNTIME_CONSUMER_LOCK_FILE = "runtime-consumer.lock.json";
+export interface DaemonPaths {
+    runtimeDir: string;
+    pidFile: string;
+    statusFile: string;
+    stdoutLog: string;
+    stderrLog: string;
+    appLog: string;
+}
+interface ResolveDaemonPathsOptions {
+    home: string;
+    runtimeDir?: string;
+    configPath?: string;
+}
+export declare function resolveDaemonPaths(options: ResolveDaemonPathsOptions): DaemonPaths;
+export declare function resolveRuntimeDirFromConfigPath(configPath: string): string;
+/** Stable metadata path for the OS-held, channel-independent runtime lock. */
+export declare function resolveRuntimeConsumerLockPath(runtimeDir: string): string;
+export declare function resolveDaemonOrchestrationSocketPath(runtimeDir: string, platform?: NodeJS.Platform): string;
+/**
+ * Liveness probe via signal 0: returns true when the pid can be signalled.
+ * EPERM also reads as ALIVE — it means the signal was denied but the process
+ * exists (typically owned by another user). Doctor uses this to gate
+ * state-mutating repairs, where the unsafe direction is reporting a live
+ * process as dead; only a definitive "no such process" (ESRCH) reads as dead.
+ */
+export declare function isProcessAlive(pid: number): boolean;
+export {};

package/dist/orchestration/orchestration-ipc.d.ts

@@ -0,0 +1,86 @@
+import type { CancelTaskInput, CoordinatorRequestHumanInputResult, CoordinatorTaskQuestionRef, OrchestrationTaskFilter, RecordWorkerReplyInput, RegisterExternalCoordinatorInput, RequestDelegateRpcInput, RequestDelegateRpcResult, WatchTaskInput, WatchTaskResult, WorkerRaiseQuestionInput } from "./orchestration-service";
+import type { ExternalCoordinatorRecord, OrchestrationGroupRecord, OrchestrationTaskRecord } from "./orchestration-types";
+import type { ScheduledCreateFromRouteInput } from "../scheduled/scheduled-route-create";
+import type { ScheduledCancelFromRouteInput, ScheduledListFromRouteInput } from "../scheduled/scheduled-route-manage";
+import type { ScheduledTaskRecord } from "../scheduled/scheduled-types";
+import type { AgentMessagingErrorCode } from "./agent-messaging-error";
+export type OrchestrationRpcMethod = "agent.list" | "agent.send" | "coordinator.register_external" | "delegate.request" | "task.get" | "task.list" | "task.watch" | "task.approve" | "task.cancel" | "worker.reply" | "worker.raise_question" | "coordinator.answer_question" | "coordinator.retract_answer" | "coordinator.request_human_input" | "coordinator.review_contested_result" | "scheduled.create" | "scheduled.list" | "scheduled.cancel" | "group.new";
+export interface OrchestrationIpcEndpoint {
+    kind: "unix" | "named-pipe";
+    path: string;
+}
+export interface OrchestrationRpcRequest {
+    id: string;
+    method: OrchestrationRpcMethod;
+    params: Record<string, unknown>;
+}
+export interface OrchestrationRpcSuccessResponse<Result = unknown> {
+    id: string;
+    ok: true;
+    result: Result;
+}
+export type OrchestrationRpcErrorCode = "ORCHESTRATION_INVALID_REQUEST" | "ORCHESTRATION_INTERNAL_ERROR" | AgentMessagingErrorCode;
+export interface OrchestrationRpcErrorResponse {
+    id: string;
+    ok: false;
+    error: {
+        code: OrchestrationRpcErrorCode;
+        message: string;
+    };
+}
+export type OrchestrationRpcResponse<Result = unknown> = OrchestrationRpcSuccessResponse<Result> | OrchestrationRpcErrorResponse;
+export interface OrchestrationRpcHandlers {
+    registerExternalCoordinator: (input: RegisterExternalCoordinatorInput) => Promise<ExternalCoordinatorRecord>;
+    requestDelegate: (input: RequestDelegateRpcInput) => Promise<RequestDelegateRpcResult>;
+    getTask: (taskId: string) => Promise<OrchestrationTaskRecord | null>;
+    listTasks: (filter?: OrchestrationTaskFilter) => Promise<OrchestrationTaskRecord[]>;
+    watchTask: (input: WatchTaskInput) => Promise<WatchTaskResult>;
+    approveTask: (input: {
+        taskId: string;
+        coordinatorSession: string;
+    }) => Promise<OrchestrationTaskRecord>;
+    cancelTask: (input: CancelTaskInput) => Promise<OrchestrationTaskRecord>;
+    recordWorkerReply: (input: RecordWorkerReplyInput) => Promise<OrchestrationTaskRecord>;
+    workerRaiseQuestion: (input: WorkerRaiseQuestionInput) => Promise<{
+        taskId: string;
+        questionId: string;
+        status: "blocked";
+    }>;
+    coordinatorAnswerQuestion: (input: {
+        coordinatorSession: string;
+        taskId: string;
+        questionId: string;
+        answer: string;
+    }) => Promise<OrchestrationTaskRecord>;
+    coordinatorRetractAnswer: (input: {
+        coordinatorSession: string;
+        taskId: string;
+        questionId: string;
+    }) => Promise<OrchestrationTaskRecord>;
+    coordinatorRequestHumanInput: (input: {
+        coordinatorSession: string;
+        taskQuestions: CoordinatorTaskQuestionRef[];
+        promptText: string;
+        expectedActivePackageId?: string;
+    }) => Promise<CoordinatorRequestHumanInputResult>;
+    coordinatorReviewContestedResult: (input: {
+        coordinatorSession: string;
+        taskId: string;
+        reviewId: string;
+        decision: "accept" | "discard";
+    }) => Promise<OrchestrationTaskRecord>;
+    createGroup: (input: {
+        coordinatorSession: string;
+        title: string;
+    }) => Promise<OrchestrationGroupRecord>;
+    createScheduledTaskFromRoute?: (input: ScheduledCreateFromRouteInput) => Promise<ScheduledTaskRecord>;
+    listScheduledTasksFromRoute?: (input: ScheduledListFromRouteInput) => Promise<ScheduledTaskRecord[]>;
+    cancelScheduledTaskFromRoute?: (input: ScheduledCancelFromRouteInput) => Promise<{
+        id: string;
+        cancelled: boolean;
+    }>;
+}
+export declare function resolveOrchestrationEndpoint(runtimeDir: string, platform?: NodeJS.Platform): OrchestrationIpcEndpoint;
+export declare function createOrchestrationEndpoint(path: string, platform?: NodeJS.Platform): OrchestrationIpcEndpoint;
+export declare function encodeOrchestrationRpcRequest(request: OrchestrationRpcRequest): string;
+export declare function encodeOrchestrationRpcResponse(response: OrchestrationRpcResponse): string;

package/dist/orchestration/orchestration-service.d.ts

@@ -187,6 +187,16 @@ export interface OrchestrationServiceDeps {
         role?: string;
         logicalSessionId: string;
         transportEngine: SessionTransportEngine;
+        /**
+         * Last-dispatched launch snapshot (claim-time copy). The CLI teardown
+         * converges this identity alongside the current resolution: after a
+         * managed-pin/config change the current identity cannot locate the
+         * previous owner, and the binding is deleted right after release
+         * returns — this is the last chance to close the old record.
+         */
+        launchAgentCommand?: string;
+        launchAcpxAgent?: string;
+        launchRawCommand?: string;
     }) => Promise<void>;
     wakeCoordinatorSession?: (request: WakeCoordinatorRequest) => Promise<void>;
     deliverCoordinatorMessage?: (request: DeliverCoordinatorMessageRequest) => Promise<FrozenCoordinatorDeliveryRoute | void>;

package/dist/orchestration/orchestration-types.d.ts

@@ -116,6 +116,17 @@ export interface WorkerBindingRecord {
     coordinatorSession: string;
     workspace: string;
     cwd?: string;
+    /**
+     * Launch identity last used to dispatch this worker (persist-before-owner,
+     * refreshed on every dispatch). Queue-owner reaping needs the PREVIOUS
+     * identity after a managed-pin/config change recomputes the current launch:
+     * without it a crashed-then-upgraded daemon cannot locate the old owner.
+     * Absent on bindings created before this field existed (reap falls back to
+     * the current resolution) and on bare-driver launches (no command to record).
+     */
+    launchAgentCommand?: string;
+    launchAcpxAgent?: string;
+    launchRawCommand?: string;
     targetAgent: string;
     role?: string;
     /** True for ephemeral parallel-slot sessions; excluded from findReusableWorkerSession matching. */

package/dist/orchestration/worker-binding-retirement.d.ts

@@ -24,6 +24,9 @@ export interface WorkerBindingRetirementEnv {
         role?: string;
         logicalSessionId: string;
         transportEngine: SessionTransportEngine;
+        launchAgentCommand?: string;
+        launchAcpxAgent?: string;
+        launchRawCommand?: string;
     }) => Promise<void>) | undefined;
     isTerminalStatus: (status: OrchestrationTaskStatus) => boolean;
     /**

package/dist/orchestration/worker-launch.d.ts

@@ -1,6 +1,7 @@
 import type { AppState, SessionTransportEngine } from "../state/types";
 import type { AgentConfig, TransportConfig } from "../config/types";
 import type { WorkerBindingRecord } from "./orchestration-types";
+import type { ResolvedSession } from "../transport/types";
 /**
  * A missing binding means this is a first launch and should opt into the new
  * guard. A persisted binding without the marker predates the rollout and must
@@ -12,6 +13,21 @@ export declare function shouldGuardWorkerAcpOutput(binding: Pick<WorkerBindingRe
 export declare function workerBindingGuardFields(previousBinding: Pick<WorkerBindingRecord, "guardAcpOutput"> | undefined): {
     guardAcpOutput?: true;
 };
+/**
+ * Preserve a reusable worker's last-dispatched launch snapshot across
+ * whole-object binding reconstructions (reuse shells, post-ensure rebuilds).
+ * Every site that rebuilds an existing binding MUST spread this alongside
+ * the guard/endpoint/engine helpers: dropping the snapshot deletes the only
+ * evidence the reaper and retirement convergence have for the previous
+ * owner's identity after a managed-pin/config change. A crash between the
+ * rebuild's saveState and the next launch snapshot would otherwise orphan
+ * the old owner permanently (ttl=0).
+ */
+export declare function workerBindingLaunchFields(previousBinding: Pick<WorkerBindingRecord, "launchAgentCommand" | "launchAcpxAgent" | "launchRawCommand"> | undefined): {
+    launchAgentCommand?: string;
+    launchAcpxAgent?: string;
+    launchRawCommand?: string;
+};
 /** Preserve a reusable worker's endpoint identity; mint one for a new binding. */
 export declare function workerBindingEndpointIdentityFields(previousBinding: Pick<WorkerBindingRecord, "agentEndpointId"> | undefined, createId?: () => string): {
     agentEndpointId?: string;
@@ -128,4 +144,56 @@ export declare function persistWorkerBindingIdentity(state: AppState, input: {
     targetAgent: string;
     workspace: string;
 }, deps: WorkerBindingIdentityPersistence): Promise<void>;
+/** Launch identity resolved for one worker dispatch (reap snapshot source). */
+export interface WorkerBindingLaunchSnapshot {
+    agentCommand?: string;
+    acpxAgent?: string;
+    rawCommand?: string;
+}
+/**
+ * Stage a worker binding's launch snapshot onto a copy-on-write clone.
+ * Unlike the immutable LID/engine identity above, the snapshot is refreshed
+ * whenever the resolved launch differs, so a later restart can reap the
+ * previous owner after a managed-pin/config change. Returns
+ * `{ changed: false }` when the binding is missing or the snapshot already
+ * matches (steady-state dispatches skip the save). The caller must
+ * `saveNow(nextState)` and publish ONLY on success, same G11 contract as
+ * the identity staging above. Stale keys the new launch no longer carries
+ * are cleared so they cannot reap a phantom identity forever.
+ */
+export declare function stageWorkerBindingLaunch(state: AppState, input: {
+    workerSession: string;
+}, launch: WorkerBindingLaunchSnapshot): {
+    changed: false;
+} | {
+    changed: true;
+    nextState: AppState;
+};
+/**
+ * The extra owner identity a worker retirement must converge besides the
+ * current resolution: the last-dispatched launch snapshot when it names a
+ * different acpx record. Command-only (no alias): the transport passes it as
+ * `--agent`, which acpx matches verbatim against the old record. Returns
+ * undefined when there is no snapshot or it already matches the current
+ * resolution (same pin, sticky custom, or bare launch).
+ */
+export declare function historicalWorkerReleaseTarget(current: Pick<ResolvedSession, "agentCommand" | "rawCommand">, snapshot: Pick<WorkerBindingRecord, "launchAgentCommand" | "launchAcpxAgent" | "launchRawCommand"> | undefined): {
+    agentCommand: string;
+} | undefined;
+/**
+ * Converge a retiring worker's engine-side owner(s): always the current
+ * resolution, then the historical snapshot target when it names a different
+ * record. A throw from either step retains the binding (fail-closed retry),
+ * so the old owner is never stranded by a deleted binding. Missing records
+ * read as success on both steps (transport contract).
+ */
+export declare function releaseWorkerOwnerSessions(removeSession: (session: ResolvedSession) => Promise<void>, current: ResolvedSession, snapshot: Pick<WorkerBindingRecord, "launchAgentCommand" | "launchAcpxAgent" | "launchRawCommand"> | undefined): Promise<void>;
+/**
+ * Persist a worker binding's launch snapshot as one atomic transaction on the
+ * shared state mutex (stage on a clone, saveNow, then publish to live state
+ * ONLY on success). Callers must run outside the non-reentrant mutex.
+ */
+export declare function persistWorkerBindingLaunch(state: AppState, input: {
+    workerSession: string;
+}, launch: WorkerBindingLaunchSnapshot, deps: Pick<WorkerBindingIdentityPersistence, "saveNow" | "publish" | "runExclusive">): Promise<void>;
 export declare function resolveWorkerAgentLaunch(agent: Pick<AgentConfig, "driver" | "command" | "argv">, transport: Pick<TransportConfig, "preferLocalAgents" | "adapterVersions" | "adapterRegistry"> | undefined, binding: Pick<WorkerBindingRecord, "guardAcpOutput"> | undefined): import("../config/agent-launch").AgentLaunchSpec;

package/dist/process/spawn-command.d.ts

@@ -0,0 +1,5 @@
+export interface SpawnCommandSpec {
+    command: string;
+    args: string[];
+}
+export declare function resolveSpawnCommand(command: string, args: string[]): SpawnCommandSpec;

package/dist/scheduled/scheduled-route-create.d.ts

@@ -0,0 +1,25 @@
+import type { AppConfig } from "../config/types";
+import type { AppState } from "../state/types";
+import type { ResolvedSession } from "../transport/types";
+import type { CreateScheduledTaskInput } from "./scheduled-service";
+import type { ScheduledSessionMode, ScheduledTaskRecord } from "./scheduled-types";
+export interface ScheduledCreateFromRouteInput {
+    coordinatorSession: string;
+    timeText: string;
+    message: string;
+    mode?: ScheduledSessionMode;
+}
+export interface ScheduledCreateFromRouteDeps {
+    state: Pick<AppState, "orchestration">;
+    config: Pick<AppConfig, "later">;
+    sessions: {
+        getSession: (alias: string) => Promise<ResolvedSession | null>;
+        getPreferredSessionForTransport: (transportSession: string) => Promise<ResolvedSession | null>;
+    };
+    scheduled: {
+        createTask: (input: CreateScheduledTaskInput) => Promise<ScheduledTaskRecord>;
+    };
+    supportsScheduledMessages?: (chatKey: string) => boolean;
+    now?: () => Date;
+}
+export declare function createScheduledTaskFromRoute(input: ScheduledCreateFromRouteInput, deps: ScheduledCreateFromRouteDeps): Promise<ScheduledTaskRecord>;

package/dist/scheduled/scheduled-route-manage.d.ts

@@ -0,0 +1,26 @@
+import type { AppState } from "../state/types";
+import type { ScheduledTaskRecord } from "./scheduled-types";
+export interface ScheduledListFromRouteInput {
+    coordinatorSession: string;
+}
+export interface ScheduledListFromRouteDeps {
+    state: Pick<AppState, "orchestration">;
+    scheduled: {
+        listPending: (chatKey: string) => ScheduledTaskRecord[];
+    };
+}
+export interface ScheduledCancelFromRouteInput {
+    coordinatorSession: string;
+    id: string;
+}
+export interface ScheduledCancelFromRouteDeps {
+    state: Pick<AppState, "orchestration">;
+    scheduled: {
+        cancelPending: (id: string, chatKey: string) => Promise<boolean>;
+    };
+}
+export declare function listScheduledTasksFromRoute(input: ScheduledListFromRouteInput, deps: ScheduledListFromRouteDeps): Promise<ScheduledTaskRecord[]>;
+export declare function cancelScheduledTaskFromRoute(input: ScheduledCancelFromRouteInput, deps: ScheduledCancelFromRouteDeps): Promise<{
+    id: string;
+    cancelled: boolean;
+}>;

package/dist/sessions/session-service.d.ts

@@ -4,6 +4,7 @@ import type { StateStore } from "../state/state-store";
 import type { AppState, BackgroundResult, LogicalSession, SessionTransportEngine } from "../state/types";
 import type { SessionResourceLifecyclePublishInput } from "./session-resource-catalog";
 import type { AgentSession, ResolvedSession } from "../transport/types";
+import type { ReapTarget } from "../transport/queue-owner-reaper";
 interface SessionListItem {
     alias: string;
     internalAlias: string;
@@ -136,6 +137,21 @@ export declare class SessionService {
      * never throws.
      */
     listAllResolvedSessions(): ResolvedSession[];
+    /**
+     * Warm acpx queue-owner reap targets, including HISTORICAL identities.
+     * Derived recorded commands (managed adapter pins, hermes shim, preinstalled
+     * adapters) are recomputed from the CURRENT pin on restart, so a current-only
+     * target cannot locate an owner spawned under a previous pin: after a crash
+     * + pin upgrade, the old owner would survive startup/shutdown reaping, and
+     * with `queueOwnerTtlSeconds=0` it would linger forever. The persisted
+     * `transport_agent_command` is byte-identical to the acpx record's
+     * `agent_command`, so it is emitted command-only (no alias): the reaper
+     * passes it as `--agent`, which acpx matches verbatim with no
+     * alias-registry round trip. Sticky custom commands resolve to themselves
+     * and dedupe away here. Sessions whose agent/workspace are de-registered
+     * are skipped, same as listAllResolvedSessions; never throws.
+     */
+    listReapTargets(): ReapTarget[];
     /**
      * One entry per persisted logical session — NO physical dedupe. This is the
      * recovery catalog for the Runtime durable queue (`runtime-queue/<LID>.json`

package/dist/transport/acpx-queue-owner-launcher.d.ts

@@ -0,0 +1,163 @@
+import type { NonInteractivePermissions, PermissionMode } from "../config/types";
+import { terminateProcessTree } from "../process/terminate-process-tree";
+import { probeWindowsProcessIdentity } from "../process/windows-process-tree";
+export interface AcpxMcpServerSpec {
+    name: string;
+    type: "stdio";
+    command: string;
+    args: string[];
+}
+export interface QueueOwnerPayload {
+    sessionId: string;
+    /** Command selected by the durable adapter transaction for this owner. */
+    agentCommand?: string;
+    permissionMode: PermissionMode;
+    nonInteractivePermissions: NonInteractivePermissions;
+    ttlMs: number;
+    maxQueueDepth: number;
+    promptRetries?: number;
+    sessionOptions?: {
+        model?: string;
+        allowedTools?: string[];
+        maxTurns?: number;
+        systemPrompt?: string | {
+            append: string;
+        };
+    };
+    mcpServers: AcpxMcpServerSpec[];
+}
+export type QueueOwnerSpawner = (command: string, args: string[], options: {
+    env: Record<string, string>;
+}) => Promise<number>;
+export type QueueOwnerTerminator = (sessionId: string) => Promise<void>;
+export interface AcpxQueueOwnerLauncherOptions {
+    acpxCommand: string;
+    xacpxCommand?: string;
+    spawnOwner?: QueueOwnerSpawner;
+    terminateOwner?: QueueOwnerTerminator;
+    /**
+     * Liveness check for an existing warm owner. When it reports alive, launch()
+     * REUSES the running owner instead of kill+respawn — consecutive turns of a
+     * coordinator session share one warm agent instead of cold-starting each turn.
+     * Defaults to reading the acpx queue lock pid.
+     */
+    isOwnerAlive?: (sessionId: string) => Promise<boolean>;
+    baseEnv?: NodeJS.ProcessEnv;
+    ttlMs?: number;
+    maxQueueDepth?: number;
+    readOwnerPid?: (sessionId: string) => Promise<number | undefined>;
+    probeSpawnedProcess?: (pid: number) => Promise<"alive" | "exited" | "unknown">;
+    handshakeTimeoutMs?: number;
+    handshakePollMs?: number;
+    uuid?: () => string;
+    sleep?: (ms: number) => Promise<void>;
+}
+export interface QueueOwnerAdapterContext {
+    id: "codex" | "claude";
+    sessionKey: string;
+    agentCommand: string;
+    platform: NodeJS.Platform;
+    prepare(intentToken: string): Promise<{
+        agentCommand: string;
+        generationId?: string;
+    }>;
+    isGenerationCurrent(generationId: string): Promise<boolean>;
+    spawned(intentToken: string): Promise<void>;
+    cancel(intentToken: string): Promise<void>;
+    settle(input: {
+        intentToken: string;
+        outcome: "owner-committed" | "launch-failed";
+        ownerPid?: number;
+        ownerAcpxRecordId?: string;
+    }): Promise<void>;
+}
+export interface LaunchQueueOwnerInput {
+    acpxRecordId: string;
+    coordinatorSession: string;
+    sourceHandle?: string;
+    permissionMode: PermissionMode;
+    nonInteractivePermissions: NonInteractivePermissions;
+    /** Session options forwarded to the warm queue owner (e.g. the resolved model id). */
+    sessionOptions?: QueueOwnerPayload["sessionOptions"];
+    /** Per-agent environment inherited by the queue owner and its ACP adapter. */
+    env?: NodeJS.ProcessEnv;
+    /** Required whenever agentCommand has the managed preinstall shape. */
+    agentCommand?: string;
+    adapterContext?: QueueOwnerAdapterContext;
+}
+export declare function buildXacpxMcpServerSpec(input: {
+    xacpxCommand: string;
+    coordinatorSession: string;
+    sourceHandle?: string;
+}): AcpxMcpServerSpec;
+export declare function buildQueueOwnerPayload(input: {
+    sessionId: string;
+    agentCommand?: string;
+    permissionMode: PermissionMode;
+    nonInteractivePermissions: NonInteractivePermissions;
+    mcpServers: AcpxMcpServerSpec[];
+    ttlMs?: number;
+    maxQueueDepth?: number;
+    promptRetries?: number;
+    sessionOptions?: QueueOwnerPayload["sessionOptions"];
+}): QueueOwnerPayload;
+export declare class AcpxQueueOwnerLauncher {
+    private readonly acpxCommand;
+    private readonly xacpxCommand;
+    private readonly spawnOwner;
+    private readonly terminateOwner;
+    private readonly isOwnerAlive;
+    private readonly baseEnv;
+    private readonly ttlMs?;
+    private readonly maxQueueDepth?;
+    private readonly readOwnerPid;
+    private readonly probeSpawnedProcess;
+    private readonly handshakeTimeoutMs;
+    private readonly handshakePollMs;
+    private readonly uuid;
+    private readonly sleep;
+    /** Per-session mutex: serializes terminate+spawn to prevent concurrent clobbering. */
+    private readonly launchLocks;
+    /** Fingerprint of the parameters the CURRENT owner was spawned with. */
+    private readonly lastLaunchFingerprint;
+    constructor(options: AcpxQueueOwnerLauncherOptions);
+    cool(acpxRecordId: string): Promise<void>;
+    private doCool;
+    wouldReuse(input: LaunchQueueOwnerInput): Promise<boolean>;
+    launch(input: LaunchQueueOwnerInput): Promise<{
+        agentCommand?: string;
+    }>;
+    private doLaunch;
+    private waitForOwnerPid;
+}
+export declare function readQueueOwnerPid(sessionId: string): Promise<number | undefined>;
+export declare function terminateAcpxQueueOwner(sessionId: string): Promise<void>;
+export interface QueueOwnerTerminationDeps {
+    platform?: NodeJS.Platform;
+    lockPath?: string;
+    probeIdentity?: typeof probeWindowsProcessIdentity;
+    terminate?: typeof terminateProcessTree;
+}
+export declare function terminateAcpxQueueOwnerWithDeps(sessionId: string, deps: QueueOwnerTerminationDeps): Promise<void>;
+export interface VerifiedOwnerTerminationDeps {
+    lockPath?: string;
+    /** Defaults to terminateAcpxQueueOwner (a no-op for unverifiable Windows locks). */
+    terminate?: () => Promise<void>;
+    delay?: (ms: number) => Promise<void>;
+    /** Test seam for lock-liveness checks; defaults to fs access(). */
+    accessFn?: (path: string) => Promise<void>;
+}
+/**
+ * Terminate the warm owner for a session AND prove it is gone before returning.
+ * Used before mutating a session record: if the owner cannot be shown to be
+ * terminated (the lock still exists), writing the record could race the
+ * owner's own writes. Fails closed instead.
+ *
+ * Note: on Windows terminateAcpxQueueOwner deliberately does not consume the
+ * queue lock (no verifiable provenance yet), so a live owner there makes the
+ * migration unsafe — callers surface the error and the operator frees the
+ * owner (or waits for the daemon's orphan sweep) before retrying.
+ */
+export declare function terminateAcpxQueueOwnerVerified(sessionId: string): Promise<void>;
+export declare function terminateAcpxQueueOwnerVerifiedWithDeps(sessionId: string, deps: VerifiedOwnerTerminationDeps): Promise<void>;
+export declare function resolveDefaultXacpxCommand(env: NodeJS.ProcessEnv): string;

package/dist/transport/acpx-session-files.d.ts

@@ -0,0 +1,31 @@
+/**
+ * acpx's home dir. Env-first (mirrors acpx, which reads HOME/USERPROFILE at
+ * startup) so tests can isolate `~/.acpx` by overriding the env, and so the
+ * daemon never disagrees with the acpx child it spawns.
+ */
+export declare function resolveAcpxHomeDir(): string;
+export interface DeleteAcpxSessionFilesOptions {
+    acpxRecordId: string;
+    /** Override for the acpx sessions dir (tests). Defaults to `<home>/.acpx/sessions`. */
+    sessionsDir?: string;
+}
+/** Best-effort delete of a single acpx session's on-disk files: the record json and
+ *  its event-stream artifacts. Mirrors acpx's per-record file layout
+ *  (`<encodeURIComponent(acpxRecordId)>.json` + `<safeId>.stream.*`). Idempotent —
+ *  missing files are ignored.
+ *
+ *  Deleting the `.json` record leaves a dangling index.json entry, but acpx rebuilds
+ *  its index from the surviving `.json` files on its next `sessions` operation, so we
+ *  do not rewrite the index ourselves.
+ *
+ *  The `.stream.*` unlinks are NOT guaranteed to take effect: acpx keeps a warm
+ *  queue-owner alive via `--ttl`, so `sessions close` returning does not mean the
+ *  backing process has released those files. On POSIX the unlink drops the directory
+ *  entry and the owner keeps writing to the now-unlinked inode until `--ttl` expires
+ *  (no visible orphan). On Windows the unlink of a still-open file rejects and is
+ *  swallowed below, leaving the `.stream.*` file as a true orphan. acpx does NOT
+ *  auto-reclaim such an orphan — index rebuild scans only `.json` files, and
+ *  `sessions prune` skips stream files unless run with `--include-history` — so a
+ *  Windows orphan persists until a manual prune. This is an accepted residual risk:
+ *  the queue-owner is a third-party process we cannot reap or await from here. */
+export declare function deleteAcpxSessionFiles(options: DeleteAcpxSessionFilesOptions): Promise<void>;

package/dist/transport/queue-owner-reaper.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Minimal session identity needed to locate an acpx queue owner: enough to run
+ * `acpx sessions show <name>` and resolve the session's stable record id, which
+ * is the key acpx uses for the queue lock at `~/.acpx/queues/<hash>.lock`.
+ */
+export interface ReapTarget {
+    agent: string;
+    agentCommand?: string;
+    /** Positional acpx agent (overlay alias or bare driver) for structured launches. */
+    acpxAgent?: string;
+    /** Unix-only legacy raw override passed as acpx `--agent`. */
+    rawCommand?: string;
+    cwd: string;
+    transportSession: string;
+}
+export interface ReapQueueOwnersDeps {
+    /** Resolve a target to its acpx record id (queue key), or null when unknown. */
+    resolveRecordId?: (acpxCommand: string, target: ReapTarget) => Promise<string | null>;
+    /** Terminate the queue owner process for a record id (kills process, keeps session). */
+    terminate?: (acpxRecordId: string) => Promise<void>;
+    /** Overall budget for the whole sweep; on expiry we return what finished. */
+    timeoutMs?: number;
+    platform?: NodeJS.Platform;
+    onError?: (target: ReapTarget, error: unknown) => void;
+}
+export declare class LegacyOwnerUnverifiableError extends Error {
+    readonly code = "legacy-owner-unverifiable";
+    constructor();
+}
+/**
+ * Terminate the warm acpx queue owner processes for the given sessions on daemon
+ * stop. Each owner holds a live ACP agent kept warm by `--ttl`; without this they
+ * would linger until the TTL expires (or forever when ttl=0) after the daemon is
+ * gone. This kills only the owner process tree — it does NOT close the acpx session
+ * (no `closed` flag, no metadata change), so sessions resume normally on next start.
+ *
+ * Best-effort by design: per-target failures are swallowed and the whole sweep is
+ * bounded by `timeoutMs`. If resolution fails or times out, the owner simply lingers
+ * until its TTL — i.e. the pre-existing behaviour, never a regression or a hang.
+ */
+export declare function reapQueueOwners(acpxCommand: string, targets: ReapTarget[], deps?: ReapQueueOwnersDeps): Promise<{
+    terminated: number;
+    attempted: number;
+}>;
+export declare function parseRecordId(stdout: string): string | null;

package/dist/util/async.d.ts

@@ -0,0 +1 @@
+export declare function settleWithinTimeout(work: Promise<unknown>, timeoutMs: number): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ganglion/xacpx",
-  "version": "0.24.3-beta.1",
+  "version": "0.24.4-beta.0",
   "description": "随时随地通过聊天频道（微信 / 飞书 / 元宝等）远程控制 `acpx` 上的 Claude Code、Codex 等 Agents。",
   "keywords": [
     "acpx",