@zhushanwen/zcode-subagent-cli 0.2.1 → 0.3.1

package/dist/{chunk-WQ7NVGKB.js → chunk-I5OX22FU.js}

@@ -22,7 +22,6 @@ function parseZcodeTurnTimeoutEnv(raw) {
   if (!Number.isFinite(parsed)) return { state: "invalid" };
   return { state: "valid", ms: parsed };
 }
-var ZCODE_SHARED_POOL_KEY = "shared";
 var ZCODE_APPSERVER_STOP_TIMEOUT_MS = 3e3;
 var ZCODE_APPSERVER_ABORT_GRACE_MS = 3e3;
 var ZCODE_APPSERVER_ERR_MODEL_CONFIG_MISSING = -32603;
@@ -31,6 +30,9 @@ var ZCODE_APPSERVER_HARVEST_GRACE_MS = 1e3;
 function isFailedTerminalStatus(status) {
   return status === "failed" || status === "error";
 }
+var ZCODE_RESUME_HISTORY_TOKEN_BUDGET = 24e3;
+var ZCODE_RESUME_CHARS_PER_TOKEN = 4;
+var ZCODE_SESSION_SWEEP_DEFER_MS = 50;
 
 // src/db-path.ts
 import * as os from "os";
@@ -278,9 +280,9 @@ async function readZcodeSessionView(dbPath, sessionId) {
 }
 
 // src/zcode-engine.ts
-import * as fs5 from "fs";
+import * as fs6 from "fs";
 import * as path4 from "path";
