@ganglion/xacpx 0.15.3 → 0.15.5

package/dist/bridge/bridge-main.js

@@ -4193,6 +4193,16 @@ class BridgeRuntime {
     await deleteAcpxSessionFiles({ acpxRecordId });
     return {};
   }
+  async freeWarmProcess(input) {
+    let acpxRecordId;
+    try {
+      ({ acpxRecordId } = await this.readSessionRecord(input));
+    } catch {
+      return {};
+    }
+    await terminateAcpxQueueOwner(acpxRecordId);
+    return {};
+  }
   async shutdown() {
     return {};
   }
@@ -4440,6 +4450,7 @@ var BRIDGE_METHODS = new Set([
   "cancel",
   "removeSession",
   "deleteSession",
+  "freeWarmProcess",
   "getAgentSessionId"
 ]);
 var SESSION_SCOPED_METHODS = new Set([
@@ -4454,6 +4465,7 @@ var SESSION_SCOPED_METHODS = new Set([
   "cancel",
   "removeSession",
   "deleteSession",
+  "freeWarmProcess",
   "getAgentSessionId"
 ]);
 
@@ -4677,6 +4689,13 @@ class BridgeServer {
           cwd: requireString(params, "cwd"),
           name: requireString(params, "name")
         });
+      case "freeWarmProcess":
+        return await this.runtime.freeWarmProcess({
+          agent: requireString(params, "agent"),
+          agentCommand: asOptionalString(params.agentCommand),
+          cwd: requireString(params, "cwd"),
+          name: requireString(params, "name")
+        });
       case "getAgentSessionId":
         return await this.runtime.getAgentSessionId({
           agent: requireString(params, "agent"),

package/dist/cli.js

@@ -20164,7 +20164,7 @@ async function resolveSessionAgentCommandFromIndex(session3) {
     const raw = await readFile12(resolve2(home, ".acpx", "sessions", "index.json"), "utf8");
     const parsed = JSON.parse(raw);
     const targetCwd = resolve2(session3.cwd);
-    const match = parsed.entries?.find((entry) => entry.name === session3.transportSession && entry.cwd === targetCwd && typeof entry.agentCommand === "string" && entry.agentCommand.trim().length > 0);
+    const match = parsed.entries?.find((entry) => entry.name === session3.transportSession && typeof entry.cwd === "string" && resolve2(entry.cwd) === targetCwd && typeof entry.agentCommand === "string" && entry.agentCommand.trim().length > 0);
     return match?.agentCommand?.trim();
   } catch {
     return;
@@ -24733,7 +24733,7 @@ class CommandRouter {
   async handle(chatKey, input, reply, replyContextToken, accountId, media, metadata, abortSignal, onToolEvent, onThought, perfSpan, onPlan, onUsage, onCommands) {
     const startedAt = Date.now();
     let command = parseCommand(input);
-    if (metadata?.channel === "control" && command.kind !== "prompt") {
+    if (metadata?.channel === "control" && command.kind !== "prompt" && command.kind !== "session.reset") {
       command = { kind: "prompt", text: input.trim() };
     }
     await this.logger.debug("command.parsed", "parsed inbound command", {
@@ -24832,7 +24832,7 @@ class CommandRouter {
         case "cancel":
           return await handleCancel(this.createSessionHandlerContext(undefined, perfSpan), chatKey, command.alias);
         case "session.reset":
-          return await handleSessionReset(this.createSessionHandlerContext(reply, perfSpan), chatKey);
+          return await handleSessionReset(this.createSessionHandlerContext(metadata?.channel === "control" ? undefined : reply, perfSpan), chatKey);
         case "session.tail":
           return await handleSessionTail(this.createSessionHandlerContext(undefined, perfSpan), chatKey, command.lines);
         case "session.rm":
@@ -25046,6 +25046,15 @@ class CommandRouter {
       try {
         await this.transport.cancel(session3);
       } catch {}
+      try {
+        await this.transport.freeWarmProcess?.(session3);
+      } catch (error2) {
+        await this.logger.error("session.free_warm_process_failed", "failed to free warm queue-owner on archive", {
+          alias: internalAlias,
+          transportSession: session3.transportSession,
+          message: error2 instanceof Error ? error2.message : String(error2)
+        });
+      }
     }
     await this.sessions.setArchived(internalAlias, true);
   }
@@ -30095,6 +30104,7 @@ class SessionService {
       agent: session3.agent,
       agentCommand: session3.transport_agent_command ?? resolveRuntimeAgentCommand(agentConfig.driver, agentConfig.command, this.config.transport.preferLocalAgents !== false),
       model: session3.model ?? agentConfig.model,
+      displayName: session3.display_name,
       workspace: session3.workspace,
       transportSession: session3.transport_session,
       source: session3.source,
@@ -30125,6 +30135,22 @@ class SessionService {
       await this.persist();
     });
   }
+  async setDisplayName(alias, name) {
+    await this.mutate(async () => {
+      const session3 = this.state.sessions[alias];
+      if (!session3) {
+        throw new Error(`session "${alias}" does not exist`);
+      }
+      const normalized = name?.trim();
+      if (normalized) {
+        session3.display_name = normalized;
+      } else {
+        delete session3.display_name;
+      }
+      session3.last_used_at = new Date(this.now()).toISOString();
+      await this.persist();
+    });
+  }
   async setCurrentSessionModel(chatKey, modelId) {
     await this.mutate(async () => {
       const currentAlias = this.state.chat_contexts[chatKey]?.current_session;
@@ -31556,6 +31582,9 @@ ${result.text}` : "" };
   async deleteSession(session3) {
     await this.client.request("deleteSession", this.toParams(session3));
   }
+  async freeWarmProcess(session3) {
+    await this.client.request("freeWarmProcess", this.toParams(session3));
+  }
   async getAgentSessionId(session3) {
     const result = await this.client.request("getAgentSessionId", this.toParams(session3));
     return result.agentSessionId;
@@ -32554,7 +32583,7 @@ class AcpxCliTransport {
     const structuredPrompt = await createStructuredPromptFile(text, options?.media);
     const args = this.buildPromptArgs(session3, text, structuredPrompt?.filePath);
     try {
-      if (reply || options?.onSegment || options?.onToolEvent || options?.onThought || options?.onPlan) {
+      if (reply || options?.onSegment || options?.onToolEvent || options?.onThought || options?.onPlan || options?.onUsage || options?.onCommands) {
         const effectiveReplyMode = session3.effectiveReplyMode ?? session3.replyMode;
         const formatToolCalls = (effectiveReplyMode ?? "verbose") === "verbose";
         const rawStream = effectiveReplyMode === "stream";
@@ -32562,7 +32591,7 @@ class AcpxCliTransport {
         if ((toolEventMode === "structured" || toolEventMode === "both") && !options?.onToolEvent) {
           toolEventMode = "text";
         }
-        const { result: result2, overflowCount } = await this.runStreamingPrompt(this.command, args, reply, formatToolCalls, toolEventMode, replyContext, options?.onSegment, options?.onToolEvent, options?.onThought, options?.onPlan, rawStream);
+        const { result: result2, overflowCount } = await this.runStreamingPrompt(this.command, args, reply, formatToolCalls, toolEventMode, replyContext, options?.onSegment, options?.onToolEvent, options?.onThought, options?.onPlan, options?.onUsage, options?.onCommands, rawStream);
         const baseText = getPromptText(result2);
         if (!reply) {
           return { text: baseText };
@@ -32671,6 +32700,15 @@ ${baseText}` : "" };
     await this.removeSession(session3);
     await deleteAcpxSessionFiles({ acpxRecordId });
   }
+  async freeWarmProcess(session3) {
+    let acpxRecordId;
+    try {
+      ({ acpxRecordId } = await this.readSessionRecord(session3));
+    } catch {
+      return;
+    }
+    await terminateAcpxQueueOwner(acpxRecordId);
+  }
   async hasSession(session3) {
     const result = await this.runCommand(this.command, this.buildArgs(session3, [
       "sessions",
@@ -32758,7 +32796,7 @@ ${baseText}` : "" };
       })
     ]);
   }
-  async runStreamingPrompt(command, args, reply, formatToolCalls = false, toolEventMode = "text", replyContext, onSegment, onToolEvent, onThought, onPlan, rawStream = false) {
+  async runStreamingPrompt(command, args, reply, formatToolCalls = false, toolEventMode = "text", replyContext, onSegment, onToolEvent, onThought, onPlan, onUsage, onCommands, rawStream = false) {
     const hooks = this.streamingHooks;
     const doSpawn = hooks.spawnPrompt ?? ((cmd, spawnArgs) => spawn9(cmd, spawnArgs, { stdio: ["ignore", "pipe", "pipe"] }));
     const setIntervalFn = hooks.setIntervalFn ?? ((fn, delay) => setInterval(fn, delay));
@@ -32780,9 +32818,15 @@ ${baseText}` : "" };
       let thoughtError;
       let planChain = Promise.resolve();
       let planError;
+      let usageChain = Promise.resolve();
+      let usageError;
+      let commandsChain = Promise.resolve();
+      let commandsError;
       const userOnToolEvent = onToolEvent;
       const userOnThought = onThought;
       const userOnPlan = onPlan;
+      const userOnUsage = onUsage;
+      const userOnCommands = onCommands;
       const state = createStreamingPromptState(formatToolCalls, {
         mode: toolEventMode,
         rawStream,
@@ -32806,6 +32850,20 @@ ${baseText}` : "" };
               planError ??= error2;
             });
           }
+        } : {},
+        ...userOnUsage ? {
+          onUsage: (usage) => {
+            usageChain = usageChain.then(() => userOnUsage(usage)).catch((error2) => {
+              usageError ??= error2;
+            });
+          }
+        } : {},
+        ...userOnCommands ? {
+          onCommands: (commands) => {
+            commandsChain = commandsChain.then(() => userOnCommands(commands)).catch((error2) => {
+              commandsError ??= error2;
+            });
+          }
         } : {}
       });
       const sink = reply ? rawStream ? createVerbatimReplySink(reply) : createQuotaGatedReplySink({
@@ -32860,7 +32918,9 @@ ${baseText}` : "" };
           segmentChain,
           toolEventChain,
           thoughtChain,
-          planChain
+          planChain,
+          usageChain,
+          commandsChain
         ]).then(() => {
           const deferred = sink?.getPendingError();
           if (deferred) {
@@ -32883,6 +32943,14 @@ ${baseText}` : "" };
             reject(planError);
             return;
           }
+          if (usageError) {
+            reject(usageError);
+            return;
+          }
+          if (commandsError) {
+            reject(commandsError);
+            return;
+          }
           resolve3({
             result: { code: code ?? 1, stdout: stdout2, stderr },
             overflowCount
@@ -33845,6 +33913,12 @@ class ControlService {
     await this.deps.transport.setModel(session3, modelId);
     await this.deps.sessions.setSessionModel(session3.alias, modelId);
   }
+  async setSessionDisplayName(chatKey, alias, displayName) {
+    const session3 = await this.resolveControlSession(chatKey, alias);
+    if (!session3)
+      throw new Error("session not found");
+    await this.deps.sessions.setDisplayName(session3.alias, displayName);
+  }
   async resolveControlSession(chatKey, alias) {
     const internalAlias = await this.deps.sessions.resolveAliasForChat(chatKey, alias);
     return await this.deps.sessions.getSession(internalAlias);
@@ -33861,7 +33935,9 @@ class ControlService {
       transportSession: session3.transportSession,
       running: this.deps.activeTurns.isActiveAnywhere(session3.alias),
       archived: session3.archived === true,
-      ...session3.agentCommand ? { agentCommand: session3.agentCommand } : {}
+      ...session3.source === "agent-side" ? { native: true } : {},
+      ...session3.agentCommand ? { agentCommand: session3.agentCommand } : {},
+      ...session3.displayName ? { displayName: session3.displayName } : {}
     }));
   }
   async listNativeSessions(_chatKey, agent3, workspace3) {
@@ -34012,10 +34088,14 @@ class ControlService {
       resolveSettled = resolve4;
     });
     this.inFlight.set(key, { controller, settled });
+    let internalAlias;
     let wasArchived = false;
+    let priorTransportSession;
     try {
-      const internalAlias = await this.deps.sessions.resolveAliasForChat(params.chatKey, params.sessionAlias);
-      wasArchived = (await this.deps.sessions.getSession(internalAlias))?.archived === true;
+      internalAlias = await this.deps.sessions.resolveAliasForChat(params.chatKey, params.sessionAlias);
+      const prior = await this.deps.sessions.getSession(internalAlias);
+      wasArchived = prior?.archived === true;
+      priorTransportSession = prior?.transportSession;
     } catch {}
     try {
       await this.deps.sessions.useSession(params.chatKey, params.sessionAlias);
@@ -34158,6 +34238,14 @@ ${chunk}` : chunk
     } finally {
       this.inFlight.delete(key);
       resolveSettled();
+      if (internalAlias && priorTransportSession) {
+        try {
+          const after = await this.deps.sessions.getSession(internalAlias);
+          if (after && after.transportSession !== priorTransportSession) {
+            this.deps.events.emit({ type: "sessions-changed" });
+          }
+        } catch {}
+      }
     }
   }
   cancelTurn(chatKey, sessionAlias) {

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

@@ -18,11 +18,17 @@ export interface ControlSessionInfo {
     transportSession: string;
     running: boolean;
     archived: boolean;
+    /** True when this logical session was attached to an existing agent-side (native) rollout
+     *  rather than freshly created. Mirrors LogicalSession.source === "agent-side"; omitted for
+     *  fresh xacpx sessions so the wire stays minimal. */
+    native?: boolean;
     /** The agent adapter command this session runs (acpx-recorded, or the agent's resolved
      *  default). Surfaced so the web can avoid seeding a new session's model picker from a
      *  session on a different adapter version (whose advertised model ids may be in an
      *  incompatible format). Omitted when unknown. */
     agentCommand?: string;
+    /** Cosmetic relay-web display label; omitted when unset so the wire stays minimal. */
+    displayName?: string;
 }
 export interface ControlAgentInfo {
     name: string;
@@ -42,7 +48,7 @@ export interface ControlWorkspaceInfo {
 }
 export interface ControlServiceDeps {
     agent: Pick<ChatAgent, "chat">;
-    sessions: Pick<SessionService, "listAllResolvedSessions" | "removeSession" | "useSession" | "resolveAliasForChat" | "getSession" | "setSessionModel">;
+    sessions: Pick<SessionService, "listAllResolvedSessions" | "removeSession" | "useSession" | "resolveAliasForChat" | "getSession" | "setSessionModel" | "setDisplayName">;
     transport: Pick<SessionTransport, "setModel" | "getSessionModel">;
     createSessionWithTransport: (internalAlias: string, agent: string, workspace: string, model?: string) => Promise<ResolvedSession>;
     removeSessionWithTransport: (internalAlias: string) => Promise<{
@@ -132,6 +138,8 @@ export declare class ControlService {
     }>;
     /** Switch a session's model (acpx validates the id) and persist the override. */
     setSessionModel(chatKey: string, alias: string, modelId: string): Promise<void>;
+    /** Set (or clear) a session's relay-web display label and persist it. */
+    setSessionDisplayName(chatKey: string, alias: string, displayName: string): Promise<void>;
     /** Resolve a chat-scoped display alias to its ResolvedSession, or null. */
     private resolveControlSession;
     get events(): ControlEventBus;

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

@@ -116,6 +116,8 @@ export declare class SessionService {
     private toResolvedSession;
     /** Persist (or clear) a session's model override by internal alias. */
     setSessionModel(alias: string, modelId: string | undefined): Promise<void>;
+    /** Set (or clear) a session's relay-web display label. Identity (`alias`) is untouched. */
+    setDisplayName(alias: string, name?: string): Promise<void>;
     /** Persist (or clear) the model override of the chat's current session. */
     setCurrentSessionModel(chatKey: string, modelId: string | undefined): Promise<void>;
     setSessionTransportAgentCommand(alias: string, transportAgentCommand: string | undefined): Promise<void>;

package/dist/state/types.d.ts

@@ -29,6 +29,9 @@ export interface LogicalSession {
     mode_id?: string;
     /** Per-session LLM model override (e.g. `gpt-5.2[high]`); falls back to the agent config default. */
     model?: string;
+    /** Per-session cosmetic display label shown in the relay-web dashboard only.
+     *  Never affects identity (`alias`), `/use`, or the transport session. Cleared → UI shows alias. */
+    display_name?: string;
     reply_mode?: "stream" | "final" | "verbose";
     /** True when the user archived this session: process closed, row greyed + sunk.
      *  Cleared on the next useSession (restore-on-message). */

package/dist/transport/types.d.ts

@@ -59,6 +59,9 @@ export interface ResolvedSession {
      * no `--model` is passed and acpx uses the agent adapter's default.
      */
     model?: string;
+    /** Cosmetic per-session display label (relay-web only). Mirrors LogicalSession.display_name;
+     *  undefined when unset. Does not affect identity or transport. */
+    displayName?: string;
     workspace: string;
     transportSession: string;
     source?: "xacpx" | "agent-side";
@@ -207,6 +210,15 @@ export interface SessionTransport {
      * that can't delete omit it. A missing acpx session is a no-op (idempotent).
      */
     deleteSession?(session: ResolvedSession): Promise<void>;
+    /**
+     * Terminate the warm queue-owner process for this session, freeing its
+     * resources, WITHOUT closing the acpx session (no `closed` flag, no metadata
+     * change) — the session stays open and resumes with full history on the next
+     * prompt. Idempotent: a missing warm process or missing session is a no-op.
+     * Used by archive to free the process now instead of waiting for acpx's TTL.
+     * Optional: transports that can't reap omit it.
+     */
+    freeWarmProcess?(session: ResolvedSession): Promise<void>;
     /**
      * Read the underlying agent-native session id for an existing transport
      * session. Used by `/clear` to keep a native session native: the fresh

package/package.json

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