@ganglion/xacpx 0.17.1 → 0.18.0

package/dist/bridge/bridge-main.js

@@ -5698,6 +5698,18 @@ function createDefaultQueueOwnerTerminator(_acpxCommand) {
     await terminateAcpxQueueOwner(sessionId);
   };
 }
+async function readQueueOwnerPid(sessionId) {
+  let owner;
+  try {
+    owner = JSON.parse(await readFile(queueLockFilePath(sessionId), "utf8"));
+  } catch {
+    return;
+  }
+  if (typeof owner.pid === "number" && Number.isInteger(owner.pid) && owner.pid > 0) {
+    return owner.pid;
+  }
+  return;
+}
 async function terminateAcpxQueueOwner(sessionId) {
   const lockPath = queueLockFilePath(sessionId);
   let owner;
@@ -5740,6 +5752,88 @@ var init_acpx_queue_owner_launcher = __esm(() => {
   init_i18n();
 });
 
+// src/runtime/core-home.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { join as join4 } from "node:path";
+function coreHomeDir(home) {
+  const primary = join4(home, CORE_HOME_DIR_NAME);
+  if (existsSync2(primary))
+    return primary;
+  const legacy = join4(home, CORE_HOME_LEGACY_DIR_NAME);
+  if (existsSync2(legacy))
+    return legacy;
+  return primary;
+}
+function coreHomeDisplayPath(...segments) {
+  return ["~", CORE_HOME_DIR_NAME, ...segments].join("/");
+}
+var CORE_HOME_DIR_NAME = ".xacpx", CORE_HOME_LEGACY_DIR_NAME = ".weacpx";
+var init_core_home = () => {};
+
+// src/orchestration/orchestration-ipc.ts
+import { createHash as createHash3 } from "node:crypto";
+import { join as join5 } from "node:path";
+function resolveOrchestrationEndpoint(runtimeDir, platform = process.platform) {
+  if (platform === "win32") {
+    const suffix = createHash3("sha256").update(runtimeDir).digest("hex").slice(0, 12);
+    return {
+      kind: "named-pipe",
+      path: `\\\\.\\pipe\\xacpx-orchestration-${suffix}`
+    };
+  }
+  return {
+    kind: "unix",
+    path: join5(runtimeDir, "orchestration.sock")
+  };
+}
+function createOrchestrationEndpoint(path2, platform = process.platform) {
+  return {
+    kind: platform === "win32" || path2.startsWith("\\\\.\\pipe\\") ? "named-pipe" : "unix",
+    path: path2
+  };
+}
+function encodeOrchestrationRpcRequest(request) {
+  return `${JSON.stringify(request)}
+`;
+}
+function encodeOrchestrationRpcResponse(response) {
+  return `${JSON.stringify(response)}
+`;
+}
+var init_orchestration_ipc = () => {};
+
+// src/daemon/daemon-files.ts
+import { dirname as dirname3, join as join6 } from "node:path";
+function resolveDaemonPaths(options) {
+  const runtimeDir = options.runtimeDir ?? (options.configPath ? resolveRuntimeDirFromConfigPath(options.configPath) : join6(coreHomeDir(options.home), "runtime"));
+  return {
+    runtimeDir,
+    pidFile: join6(runtimeDir, "daemon.pid"),
+    statusFile: join6(runtimeDir, "status.json"),
+    stdoutLog: join6(runtimeDir, "stdout.log"),
+    stderrLog: join6(runtimeDir, "stderr.log"),
+    appLog: join6(runtimeDir, "app.log")
+  };
+}
+function resolveRuntimeDirFromConfigPath(configPath) {
+  return join6(dirname3(configPath), "runtime");
+}
+function resolveDaemonOrchestrationSocketPath(runtimeDir, platform = process.platform) {
+  return resolveOrchestrationEndpoint(runtimeDir, platform).path;
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+var init_daemon_files = __esm(() => {
+  init_core_home();
+  init_orchestration_ipc();
+});
+
 // src/util/path.ts
 import path2 from "node:path";
 import { homedir as homedir4 } from "node:os";
@@ -5782,10 +5876,10 @@ var init_path = __esm(() => {
 // src/transport/codex-subagent-filter.ts
 import { closeSync, openSync, readdirSync, readSync, statSync } from "node:fs";
 import { homedir as homedir5 } from "node:os";
-import { join as join4 } from "node:path";
+import { join as join7 } from "node:path";
 function resolveCodexHome(env = process.env) {
   const fromEnv = env.CODEX_HOME?.trim();
-  return fromEnv ? fromEnv : join4(homedir5(), ".codex");
+  return fromEnv ? fromEnv : join7(homedir5(), ".codex");
 }
 function isPlainObject(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
@@ -5850,7 +5944,7 @@ function filterSubagentSessions(result, isSubagent) {
   };
 }
 function nodeRolloutReader(home) {
-  const root = join4(home, "sessions");
+  const root = join7(home, "sessions");
   return {
     listRolloutPaths() {
       const out = [];
@@ -5862,7 +5956,7 @@ function nodeRolloutReader(home) {
           return;
         }
         for (const entry of entries) {
-          const full = join4(dir, entry.name);
+          const full = join7(dir, entry.name);
           if (entry.isDirectory())
             walk(full);
           else if (entry.isFile() && entry.name.startsWith("rollout-") && entry.name.endsWith(".jsonl"))
@@ -5978,11 +6072,11 @@ var init_agent_session_list = __esm(() => {
 // src/transport/acpx-session-files.ts
 import { readdir, unlink as unlink2 } from "node:fs/promises";
 import { homedir as homedir6 } from "node:os";
-import { join as join5 } from "node:path";
+import { join as join8 } from "node:path";
 async function deleteAcpxSessionFiles(options) {
-  const dir = options.sessionsDir ?? join5(homedir6(), ".acpx", "sessions");
+  const dir = options.sessionsDir ?? join8(homedir6(), ".acpx", "sessions");
   const safeId = encodeURIComponent(options.acpxRecordId);
-  await unlink2(join5(dir, `${safeId}.json`)).catch(() => {
+  await unlink2(join8(dir, `${safeId}.json`)).catch(() => {
     return;
   });
   let entries;
@@ -5993,7 +6087,7 @@ async function deleteAcpxSessionFiles(options) {
   }
   const streamFiles = entries.filter((name) => name.startsWith(`${safeId}.stream.`));
   for (const name of streamFiles) {
-    await unlink2(join5(dir, name)).catch(() => {
+    await unlink2(join8(dir, name)).catch(() => {
       return;
     });
   }
@@ -6260,7 +6354,7 @@ init_prompt_media();
 init_streaming_prompt();
 import { copyFile, readdir as readdir2 } from "node:fs/promises";
 import { homedir as homedir7 } from "node:os";
-import { dirname as dirname3, join as join6, win32 } from "node:path";
+import { dirname as dirname4, join as join9, win32 } from "node:path";
 import { spawn as spawn4 } from "node:child_process";
 
 // src/bridge/parse-missing-optional-dep.ts
@@ -6279,6 +6373,7 @@ function parseMissingOptionalDep(text) {
 // src/bridge/bridge-runtime.ts
 init_discover_parent_package_paths();
 init_acpx_queue_owner_launcher();
+init_daemon_files();
 init_agent_session_list();
 init_codex_subagent_filter();
 init_acpx_session_files();
@@ -6343,6 +6438,7 @@ class BridgeRuntime {
     });
   }
   async resumeAgentSession(input) {
+    this.invalidateRecordIdCache(input);
     const spawnSpec = resolveSpawnCommand(this.command, this.buildSessionArgs(input, [
       "sessions",
       "new",
@@ -6412,6 +6508,7 @@ class BridgeRuntime {
     throw new Error(message);
   }
   async ensureSession(input, onProgress) {
+    this.invalidateRecordIdCache(input);
     try {
       return await this.attemptEnsureSession(input, onProgress);
     } catch (error) {
@@ -6526,7 +6623,7 @@ class BridgeRuntime {
         const resolved = __require.resolve(`${candidate}/package.json`, {
           paths: [process.cwd(), ...__require.resolve.paths(candidate) ?? []]
         });
-        return dirname3(resolved);
+        return dirname4(resolved);
       } catch {
         continue;
       }
@@ -6713,6 +6810,7 @@ class BridgeRuntime {
     };
   }
   async removeSession(input) {
+    this.invalidateRecordIdCache(input);
     const spawnSpec = resolveSpawnCommand(this.command, this.buildSessionArgs(input, [
       "sessions",
       "close",
@@ -6751,6 +6849,27 @@ class BridgeRuntime {
     await terminateAcpxQueueOwner(acpxRecordId);
     return {};
   }
+  recordIdCache = new Map;
+  recordIdCacheKey(input) {
+    return JSON.stringify([input.agent, input.agentCommand ?? null, input.cwd, input.name]);
+  }
+  invalidateRecordIdCache(input) {
+    this.recordIdCache.delete(this.recordIdCacheKey(input));
+  }
+  async isSessionWarm(input) {
+    const cacheKey = this.recordIdCacheKey(input);
+    let acpxRecordId = this.recordIdCache.get(cacheKey);
+    if (!acpxRecordId) {
+      try {
+        ({ acpxRecordId } = await this.readSessionRecord(input));
+      } catch {
+        return { warm: false };
+      }
+      this.recordIdCache.set(cacheKey, acpxRecordId);
+    }
+    const pid = await readQueueOwnerPid(acpxRecordId);
+    return { warm: pid !== undefined && isProcessAlive(pid) };
+  }
   async shutdown() {
     return {};
   }
@@ -6941,7 +7060,7 @@ async function tryRepairAcpxSessionIndex(deps = {}) {
   if (!home) {
     return false;
   }
-  const pathJoin = platform === "win32" ? win32.join : join6;
+  const pathJoin = platform === "win32" ? win32.join : join9;
   const sessionsDir = pathJoin(home, ".acpx", "sessions");
   const indexPath = pathJoin(sessionsDir, "index.json");
   const readdirFn = deps.readdirFn ?? readdir2;
@@ -6991,6 +7110,7 @@ var BRIDGE_METHODS = new Set([
   "removeSession",
   "deleteSession",
   "freeWarmProcess",
+  "isSessionWarm",
   "getAgentSessionId"
 ]);
 var SESSION_SCOPED_METHODS = new Set([
@@ -7008,6 +7128,7 @@ var SESSION_SCOPED_METHODS = new Set([
   "removeSession",
   "deleteSession",
   "freeWarmProcess",
+  "isSessionWarm",
   "getAgentSessionId"
 ]);
 
@@ -7068,7 +7189,7 @@ class BridgeServer {
     if (!sessionKey) {
       return await this.dispatch(requestId, method, params, writeLine);
     }
-    const lane = method === "cancel" ? "control" : "normal";
+    const lane = method === "cancel" || method === "isSessionWarm" ? "control" : "normal";
     return await this.scheduler.run(sessionKey, lane, () => this.dispatch(requestId, method, params, writeLine));
   }
   async dispatch(requestId, method, params, writeLine) {
@@ -7279,6 +7400,14 @@ class BridgeServer {
           cwd: requireString(params, "cwd"),
           name: requireString(params, "name")
         });
+      case "isSessionWarm":
+        return await this.runtime.isSessionWarm({
+          agent: requireString(params, "agent"),
+          ...agentExecutionSettings(params),
+          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

@@ -32133,6 +32133,18 @@ function createDefaultQueueOwnerTerminator(_acpxCommand) {
     await terminateAcpxQueueOwner(sessionId);
   };
 }
+async function readQueueOwnerPid(sessionId) {
+  let owner;
+  try {
+    owner = JSON.parse(await readFile13(queueLockFilePath(sessionId), "utf8"));
+  } catch {
+    return;
+  }
+  if (typeof owner.pid === "number" && Number.isInteger(owner.pid) && owner.pid > 0) {
+    return owner.pid;
+  }
+  return;
+}
 async function terminateAcpxQueueOwner(sessionId) {
   const lockPath = queueLockFilePath(sessionId);
   let owner;
@@ -32989,6 +33001,10 @@ ${result.text}` : "" };
   async freeWarmProcess(session3) {
     await this.client.request("freeWarmProcess", this.toParams(session3));
   }
+  async isSessionWarm(session3) {
+    const result = await this.client.request("isSessionWarm", this.toParams(session3));
+    return result.warm === true;
+  }
   async getAgentSessionId(session3) {
     const result = await this.client.request("getAgentSessionId", this.toParams(session3));
     return result.agentSessionId;
@@ -34105,6 +34121,7 @@ class AcpxCliTransport {
     this.resolveSpawnEnvironment = options.resolveSpawnEnvironment ?? resolveClaudeSpawnEnvironment;
   }
   async ensureSession(session3, _onProgress) {
+    this.invalidateRecordIdCache(session3);
     try {
       await this.runEnsureSession(session3);
     } catch (error2) {
@@ -34317,6 +34334,7 @@ ${baseText}` : "" };
     };
   }
   async resumeAgentSession(session3, agentSessionId) {
+    this.invalidateRecordIdCache(session3);
     const args = this.buildArgs(session3, [
       "sessions",
       "new",
@@ -34337,6 +34355,7 @@ ${baseText}` : "" };
     this.permissionPolicy = policy.permissionPolicy;
   }
   async removeSession(session3) {
+    this.invalidateRecordIdCache(session3);
     const result = await this.runCommandWithTimeout(this.runCommand, this.buildArgs(session3, [
       "sessions",
       "close",
@@ -34373,6 +34392,30 @@ ${baseText}` : "" };
     }
     await terminateAcpxQueueOwner(acpxRecordId);
   }
+  recordIdCache = new Map;
+  recordIdCacheKey(session3) {
+    return JSON.stringify([session3.agent, session3.agentCommand ?? null, session3.cwd, session3.transportSession]);
+  }
+  invalidateRecordIdCache(session3) {
+    this.recordIdCache.delete(this.recordIdCacheKey(session3));
+  }
+  async isSessionWarm(session3) {
+    const cacheKey = this.recordIdCacheKey(session3);
+    let acpxRecordId = this.recordIdCache.get(cacheKey);
+    if (!acpxRecordId) {
+      try {
+        ({ acpxRecordId } = await this.readSessionRecord(session3));
+      } catch {
+        return false;
+      }
+      this.recordIdCache.set(cacheKey, acpxRecordId);
+    }
+    const pid = await readQueueOwnerPid(acpxRecordId);
+    if (pid === undefined) {
+      return false;
+    }
+    return isProcessAlive(pid);
+  }
   async hasSession(session3) {
     const result = await this.runCommandWithTimeout(this.runCommand, this.buildArgs(session3, [
       "sessions",
@@ -34705,6 +34748,7 @@ var init_acpx_cli_transport = __esm(() => {
   init_node_pty_helper();
   init_terminate_process_tree();
   init_acpx_queue_owner_launcher();
+  init_daemon_files();
   init_agent_session_list();
   init_codex_subagent_filter();
   init_acpx_session_files();
@@ -36444,7 +36488,7 @@ class WorkspaceFs {
     }
     const files = [];
     try {
-      const { stdout: stdout2 } = await execFileAsync("git", ["-C", root, "-c", "core.quotePath=false", "status", "--porcelain", "-z"], { maxBuffer: GIT_MAX_BUFFER, timeout: GIT_TIMEOUT_MS, killSignal: "SIGKILL" });
+      const { stdout: stdout2 } = await execFileAsync("git", ["-C", root, "-c", "core.quotePath=false", "status", "--porcelain", "-z", "--untracked-files=all"], { maxBuffer: GIT_MAX_BUFFER, timeout: GIT_TIMEOUT_MS, killSignal: "SIGKILL" });
       const fields = stdout2.split("\x00");
       for (let i = 0;i < fields.length; i++) {
         const field = fields[i];
@@ -36672,9 +36716,10 @@ class WorkspaceGit {
     return (await this.runRaw(root, args)).trim();
   }
   async runRaw(root, args) {
+    const fullArgs = ["-C", root, "-c", "gc.auto=0", ...args];
     if (this.runGitOverride)
-      return await this.runGitOverride(root, args);
-    const result = await execFileAsync2("git", ["-C", root, ...args], {
+      return await this.runGitOverride(root, fullArgs);
+    const result = await execFileAsync2("git", fullArgs, {
       timeout: GIT_TIMEOUT_MS2,
       killSignal: "SIGKILL",
       maxBuffer: GIT_MAX_BUFFER2
@@ -36950,19 +36995,21 @@ class WorkspaceGit {
         ...worktreePath ? { worktreePath } : {}
       };
     });
-    const statusRaw = await this.runRaw(root, ["-c", "core.quotePath=false", "status", "--porcelain", "-z"]);
     const files = [];
-    const fields = statusRaw.split("\x00");
-    for (let index = 0;index < fields.length; index += 1) {
-      const field = fields[index];
-      if (!field)
-        continue;
-      const status = field.slice(0, 2);
-      const path14 = field.slice(3);
-      if (status[0] === "R" || status[0] === "C")
-        index += 1;
-      files.push({ path: path14, status });
-    }
+    try {
+      const statusRaw = await this.runRaw(root, ["-c", "core.quotePath=false", "status", "--porcelain", "-z", "--untracked-files=all"]);
+      const fields = statusRaw.split("\x00");
+      for (let index = 0;index < fields.length; index += 1) {
+        const field = fields[index];
+        if (!field)
+          continue;
+        const status = field.slice(0, 2);
+        const path14 = field.slice(3);
+        if (status[0] === "R" || status[0] === "C")
+          index += 1;
+        files.push({ path: path14, status });
+      }
+    } catch {}
     files.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
     return {
       workspace: workspace3,
@@ -37069,6 +37116,11 @@ class SessionTurnRunner {
     if (wasArchived) {
       this.deps.events.emit({ type: "sessions-changed" });
     }
+    if (internalAlias && this.deps.sessionWarmth) {
+      const bound = await this.deps.sessions.getSession(internalAlias).catch(() => null);
+      if (bound)
+        this.deps.sessionWarmth.markWarm(bound);
+    }
     this.deps.events.emit({
       type: "turn-started",
       chatKey: req.chatKey,
@@ -37685,6 +37737,7 @@ class ControlService {
     if (!session3)
       throw new Error("session not found");
     await this.deps.sessions.setDisplayName(session3.alias, displayName);
+    this.deps.events.emit({ type: "sessions-changed" });
   }
   async resolveControlSession(chatKey, alias) {
     const internalAlias = await this.deps.sessions.resolveAliasForChat(chatKey, alias);
@@ -37695,17 +37748,22 @@ class ControlService {
   }
   listSessions(chatKey) {
     const channelId = getChannelIdFromChatKey(chatKey);
-    return this.deps.sessions.listAllResolvedSessions().filter((session3) => isSessionAliasVisibleInChannel(session3.alias, channelId)).map((session3) => ({
-      alias: toDisplaySessionAlias(session3.alias),
-      agent: session3.agent,
-      workspace: session3.workspace,
-      transportSession: session3.transportSession,
-      running: this.deps.activeTurns.isActiveAnywhere(session3.alias),
-      archived: session3.archived === true,
-      ...session3.source === "agent-side" ? { native: true } : {},
-      ...session3.agentCommand ? { agentCommand: session3.agentCommand } : {},
-      ...session3.displayName ? { displayName: session3.displayName } : {}
-    }));
+    return this.deps.sessions.listAllResolvedSessions().filter((session3) => isSessionAliasVisibleInChannel(session3.alias, channelId)).map((session3) => {
+      const running = this.deps.activeTurns.isActiveAnywhere(session3.alias);
+      const warm = running ? true : this.deps.sessionWarmth?.isWarm(session3);
+      return {
+        alias: toDisplaySessionAlias(session3.alias),
+        agent: session3.agent,
+        workspace: session3.workspace,
+        transportSession: session3.transportSession,
+        running,
+        archived: session3.archived === true,
+        ...warm !== undefined ? { warm } : {},
+        ...session3.source === "agent-side" ? { native: true } : {},
+        ...session3.agentCommand ? { agentCommand: session3.agentCommand } : {},
+        ...session3.displayName ? { displayName: session3.displayName } : {}
+      };
+    });
   }
   async listNativeSessions(_chatKey, agent3, workspace3) {
     const sessions = await this.deps.listNativeSessions(agent3, workspace3);
@@ -37747,6 +37805,11 @@ class ControlService {
   async archiveSession(chatKey, alias) {
     const internalAlias = await this.deps.sessions.resolveAliasForChat(chatKey, alias);
     await this.deps.archiveSessionWithTransport(internalAlias);
+    const session3 = await this.deps.sessions.getSession(internalAlias).catch(() => {
+      return;
+    });
+    if (session3)
+      this.deps.sessionWarmth?.markCold(session3);
     this.deps.events.emit({ type: "sessions-changed" });
   }
   async unarchiveSession(chatKey, alias) {
@@ -37894,6 +37957,98 @@ var init_control_service = __esm(() => {
   MODEL_SET_SETTLE_BUDGET_MS = 2 * (DEFAULT_MANAGEMENT_COMMAND_TIMEOUT_MS + BRIDGE_REQUEST_TIMEOUT_GRACE_MS);
 });
 
+// src/control/session-warmth-tracker.ts
+class SessionWarmthTracker {
+  listSessions;
+  checkWarm;
+  events;
+  logger;
+  intervalMs;
+  setIntervalFn;
+  clearIntervalFn;
+  warmth = new Map;
+  intervalHandle = null;
+  ticking = false;
+  constructor(deps) {
+    this.listSessions = deps.listSessions;
+    this.checkWarm = deps.isWarm;
+    this.events = deps.events;
+    this.logger = deps.logger;
+    this.intervalMs = deps.intervalMs ?? 60000;
+    this.setIntervalFn = deps.setIntervalFn ?? ((fn, delay) => setInterval(fn, delay));
+    this.clearIntervalFn = deps.clearIntervalFn ?? ((timer) => clearInterval(timer));
+  }
+  start() {
+    if (this.intervalHandle !== null)
+      return;
+    this.intervalHandle = this.setIntervalFn(() => {
+      this.tick();
+    }, this.intervalMs);
+    this.tick();
+  }
+  stop() {
+    if (this.intervalHandle !== null) {
+      this.clearIntervalFn(this.intervalHandle);
+      this.intervalHandle = null;
+    }
+  }
+  isWarm(session3) {
+    return this.warmth.get(warmthKey(session3));
+  }
+  markWarm(session3) {
+    this.warmth.set(warmthKey(session3), true);
+  }
+  markCold(session3) {
+    this.warmth.set(warmthKey(session3), false);
+  }
+  async tick() {
+    if (this.ticking)
+      return;
+    this.ticking = true;
+    try {
+      const sessions = this.listSessions();
+      const seen = new Set;
+      let flipped = false;
+      for (const session3 of sessions) {
+        const key = warmthKey(session3);
+        if (seen.has(key))
+          continue;
+        seen.add(key);
+        let warm;
+        try {
+          warm = await this.checkWarm(session3);
+        } catch (error2) {
+          await this.logger?.error("warmth.check_failed", "session warmth check threw; keeping previous value", {
+            transportSession: session3.transportSession,
+            message: error2 instanceof Error ? error2.message : String(error2)
+          });
+          continue;
+        }
+        if (this.warmth.get(key) !== warm) {
+          this.warmth.set(key, warm);
+          flipped = true;
+        }
+      }
+      for (const key of [...this.warmth.keys()]) {
+        if (!seen.has(key))
+          this.warmth.delete(key);
+      }
+      if (flipped) {
+        this.events.emit({ type: "sessions-changed" });
+      }
+    } catch (error2) {
+      await this.logger?.error("warmth.tick_failed", "session warmth tick threw", {
+        message: error2 instanceof Error ? error2.message : String(error2)
+      });
+    } finally {
+      this.ticking = false;
+    }
+  }
+}
+function warmthKey(session3) {
+  return JSON.stringify([session3.agent, session3.agentCommand ?? null, session3.cwd, session3.transportSession]);
+}
+
 // src/control/terminal-service.ts
 import { randomUUID as randomUUID4 } from "node:crypto";
 import { createRequire as createRequire6 } from "node:module";
@@ -38798,6 +38953,13 @@ async function buildApp(paths, deps = {}) {
   const loadAgentRegistry = createAcpxAgentRegistryLoader({ logger });
   uploadStore.cleanup();
   const uploadCleanupInterval = setInterval(() => void uploadStore.cleanup().catch(() => {}), 60 * 60 * 1000);
+  const sessionWarmth = transport.isSessionWarm ? new SessionWarmthTracker({
+    listSessions: () => sessions.listAllResolvedSessions(),
+    isWarm: (session3) => transport.isSessionWarm(session3),
+    events: controlEvents,
+    logger
+  }) : undefined;
+  sessionWarmth?.start();
   const control = new ControlService({
     logger,
     agent: agent3,
@@ -38810,6 +38972,7 @@ async function buildApp(paths, deps = {}) {
     archiveSessionWithTransport: (internalAlias) => router3.archiveSessionWithTransport(internalAlias),
     unarchiveSession: (internalAlias) => router3.unarchiveSession(internalAlias),
     activeTurns,
+    ...sessionWarmth ? { sessionWarmth } : {},
     scheduled: scheduledService,
     orchestration: orchestration3,
     events: controlEvents,
@@ -38945,6 +39108,7 @@ async function buildApp(paths, deps = {}) {
     reapStaleQueueOwners: () => reapWarmQueueOwners("startup"),
     dispose: async () => {
       scheduledScheduler.stop();
+      sessionWarmth?.stop();
       configWatcher.close();
       clearInterval(uploadCleanupInterval);
       terminalService.disposeAll();

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

@@ -25,6 +25,10 @@ export interface ControlSessionInfo {
     transportSession: string;
     running: boolean;
     archived: boolean;
+    /** Whether the session's agent process is currently alive (next prompt responds
+     *  without a cold start). Omitted when unknown — e.g. the transport can't observe
+     *  liveness or the warmth tracker hasn't sampled this session yet. */
+    warm?: 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. */
@@ -72,6 +76,8 @@ export interface ControlServiceDeps {
         updatedAt?: string;
     }) => Promise<ResolvedSession>;
     activeTurns: Pick<ActiveTurnRegistry, "isActiveAnywhere">;
+    /** Warmth tracker view for the cold-session indicator; absent ⇒ `warm` omitted from listings. */
+    sessionWarmth?: Pick<import("./session-warmth-tracker").SessionWarmthTracker, "isWarm" | "markWarm" | "markCold">;
     scheduled: Pick<ScheduledTaskService, "listPending" | "listRecentForChat" | "createTask" | "cancelPending">;
     orchestration: Pick<OrchestrationService, "listTasks" | "getTask" | "requestTaskCancellation">;
     events: ControlEventBus;

package/dist/control/session-turn-runner.d.ts

@@ -26,7 +26,7 @@ export interface TurnResult {
 }
 export declare class SessionTurnRunner {
     private readonly deps;
-    constructor(deps: Pick<ControlServiceDeps, "agent" | "sessions" | "events" | "uploadStore">);
+    constructor(deps: Pick<ControlServiceDeps, "agent" | "sessions" | "events" | "uploadStore" | "sessionWarmth">);
     run(req: TurnRequest, signal: AbortSignal, onActivity?: () => void): Promise<TurnResult>;
     /** Resolve a chat-scoped display alias to its ResolvedSession and read whether it is
      *  in stream reply mode. Best-effort: any resolution failure falls back to batched

package/dist/control/session-warmth-tracker.d.ts

@@ -0,0 +1,42 @@
+import type { AppLogger } from "../logging/app-logger";
+import type { ResolvedSession } from "../transport/types";
+import type { ControlEventBus } from "./control-event-bus";
+export interface SessionWarmthTrackerDeps {
+    listSessions: () => ResolvedSession[];
+    isWarm: (session: ResolvedSession) => Promise<boolean>;
+    events: ControlEventBus;
+    logger?: AppLogger;
+    intervalMs?: number;
+    setIntervalFn?: (fn: () => void | Promise<void>, delay: number) => unknown;
+    clearIntervalFn?: (timer: unknown) => void;
+}
+/**
+ * Polls queue-owner process liveness for every logical session and emits a
+ * payload-free `sessions-changed` control event whenever any session's warmth
+ * flips (e.g. a silent TTL expiry), so connected dashboards re-fetch the list
+ * and refresh their cold indicators. `isWarm` gives the last observed value
+ * synchronously for `control.sessions.list`.
+ */
+export declare class SessionWarmthTracker {
+    private readonly listSessions;
+    private readonly checkWarm;
+    private readonly events;
+    private readonly logger?;
+    private readonly intervalMs;
+    private readonly setIntervalFn;
+    private readonly clearIntervalFn;
+    private readonly warmth;
+    private intervalHandle;
+    private ticking;
+    constructor(deps: SessionWarmthTrackerDeps);
+    start(): void;
+    stop(): void;
+    /** Last observed warmth for this session's transport; undefined until first checked. */
+    isWarm(session: ResolvedSession): boolean | undefined;
+    /** Immediate corrections from call sites that just changed warmth themselves
+     *  (archive kills the owner; a starting turn warms it). No event — the caller's
+     *  own flow already emits one. */
+    markWarm(session: ResolvedSession): void;
+    markCold(session: ResolvedSession): void;
+    tick(): Promise<void>;
+}

package/dist/transport/types.d.ts

@@ -232,6 +232,13 @@ export interface SessionTransport {
      * Optional: transports that can't reap omit it.
      */
     freeWarmProcess?(session: ResolvedSession): Promise<void>;
+    /**
+     * Whether this session's warm queue-owner process is currently alive (=
+     * the next prompt responds immediately instead of cold-starting). False
+     * when the owner exited via TTL, archive, or any other reason. Optional:
+     * transports that can't observe process liveness omit it.
+     */
+    isSessionWarm?(session: ResolvedSession): Promise<boolean>;
     /**
      * 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.17.1",
+  "version": "0.18.0",
   "description": "随时随地通过聊天频道（微信 / 飞书 / 元宝等）远程控制 `acpx` 上的 Claude Code、Codex 等 Agents。",
   "keywords": [
     "acpx",