-import { getLogger as getLogger3 } from "@zhushanwen/subagent-engine-sdk";
+import { getLogger as getLogger4 } from "@zhushanwen/subagent-engine-sdk";
 import {
   buildEngineChildEnv as buildEngineChildEnv2,
   buildSchemaEmulationSegment,
@@ -289,6 +291,7 @@ import {
   synthesizeTimeoutOutcome,
   engineTimeoutDetail,
   resolvePoolDir,
+  SHARED_POOL_KEY,
   spawnEngineChild as spawnEngineChild2
 } from "@zhushanwen/subagent-engine-sdk";
 
@@ -779,7 +782,7 @@ var AppServerConnection = class {
     }
     const timeoutMs = opts?.timeoutMs ?? this.requestTimeoutMs;
     const id = ++this.reqSeq;
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(id);
         reject(new Error(`\u8BF7\u6C42 ${method} \u8D85\u65F6\uFF08${timeoutMs}ms\uFF09`));
@@ -787,7 +790,7 @@ var AppServerConnection = class {
       this.pending.set(id, {
         // 泛型 T 是调用方对线上 unknown 结果的视图声明，连接层不做运行时校验
         // （协议层保持透明，结构校验归会话层/消费方）。
-        resolve,
+        resolve: resolve2,
         reject,
         timer,
         method
@@ -1138,6 +1141,46 @@ function extractReadUsage(readResult) {
   }
   return isRecord3(readResult.usage) ? readResult.usage : void 0;
 }
+function extractResumeHistory(resumeResult) {
+  if (!isRecord3(resumeResult) || !Array.isArray(resumeResult.messages)) return [];
+  const turns = [];
+  for (const m of resumeResult.messages) {
+    if (!isRecord3(m)) continue;
+    const role = messageRole(m);
+    if (role !== "user" && role !== "assistant") continue;
+    const text = partsToText(m.parts) ?? contentToText(m.content);
+    if (text === void 0 || text === "") continue;
+    turns.push({ role, text });
+  }
+  return turns;
+}
+function accumulateTokenFields(source, keys, acc) {
+  for (const key of keys) {
+    const raw = source[key];
+    const v = typeof raw === "number" ? raw : Number(raw);
+    if (Number.isFinite(v) && v > 0) {
+      acc.total += v;
+      acc.has = true;
+    }
+  }
+}
+function accumulateStepFinishTokens(parts, acc) {
+  for (const p of parts) {
+    if (!isRecord3(p) || p.type !== "step-finish" || !isRecord3(p.tokens)) continue;
+    const t = p.tokens;
+    accumulateTokenFields(t, ["input", "output"], acc);
+    if (isRecord3(t.cache)) accumulateTokenFields(t.cache, ["read", "write"], acc);
+  }
+}
+function extractResumeTotalTokens(resumeResult) {
+  if (!isRecord3(resumeResult) || !Array.isArray(resumeResult.messages)) return void 0;
+  const acc = { total: 0, has: false };
+  for (const m of resumeResult.messages) {
+    if (!isRecord3(m) || messageRole(m) !== "assistant" || !Array.isArray(m.parts)) continue;
+    accumulateStepFinishTokens(m.parts, acc);
+  }
+  return acc.has ? acc.total : void 0;
+}
 var TurnTimeoutError = class extends Error {
   kind;
   elapsed;
@@ -1298,6 +1341,17 @@ var SessionChannel = class {
       );
     }
   }
+  /**
+   * session/resume 读通道（[U6 / §3.2.6 要点 3，P-1 探针实证]）：应答自带完整
+   * 双向 messages 历史（user/assistant 全量、tokens、parts）——zcode 续聊选型的
+   * 历史来源（读通道成立；原地 resume 续写被 -32031 卡死，写通道不可用）。错误
+   * 原样上抛（调用方决定降级形态——引擎侧 warn 后无历史前缀开新会话）。
+   * 经 conn.request 惰性启动连接（resume 是 run 的**首个**请求——调用时点连接
+   * 可能尚未启动，与 readBestEffort 的「已死跳过」判据不同场景，不做 alive 守卫）。
+   */
+  async resumeSession(sessionId) {
+    return this.conn.request("session/resume", { sessionId }, { timeoutMs: ZCODE_APPSERVER_TURN_READ_TIMEOUT_MS });
+  }
   /**
    * session/close（A.2 ⑦，D4 用后即毁——回收引擎驻留内存，SQLite 持久化保留）。
    * best-effort：失败只 warn 不抛（会话已终态，close 失败只泄漏一个驻留会话，
@@ -1644,8 +1698,166 @@ var SessionChannel = class {
   }
 };
 
-// src/zcode-engine.ts
+// src/session-db-maintenance.ts
+import * as fs5 from "fs";
+import { getLogger as getLogger3 } from "@zhushanwen/subagent-engine-sdk";
 var logger3 = getLogger3("subagents");
+var ZCODE_SESSION_TTL_MS = 2592e6;
+var ZCODE_SESSION_SWEEP_INTERVAL_MS = 864e5;
+var SWEEP_BUSY_TIMEOUT_MS = 5e3;
+var SESSION_CHILD_TABLES = [
+  "message",
+  "todo",
+  "session_entry",
+  "session_input",
+  "session_target",
+  "model_usage",
+  "turn_usage",
+  "tool_usage"
+];
+function loadDatabaseSyncCtor() {
+  const getBuiltin = process.getBuiltinModule;
+  if (typeof getBuiltin !== "function") return void 0;
+  const mod = getBuiltin("node:sqlite");
+  return typeof mod?.DatabaseSync === "function" ? mod.DatabaseSync : void 0;
+}
+function sessionLastActivity(row) {
+  for (const v of [row.time_updated, row.time_created]) {
+    if (typeof v === "number" && Number.isFinite(v)) return v;
+  }
+  return null;
+}
+function collectExpiredSessions(db, cutoff, keep) {
+  const rows = db.prepare("SELECT id, time_updated, time_created FROM session").all();
+  const expired = [];
+  let keptActive = 0;
+  for (const row of rows) {
+    if (typeof row.id !== "string" || row.id === "") continue;
+    const last = sessionLastActivity(row);
+    if (last === null || last >= cutoff) continue;
+    if (keep.has(row.id)) {
+      keptActive++;
+      continue;
+    }
+    expired.push(row.id);
+  }
+  return { expired, keptActive };
+}
+function ensureForeignKeysOn(db) {
+  db.exec("PRAGMA foreign_keys = ON");
+  const fkOn = db.prepare("PRAGMA foreign_keys").get();
+  if (fkOn?.foreign_keys !== 1) {
+    throw new Error("PRAGMA foreign_keys=ON \u672A\u751F\u6548\u2014\u2014\u4E2D\u6B62\u5220\u9664\uFF08\u9632\u5B64\u513F\u884C\uFF09\uFF0C\u672C\u8F6E sweep \u653E\u5F03");
+  }
+}
+function listPresentTables(db) {
+  return new Set(
+    db.prepare("SELECT name FROM sqlite_master WHERE type = 'table'").all().map((r) => typeof r.name === "string" ? r.name : "")
+  );
+}
+var DELETE_BATCH_SIZE = 500;
+function chunkIds(ids, size) {
+  const batches = [];
+  for (let i = 0; i < ids.length; i += size) batches.push(ids.slice(i, i + size));
+  return batches;
+}
+function deleteExpiredSessionsInTx(db, expired, present) {
+  db.exec("BEGIN");
+  try {
+    let swept = 0;
+    for (const batch of chunkIds(expired, DELETE_BATCH_SIZE)) {
+      const ph = batch.map(() => "?").join(", ");
+      for (const table of SESSION_CHILD_TABLES) {
+        if (present.has(table)) db.prepare(`DELETE FROM ${table} WHERE session_id IN (${ph})`).run(...batch);
+      }
+      if (present.has("session_task_link")) {
+        db.prepare(`DELETE FROM session_task_link WHERE child_session_id IN (${ph})`).run(...batch);
+        db.prepare(`UPDATE session_task_link SET parent_session_id = NULL WHERE parent_session_id IN (${ph})`).run(...batch);
+      }
+      if (present.has("workflow_run")) {
+        db.prepare(`UPDATE workflow_run SET parent_session_id = NULL WHERE parent_session_id IN (${ph})`).run(...batch);
+      }
+      if (present.has("workflow_activity")) {
+        db.prepare(`UPDATE workflow_activity SET child_session_id = NULL WHERE child_session_id IN (${ph})`).run(...batch);
+      }
+      if (present.has("input_history")) {
+        db.prepare(`DELETE FROM input_history WHERE session_id IN (${ph})`).run(...batch);
+      }
+      const res = db.prepare(`DELETE FROM session WHERE id IN (${ph})`).run(...batch);
+      swept += res.changes ?? batch.length;
+    }
+    db.exec("COMMIT");
+    return swept;
+  } catch (err) {
+    try {
+      db.exec("ROLLBACK");
+    } catch (rollbackErr) {
+      void rollbackErr;
+    }
+    throw err;
+  }
+}
+function sweepExpiredZcodeSessions(dbPath, opts = {}) {
+  const noOp = { swept: 0, keptActive: 0 };
+  if (!fs5.existsSync(dbPath)) return noOp;
+  const Ctor = loadDatabaseSyncCtor();
+  if (Ctor === void 0) {
+    logger3.warn("[zcode-ttl] node:sqlite \u4E0D\u53EF\u7528\uFF08\u9700 Node \u226522.3 \u7684 process.getBuiltinModule\uFF09\u2014\u2014\u672C\u8F6E sweep \u8DF3\u8FC7");
+    return noOp;
+  }
+  const now = opts.nowMs ?? Date.now();
+  const ttl = opts.ttlMs ?? ZCODE_SESSION_TTL_MS;
+  const cutoff = now - ttl;
+  const keep = opts.keepSessionIds ?? /* @__PURE__ */ new Set();
+  let db;
+  try {
+    db = new Ctor(dbPath);
+    db.exec(`PRAGMA busy_timeout = ${SWEEP_BUSY_TIMEOUT_MS}`);
+    const { expired, keptActive } = collectExpiredSessions(db, cutoff, keep);
+    if (expired.length === 0) {
+      db.close();
+      return { swept: 0, keptActive };
+    }
+    ensureForeignKeysOn(db);
+    const present = listPresentTables(db);
+    const swept = deleteExpiredSessionsInTx(db, expired, present);
+    logger3.debug(`[zcode-ttl] \u9694\u79BB\u5E93\u8D85\u7A97\u6761\u76EE\u5DF2\u6E05\uFF1A${swept} \u6761\uFF08TTL ${ttl}ms\uFF0C\u8C41\u514D\u6D3B\u8DC3 ${keptActive}\uFF09`, { dbPath });
+    try {
+      db.prepare("PRAGMA wal_checkpoint(PASSIVE)").get();
+    } catch (err) {
+      void err;
+    }
+    return { swept, keptActive };
+  } catch (err) {
+    logger3.warn(
+      `[zcode-ttl] sweep \u5931\u8D25\uFF08\u8F85\u52A9\u8D44\u6E90\u9762\uFF0C\u4E0D\u5F71\u54CD run \u4E3B\u94FE\u8DEF\uFF1B\u4E0B\u4E2A\u8282\u6D41\u7A97\u91CD\u8BD5\uFF09: ${err instanceof Error ? err.message : String(err)}`,
+      { dbPath }
+    );
+    return noOp;
+  } finally {
+    try {
+      db?.close();
+    } catch (err) {
+      void err;
+    }
+  }
+}
+var sweepThrottle = /* @__PURE__ */ new Map();
+function maybeSweepExpiredZcodeSessions(dbPath, opts = {}) {
+  const now = Date.now();
+  const last = sweepThrottle.get(dbPath);
+  if (!opts.force && last !== void 0 && now - last < ZCODE_SESSION_SWEEP_INTERVAL_MS) {
+    return { swept: 0, keptActive: 0 };
+  }
+  const result = sweepExpiredZcodeSessions(dbPath, {
+    ...opts.keepSessionIds !== void 0 ? { keepSessionIds: opts.keepSessionIds } : {}
+  });
+  sweepThrottle.set(dbPath, now);
+  return result;
+}
+
+// src/zcode-engine.ts
+var logger4 = getLogger4("subagents");
 var PROBE_VERSION_TIMEOUT_MS = 15e3;
 var COMMON_THOUGHT_LEVELS = ["low", "high", "max"];
 var ZcodeEngine = class {
@@ -1672,8 +1884,11 @@ var ZcodeEngine = class {
       schemaEnforcement: "emulated",
       // send-while-running 恒 -32010 硬错误（旧实测）——app-server 常驻化不改变此判据
       steer: "unsupported",
-      // 无同进程 idle 复用（D4：每任务自包含 create→run→close）
-      conversation: "unsupported",
+      // [U6 / §3.2.6 要点 4] "cold" = 冷恢复会话：session/resume 读通道取结构化
+      // 历史 + session/create 新会话注入首轮（无热 steering——interrupt 维持
+      // kill-only 如实声明）。P-1 探针：原地 resume 续写被 -32031 卡死，热会话
+      // 通道不可用，声明不越级。
+      conversation: "cold",
       // 无 --append-system-prompt flag（实测拒收）——persona 只能拼进 prompt
       personaInjection: "prompt",
       // app-server 推送流实时流出（session/event payload.delta → text_delta）
@@ -1717,7 +1932,7 @@ var ZcodeEngine = class {
   }
   /** check 1：二进制存在性（isFile 才算——同名目录不是可执行入口）。 */
   probeBinaryCheck(cliPath) {
-    const binaryOk = fs5.existsSync(cliPath) && fs5.statSync(cliPath).isFile();
+    const binaryOk = fs6.existsSync(cliPath) && fs6.statSync(cliPath).isFile();
     return {
       name: "binary",
       ok: binaryOk,
@@ -1755,8 +1970,8 @@ var ZcodeEngine = class {
   /**
    * 常驻路径主编排：模型解析（v2 单源校验）→ 惰性连接 + runTurn（事件时序前移：
    * text_delta 流式、终态后 message_end/turn_end）→ schema 仿真重试 → outcome/handle。
-   * poolKey 固定 'shared'（共享宿主 HOME，无池），onPoolResolved 在 prepare 期、
-   * onHandleReady 在 create 应答后（§3.4 不变量 3）。
+   * onHandleReady 在 create 应答后（§3.4 不变量 3；原 onPoolResolved prepare 期
+   * 声明已随 [池抽象降级 2026-09-13] poolKey 协议面退役删除）。
    */
   async runViaAppServer(task, ctx) {
     const startedAt = Date.now();
@@ -1766,10 +1981,10 @@ var ZcodeEngine = class {
     const modelRef = resolveZcodeModelRef(task.model, this.deps.sources);
     this.warnIgnoredCtxModel(task, ctx, modelRef);
     this.warnThoughtLevelUncommon(task, ctx);
-    ctx.onPoolResolved?.(ZCODE_SHARED_POOL_KEY);
     const cwd = task.cwd ?? process.cwd();
     const schema = isPlainObject(task.schema) ? task.schema : void 0;
-    const basePrompt = this.buildPrompt(task, schema);
+    const resumePrefix = await this.buildResumeHistoryPrefix(ctx);
+    const basePrompt = resumePrefix === void 0 ? this.buildPrompt(task, schema) : resumePrefix + this.buildPrompt(task, schema);
     const usageAcc = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, has: false };
     const final = await this.runAppServerAttemptsWithRetry(task, ctx, modelRef, cwd, basePrompt, schema, usageAcc);
     const outcome = this.finalizeOutcome(task, ctx, final, usageAcc, startedAt);
@@ -1777,7 +1992,6 @@ var ZcodeEngine = class {
   }
   /** pre-aborted 短路收口：合成中止 outcome + 'shared' 锚定 handle。 */
   abortedAppServerRun(task, ctx, startedAt) {
-    ctx.onPoolResolved?.(ZCODE_SHARED_POOL_KEY);
     const outcome = this.finalizeOutcome(
       task,
       ctx,
@@ -1811,11 +2025,11 @@ var ZcodeEngine = class {
     if (final.kind === "run-failed" && final.transient !== void 0 && ctx.signal?.aborted !== true && !this.disposed) {
       const budget = resolveTransientRetryBudget(explicitTurnBudgetMs(), Date.now() - attemptStartedAt);
       if (budget.state === "depleted") {
-        logger3.warn(
+        logger4.warn(
           `[zcode-engine] \u672B\u6B21 attempt \u77AC\u65F6\u5931\u8D25\uFF08${final.transient}\uFF09\u2014\u2014\u663E\u5F0F\u603B\u4E0A\u754C\u9884\u7B97\u5269\u4F59\u4E0D\u8DB3 ${ZCODE_TURN_RETRY_MIN_BUDGET_MS}ms\uFF0C\u4E0D\u91CD\u8BD5\u76F4\u63A5\u7EC8\u6001\u5316\uFF08\u9884\u7B97\u7EE7\u627F\uFF1A\u91CD\u8BD5\u4E0D\u91CD\u7F6E\u603B\u9884\u7B97\uFF09`
         );
       } else {
-        logger3.warn(
+        logger4.warn(
           `[zcode-engine] \u672B\u6B21 attempt \u77AC\u65F6\u5931\u8D25\uFF08${final.transient}\uFF09\u2014\u2014\u6B62\u635F\u94FE\u5DF2\u7EC8\u5C40\uFF0C\u65B0\u4F1A\u8BDD\u81EA\u52A8\u91CD\u8BD5\u4E00\u6B21` + (budget.state === "inherit" ? `\uFF08\u9884\u7B97\u7EE7\u627F\uFF1A\u91CD\u8BD5\u8F6E\u603B\u4E0A\u754C=\u5269\u4F59 ${budget.remainingMs}ms\uFF0C\u4E0D\u91CD\u7F6E\u603B\u9884\u7B97\uFF09` : "\uFF08\u65E0\u663E\u5F0F\u603B\u4E0A\u754C\u9884\u7B97\uFF0C\u91CD\u8BD5\u8F6E\u8D70 env/\u9ED8\u8BA4\u4E0A\u754C\uFF09")
         );
         const retry = await this.attemptAppServerTurn(task, ctx, modelRef, cwd, basePrompt, {
@@ -1851,7 +2065,6 @@ var ZcodeEngine = class {
           dbPath: zcodeSessionDbPath(this.deps.engineDataDir()),
           ...outcome.sessionId !== void 0 ? { sessionId: outcome.sessionId } : {}
         },
-        poolKey: ZCODE_SHARED_POOL_KEY,
         ...this.probeCache?.engineVersion !== void 0 && this.probeCache.engineVersion !== "" ? { engineVersion: this.probeCache.engineVersion } : {},
         adapterVersion: ZCODE_ADAPTER_VERSION
       }
@@ -1871,8 +2084,8 @@ var ZcodeEngine = class {
     const createParams = buildAppServerCreateParams(task, providerId, modelId, cwd);
     let currentSessionId;
     let signalSessionCreated;
-    const sessionCreated = new Promise((resolve) => {
-      signalSessionCreated = resolve;
+    const sessionCreated = new Promise((resolve2) => {
+      signalSessionCreated = resolve2;
     });
     const turn = rt.channel.runTurn(createParams, prompt, {
       // 事件时序前移：payload.delta → text_delta 实时流出（stream 粒度，D5）；
@@ -1882,16 +2095,16 @@ var ZcodeEngine = class {
       onThinkingDelta: (delta) => ctx.onEvent?.({ type: "thinking_delta", delta }),
       // [PR3] 工具执行期活性：非终态非增量的 session/event 帧（tool.updated progress
       // 等，真机探针实证每 ~1s 一帧）→ activity 事件（零载荷纯活性信号——宿主无进展
-      // 守护对任何事件类型刷新；reducer no-op、不落 journal）。zcode 引擎
-      // conversation:"unsupported"，run 域是唯一发射面（无 chat 域接线）。
+      // 守护对任何事件类型刷新；reducer no-op、不落 journal）。zcode 引擎声明
+      // conversation:"cold"（续聊 = session-store 冷恢复重建 + 新 run + resume 锚点，
+      // 无热 steering/chat 域接线），run 域是唯一发射面。
       onActivity: () => ctx.onEvent?.({ type: "activity" }),
       onSessionCreated: (sessionId) => {
         currentSessionId = sessionId;
         rt.activeSessions.add(sessionId);
         signalSessionCreated?.();
         ctx.onHandleReady?.({
-          sessionRef: { dbPath: zcodeSessionDbPath(this.deps.engineDataDir()), sessionId },
-          poolKey: ZCODE_SHARED_POOL_KEY
+          sessionRef: { dbPath: zcodeSessionDbPath(this.deps.engineDataDir()), sessionId }
         });
       },
       // 显式总上界传参（D2/U4：缺省缺席——channel 侧 resolveTurnTimerMs 走 env→默认）
@@ -1939,14 +2152,14 @@ var ZcodeEngine = class {
    */
   async awaitConnFinalized(rt) {
     if (!rt.conn.alive) return;
-    await new Promise((resolve) => {
+    await new Promise((resolve2) => {
       const timer = setTimeout(() => finish(), ZCODE_APPSERVER_HARVEST_GRACE_MS);
       if (typeof timer.unref === "function") timer.unref();
       const off = rt.conn.onClose(() => finish());
       function finish() {
         clearTimeout(timer);
         off();
-        resolve();
+        resolve2();
       }
     });
   }
@@ -1980,7 +2193,7 @@ var ZcodeEngine = class {
         delayResolved(ZCODE_APPSERVER_ABORT_GRACE_MS, false)
       ]);
       if (settled) return "settled-in-grace";
-      logger3.warn(
+      logger4.warn(
         `[zcode-engine] abort grace \u7A97\u53E3\u5185\u672A\u89C1\u7EC8\u6001\u2014\u2014killChain \u6536\u5272\u5171\u4EAB\u8FDB\u7A0B\uFF08\u63A5\u53D7\u8FDE\u5750\uFF0C\u5728\u9014\u4EFB\u52A1\u8D70\u5D29\u6E83\u8DEF\u5F84\uFF09`
       );
       await rt.conn.shutdown({ graceMs: ZCODE_KILL_GRACE_MS });
@@ -2005,19 +2218,19 @@ var ZcodeEngine = class {
     } catch (err) {
       if (entry.escalateOn === "stop-outcome") {
         if (isAppServerRpcError(err)) {
-          logger3.debug(
+          logger4.debug(
             `[zcode-engine] session/stop \u62A5\u534F\u8BAE\u6027 error\uFF08${errMessage3(err)}\uFF09\u2014\u2014\u4F1A\u8BDD\u5DF2\u56DE\u6536\uFF0C\u63A7\u5236\u9762\u5B58\u6D3B\uFF0C\u4E0D\u5347\u7EA7\u6740\u94FE`
           );
           return "stop-rejected";
         }
-        logger3.warn(
+        logger4.warn(
           `[zcode-engine] session/stop \u65E0\u5E94\u7B54\uFF08${errMessage3(err)}\uFF09\u2014\u2014\u5347\u7EA7 killChain \u6536\u5272\u5171\u4EAB\u8FDB\u7A0B\uFF08\u8D85\u65F6\u5165\u53E3\uFF0C\u63A5\u53D7\u8FDE\u5750\uFF09`
         );
         await rt.conn.shutdown({ graceMs: ZCODE_KILL_GRACE_MS });
         await this.awaitConnFinalized(rt);
         return "stop-unreachable-killed";
       }
-      logger3.debug(
+      logger4.debug(
         `[zcode-engine] session/stop \u5931\u8D25\uFF08${errMessage3(err)}\uFF09\u2014\u2014grace \u540E\u8D70 killChain \u515C\u5E95`
       );
     }
@@ -2046,7 +2259,7 @@ var ZcodeEngine = class {
     const sessionDbPath = zcodeSessionDbPath(engineDataDir);
     env.ZCODE_SESSION_DB_PATH = sessionDbPath;
     delete env.ZCODE_SESSION_DB;
-    fs5.mkdirSync(path4.dirname(sessionDbPath), { recursive: true });
+    fs6.mkdirSync(path4.dirname(sessionDbPath), { recursive: true });
     const conn = new AppServerConnection({
       cliPath,
       dataDir: engineDataDir,
@@ -2064,6 +2277,11 @@ var ZcodeEngine = class {
       activeSessions: /* @__PURE__ */ new Set()
     };
     this.appserverRuntime = rt;
+    const sweepDbPath = sessionDbPath;
+    const sweepTimer = setTimeout(() => {
+      maybeSweepExpiredZcodeSessions(sweepDbPath, { keepSessionIds: this.appserverRuntime?.activeSessions });
+    }, ZCODE_SESSION_SWEEP_DEFER_MS);
+    if (typeof sweepTimer.unref === "function") sweepTimer.unref();
     return rt;
   }
   /**
@@ -2081,10 +2299,10 @@ var ZcodeEngine = class {
    * 先到时 onClose 收割先行，dispose 收割幂等 no-op（零回归）。
    */
   async shutdownRuntimeAndDisposeChannel(rt) {
-    const harvested = new Promise((resolve) => {
+    const harvested = new Promise((resolve2) => {
       const off = rt.conn.onClose(() => {
         off();
-        resolve();
+        resolve2();
       });
     });
     await rt.conn.shutdown({ graceMs: ZCODE_KILL_GRACE_MS });
@@ -2111,17 +2329,6 @@ var ZcodeEngine = class {
     }
     await this.shutdownRuntimeAndDisposeChannel(rt);
   }
-  /**
-   * [u7a D5] 引擎在途只读快照：activeSessions 非空才算在途——poolKey 'shared' 的
-   * app-server **空闲常驻进程恒活，禁止按进程存在判定**（进程在 ≠ 在途，否则推迟
-   * 判定恒真、30min 上限从兜底变常态路径，设计 §3.3 D5 显式排除）。计数权威 =
-   * activeSessions（attempt 入 create 应答后 add / finally settle 后 delete，与
-   * dispose 的 close 帧目标集同一状态源，无双记账）。运行时未初始化（从未 run /
-   * 已 dispose）→ 恒 0。
-   */
-  inFlightSnapshot() {
-    return { inFlight: this.appserverRuntime?.activeSessions.size ?? 0 };
-  }
   /** 终态合成（extension-conventions 函数 80 行上限，从 run 提取）：aborted / run-failed / parsed 三分支。 */
   finalizeOutcome(task, ctx, final, usageAcc, startedAt) {
     const outcome = {
@@ -2210,8 +2417,12 @@ var ZcodeEngine = class {
    * sessionId 缺失（解析失败的 run 无法定位 session）跳过①级；②级依赖
    * handle.journalPath（宿主 run 后回填）。dbPath：新 handle 恒为隔离库绝对路径
    * （zcodeSessionDbPath(engineDataDir)，tier1 白名单集合见方法体——宿主路径仅
-   * 「共享 HOME 时代」存量兼容）；旧 records（池时代）的相对路径仍按 poolKey
-   * 锚定解析（read 兼容旧数据，池目录不存在时自然落②级 journal 降级）。
+   * 「共享 HOME 时代」存量兼容）；旧 records（池时代）的相对路径仍按池目录锚定
+   * 解析（read 兼容旧数据，池目录不存在时自然落②级 journal 降级）。[池抽象降级
+   * 2026-09-13] 锚定 key 用常量 SHARED_POOL_KEY 承载——协议面 poolKey 已删，池
+   * 时代真实池 key 不再随 handle 传输；若旧 record 的池目录恰为 shared 布局则①级
+   * 仍可达，其余池 key 的旧 record 直接走②级 journal 降级（30 天 TTL 同尺度衰减，
+   * 行为安全）。
    */
   async read(handle) {
     if (handle.data.engineId !== ZCODE_ENGINE_ID) {
@@ -2225,21 +2436,28 @@ var ZcodeEngine = class {
         if (zcodeDbPathAllowlist(this.deps.engineDataDir()).includes(dbPathRaw)) {
           dbPath = dbPathRaw;
         } else {
-          logger3.warn("[zcode-engine] record dbPath \u975E\u767D\u540D\u5355 db \u7EDD\u5BF9\u8DEF\u5F84\uFF0C\u62D2\u7EDD \u2460\u7EA7\u8BFB\u53D6\u964D journal", {
+          logger4.warn("[zcode-engine] record dbPath \u975E\u767D\u540D\u5355 db \u7EDD\u5BF9\u8DEF\u5F84\uFF0C\u62D2\u7EDD \u2460\u7EA7\u8BFB\u53D6\u964D journal", {
             dbPath: dbPathRaw
           });
         }
       } else {
-        dbPath = path4.join(
-          resolvePoolDir(this.deps.engineDataDir(), ZCODE_ENGINE_ID, handle.data.poolKey),
-          dbPathRaw
+        const poolDir = path4.resolve(
+          resolvePoolDir(this.deps.engineDataDir(), ZCODE_ENGINE_ID, SHARED_POOL_KEY)
         );
+        const resolved = path4.resolve(poolDir, dbPathRaw);
+        if (resolved.startsWith(poolDir + path4.sep)) {
+          dbPath = resolved;
+        } else {
+          logger4.warn("[zcode-engine] record dbPath \u76F8\u5BF9\u8DEF\u5F84\u9003\u9038\u6C60\u76EE\u5F55\uFF0C\u62D2\u7EDD \u2460\u7EA7\u8BFB\u53D6\u964D journal", {
+            dbPath: dbPathRaw
+          });
+        }
       }
       if (dbPath !== void 0) {
         try {
           return await readZcodeSessionView(dbPath, sessionId);
         } catch (err) {
-          logger3.warn("[zcode-engine] native session read failed, degrade to journal replay", {
+          logger4.warn("[zcode-engine] native session read failed, degrade to journal replay", {
             dbPath,
             sessionId,
             reason: toErrorMessage(err)
@@ -2265,7 +2483,7 @@ var ZcodeEngine = class {
     const thoughtLevel = task.thinkingLevel?.trim();
     if (thoughtLevel === void 0 || thoughtLevel === "") return;
     if (COMMON_THOUGHT_LEVELS.includes(thoughtLevel)) return;
-    logger3.warn(
+    logger4.warn(
       `[zcode-engine] thinkingLevel=${thoughtLevel} \u5DF2\u900F\u4F20\u4E3A thoughtLevel\uFF08\u975E\u5E38\u89C1\u6863\u4F4D\uFF09\uFF1A\u82E5\u76EE\u6807\u6A21\u578B\u4E0D\u652F\u6301\u8BE5\u6863\u4F4D\u5C06\u88AB\u5FFD\u7565/\u56DE\u843D\u5230\u6A21\u578B\u7F3A\u7701\u63A8\u7406\u6863\u4F4D\uFF08\u5E38\u89C1\u6863\u4F4D\uFF1A${COMMON_THOUGHT_LEVELS.join("/")}\uFF09\uFF1B\u6863\u4F4D\u662F\u5426\u751F\u6548\u4EE5\u6A21\u578B\u5B9E\u9645\u884C\u4E3A\u4E3A\u51C6`,
       { taskId: ctx.taskId }
     );
@@ -2283,11 +2501,40 @@ var ZcodeEngine = class {
     if (ctx.ctxModel === void 0) return;
     const requested = task.model?.trim();
     if (requested !== void 0 && requested !== "") return;
-    logger3.warn(
+    logger4.warn(
       `[zcode-engine] ctx.ctxModel\uFF08${ctx.ctxModel.id}\uFF09\u88AB\u5FFD\u7565\u2014\u2014ctxModel \u662F pi \u94FE\u8DEF\u515C\u5E95\uFF0Czcode \u4E0D\u6D88\u8D39\uFF1Btask.model \u672A\u663E\u5F0F\u6307\u5B9A\uFF0C\u5B9E\u9645\u4F7F\u7528\u5F15\u64CE\u7F3A\u7701\u6A21\u578B ${modelRef}`,
       { taskId: ctx.taskId }
     );
   }
+  /**
+   * [U6 / §3.2.6 要点 3] resume 锚 → 历史前缀（interact-resume 的读半段）。
+   *
+   * 无锚 / 非 zcode 锚形态 → undefined（行为不变）。读通道失败（条目被 TTL 清 /
+   * 会话失效 / 控制面错误）= 宿主侧锚判据通过后、引擎派发前的窄竞态窗——降级为
+   * **无历史前缀的新会话**（warn 留痕；宿主 reopen 摘要承担主降级面），不炸轮：
+   * 续聊消息本身仍可送达（模型缺历史上下文，比整轮失败可用性高，与 reopen 降级
+   * 的「带摘要重开」语义同族）。
+   */
+  async buildResumeHistoryPrefix(ctx) {
+    const anchor = zcodeResumeAnchorOf(ctx, this.deps.engineDataDir());
+    if (anchor === void 0) return void 0;
+    const rt = this.ensureAppServerRuntime();
+    let history;
+    let tokens;
+    try {
+      const result = await rt.channel.resumeSession(anchor.sessionId);
+      history = extractResumeHistory(result);
+      tokens = extractResumeTotalTokens(result);
+    } catch (err) {
+      logger4.warn(
+        `[zcode-engine] session/resume \u8BFB\u5386\u53F2\u5931\u8D25\uFF08\u951A ${anchor.sessionId}\uFF09\u2014\u2014\u964D\u7EA7\u4E3A\u65E0\u5386\u53F2\u524D\u7F00\u7684\u65B0\u4F1A\u8BDD: ${errMessage3(err)}`,
+        { taskId: ctx.taskId }
+      );
+      return void 0;
+    }
+    if (history.length === 0) return void 0;
+    return buildResumeInjectionSegment(history, anchor.sessionId, tokens);
+  }
   /**
    * persona 拼接后的完整 prompt（personaInjection: 'prompt'——zcode 无 flag 通道）：
    * appendSystemPrompt 段在前（人设/约束语境——D6 合流后 persona≡skillPath+
@@ -2301,6 +2548,38 @@ var ZcodeEngine = class {
     return segments.join("\n\n");
   }
 };
+function zcodeResumeAnchorOf(ctx, engineDataDir) {
+  const ref = ctx.resume?.resume?.sessionRef;
+  if (ref === void 0) return void 0;
+  const sessionId = ref["sessionId"];
+  const dbPath = ref["dbPath"];
+  if (typeof sessionId !== "string" || sessionId === "") return void 0;
+  if (typeof dbPath !== "string" || dbPath === "") return void 0;
+  if (!zcodeDbPathAllowlist(engineDataDir).includes(dbPath)) return void 0;
+  return { sessionId, dbPath };
+}
+function buildResumeInjectionSegment(history, priorSessionId, totalTokens, tokenBudget = ZCODE_RESUME_HISTORY_TOKEN_BUDGET) {
+  const budgetTokens = tokenBudget;
+  const charBudget = budgetTokens * ZCODE_RESUME_CHARS_PER_TOKEN;
+  const lines = history.map((t) => `${t.role}: ${t.text}`);
+  let kept = lines;
+  let omitted = 0;
+  while (kept.length > 1 && kept.reduce((n, l) => n + l.length + 1, 0) > charBudget) {
+    kept = kept.slice(1);
+    omitted++;
+  }
+  const omissionNote = omitted > 0 ? `[... ${omitted} older turn(s) omitted to fit the ${tokenBudget}-token history budget ...]
+` : "";
+  const usageNote = totalTokens !== void 0 ? `
+(prior session retained ~${totalTokens} tokens of history)` : "";
+  return `[Continued conversation] You are continuing an existing subagent conversation on a NEW session (prior session id: ${priorSessionId}). The new session has no memory of its own \u2014 the full prior conversation history recovered from the session store follows. Continue seamlessly from it; the user message after this block is the next turn of the SAME conversation.
+
+<conversation_history>
+${omissionNote}${kept.join("\n")}
+</conversation_history>${usageNote}
+
+`;
+}
 var ZCODE_TURN_RETRY_MIN_BUDGET_MS = 3e5;
 function resolveTransientRetryBudget(totalBudgetMs, consumedMs) {
   if (totalBudgetMs === void 0) return { state: "unbounded" };
@@ -2318,8 +2597,8 @@ function errMessage3(err) {
   return toErrorMessage(err);
 }
 function delayResolved(ms, value) {
-  return new Promise((resolve) => {
-    const t = setTimeout(() => resolve(value), ms);
+  return new Promise((resolve2) => {
+    const t = setTimeout(() => resolve2(value), ms);
     if (typeof t.unref === "function") t.unref();
   });
 }
@@ -2474,7 +2753,7 @@ function isHostTimeoutAbort(ctx) {
 var PROBE_STDOUT_CAP_CHARS = 4096;
 async function defaultProbeVersion(cliPath, dataDir) {
   try {
-    return await new Promise((resolve, reject) => {
+    return await new Promise((resolve2, reject) => {
       const child = spawnEngineChild2({
         command: "node",
         args: [cliPath, "--version"],
@@ -2491,11 +2770,11 @@ async function defaultProbeVersion(cliPath, dataDir) {
       child.once("error", reject);
       child.once("close", (code) => {
         if (code !== 0) reject(new Error(`zcode --version exited with code ${code}`));
-        else resolve(out.trim().split("\n")[0]?.trim() || void 0);
+        else resolve2(out.trim().split("\n")[0]?.trim() || void 0);
       });
     });
   } catch (err) {
-    logger3.debug(
+    logger4.debug(
       `[zcode-engine] probe version check failed (best-effort continue): ${toErrorMessage(err)}`
     );
     return void 0;
@@ -2643,18 +2922,17 @@ var EngineProtocolServer = class {
     } } : void 0;
     const runCtx = {
       taskId: runId,
-      poolKey: ctx.poolKey,
       signal: controller.signal,
       onEvent: (event) => this.emitEvent(runId, event),
       ...ctxModel !== void 0 ? { ctxModel } : {},
       ...stream !== void 0 ? { stream } : {},
       ...ctx.schemaEnv !== void 0 ? { schemaEnv: ctx.schemaEnv } : {},
       ...ctx.engineFallback !== void 0 ? { engineFallback: ctx.engineFallback } : {},
-      onPoolResolved: (poolKey) => {
-        void this.reverseRequestInternal("host/poolResolved", { runId, poolKey });
-      },
+      // [U6 / §3.2.6 要点 3] resume 锚点透传（宿主 → 引擎的续聊通道：zcode 锚
+      // sessionRef {sessionId, dbPath}，引擎侧 resume 读 + 新 session 注入消费）。
+      ...params.resume !== void 0 ? { resume: params.resume } : {},
       onHandleReady: (partial) => {
-        void this.reverseRequestInternal("host/handleReady", { runId, sessionRef: partial.sessionRef, poolKey: partial.poolKey });
+        void this.reverseRequestInternal("host/handleReady", { runId, sessionRef: partial.sessionRef });
       }
     };
     try {
@@ -2700,14 +2978,14 @@ var EngineProtocolServer = class {
   }
   reverseRequestInternal(method, params) {
     const id = `rev-${++this.revSeq}`;
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const timer = setTimeout(() => {
         this.reversePending.delete(id);
         this.reverseClock?.settled(id);
         reject(new Error(`reverse request ${method} (${id}) timed out after ${this.reverseTimeoutMs}ms`));
       }, this.reverseTimeoutMs);
       if (typeof timer.unref === "function") timer.unref();
-      this.reversePending.set(id, { resolve, reject, timer });
+      this.reversePending.set(id, { resolve: resolve2, reject, timer });
       this.reverseClock?.started(id);
       this.write({ id, method, params });
     });