@zhushanwen/zcode-subagent-cli 0.2.0 → 0.3.0

package/dist/{chunk-36VY2TNC.js → chunk-DMHXNYG2.js}

@@ -22,12 +22,17 @@ 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;
 var ZCODE_APPSERVER_ERR_BUSY_SESSION = -32010;
 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";
@@ -275,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,
@@ -286,6 +291,7 @@ import {
   synthesizeTimeoutOutcome,
   engineTimeoutDetail,
   resolvePoolDir,
+  SHARED_POOL_KEY,
   spawnEngineChild as spawnEngineChild2
 } from "@zhushanwen/subagent-engine-sdk";
 
@@ -776,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`));
@@ -784,7 +790,7 @@ var AppServerConnection = class {
       this.pending.set(id, {
         // 泛型 T 是调用方对线上 unknown 结果的视图声明，连接层不做运行时校验
         // （协议层保持透明，结构校验归会话层/消费方）。
-        resolve,
+        resolve: resolve2,
         reject,
         timer,
         method
@@ -1135,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;
@@ -1295,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 失败只泄漏一个驻留会话，
@@ -1371,7 +1428,13 @@ var SessionChannel = class {
     });
     const turn = {
       sessionId,
-      callbacks: { onTextDelta: opts.onTextDelta, onThinkingDelta: opts.onThinkingDelta },
+      callbacks: {
+        onTextDelta: opts.onTextDelta,
+        onThinkingDelta: opts.onThinkingDelta,
+        // [PR3] tool 执行期活性回调（SessionTurnCallbacks.onActivity 注释——宿主侧
+        // 无进展守护的工具执行期刷新面）
+        onActivity: opts.onActivity
+      },
       settled: false,
       deltas: [],
       finalText: void 0,
@@ -1487,7 +1550,9 @@ var SessionChannel = class {
     if (payload === void 0) return;
     this.refreshIdle(turn);
     if (this.applyFinalFrame(turn, payload)) return;
-    this.applyStreamDelta(turn, payload);
+    if (!this.applyStreamDelta(turn, payload) && !turn.settled) {
+      turn.callbacks.onActivity?.();
+    }
   }
   /**
    * 收尾帧判定与吸收（A.2 ⑤ 两种形态：payload.response / stopReason+content 变体）。
@@ -1511,9 +1576,12 @@ var SessionChannel = class {
   /** 增量 delta 分发：非空 delta 入账 + 回调；终态后迟到丢弃（不变量 2）。
    *  kind 区分两通道（F2）：reasoning_delta 只走 thinking 回调（不入 deltas 账本
    *  ——deltas 是 response 兜底聚合，推理文本不是答案正文）；text_delta / kind
-   *  缺席走 text 路径。 */
+   *  缺席走 text 路径。
+   *  返回值（[PR3]）：帧被 delta 路径消费（thinking 或 text，回调若注册则已触发）
+   *  → true；无 delta / 空 delta / 终态后迟到丢弃 → false（handleSessionEvent 据
+   *  此分流 onActivity——delta 帧已是宿主可见进展，不双发活性信号）。 */
   applyStreamDelta(turn, payload) {
-    if (typeof payload.delta !== "string" || payload.delta === "") return;
+    if (typeof payload.delta !== "string" || payload.delta === "") return false;
     if (turn.settled) {
       logger2.warn(
         `\u7EC8\u6001\u540E\u8FDF\u5230\u7684 delta \u4E22\u5F03\uFF08\u4F1A\u8BDD ${turn.sessionId}\uFF0C\u4E0D\u53D8\u91CF 2\uFF1Aresolve \u540E\u4E0D\u518D\u53D1\u4E8B\u4EF6\uFF09: ${payload.delta.slice(
@@ -1521,14 +1589,15 @@ var SessionChannel = class {
           DELTA_LOG_CHARS
         )}`
       );
-      return;
+      return false;
     }
     if (payload.kind === "reasoning_delta") {
       turn.callbacks.onThinkingDelta?.(payload.delta);
-      return;
+      return true;
     }
     turn.deltas.push(payload.delta);
     turn.callbacks.onTextDelta?.(payload.delta);
+    return true;
   }
   handleTelemetry(params) {
     if (!isRecord3(params)) return;
@@ -1548,13 +1617,38 @@ var SessionChannel = class {
     turn.lastTerminalStatus = status;
     this.recordTerminalError(turn, params);
     if (turn.settled) {
-      logger2.warn(
-        `\u6743\u5A01\u7EC8\u6001\u665A\u4E8E\u843D\u5B9A\u7ED3\u679C\u5230\u8FBE\uFF08\u4F1A\u8BDD ${turn.sessionId}\uFF0C\u5DF2\u843D\u5B9A source=${turn.terminal?.source}\uFF09\uFF1Aturn.terminal status="${status}" \u4EC5\u8BB0\u5F55\u4E0D\u6539\u5199\uFF08P0-1 D5\u2460\uFF09`
-      );
+      this.logLateTerminal(turn, status);
       return;
     }
     turn.settle({ status, source: "turn.terminal" });
   }
+  /**
+   * 已落定 turn 的迟到权威终态分级日志（P-Z2 后续：常态迟到降噪）。真机实证该
+   * 形态的唯一可达路径是 success 终态常态迟到（final-frame 先落定 + 权威
+   * turn.terminal 迟到）——即每个成功任务必经；原无条件 warn 经 SDK cli-entry
+   * 的 stderr 兜底 → runtime [rpc:stderr] 全量 console.error 链路，每个成功任务
+   * 产一条零异常区分度的 ERROR 级日志。按权威 status 分级（落定语义不动——
+   * lastTerminalStatus/lastTerminalError 的入账在上游无条件路径完成）：
+   *   - "success"：常态迟到，零日志；
+   *   - "interrupted"：用户中断形态，debug（stderr 兜底对 debug no-op——对齐
+   *     SDK logger CONSOLE_SINK 语义，host/log 反向请求侧仍可观测）；
+   *   - 失败类（isFailedTerminalStatus，与引擎失败分流同口径）与 unknown/未识别
+   *     status：保守 warn（原样 status 已写入文案）——假成功识破的防御面，理论
+   *     不可达但保留，宁可误报不静默。
+   */
+  logLateTerminal(turn, status) {
+    if (status === "success") return;
+    const message = `\u6743\u5A01\u7EC8\u6001\u665A\u4E8E\u843D\u5B9A\u7ED3\u679C\u5230\u8FBE\uFF08\u4F1A\u8BDD ${turn.sessionId}\uFF0C\u5DF2\u843D\u5B9A source=${turn.terminal?.source}\uFF09\uFF1Aturn.terminal status="${status}" \u4EC5\u8BB0\u5F55\u4E0D\u6539\u5199\uFF08P0-1 D5\u2460\uFF09`;
+    if (isFailedTerminalStatus(status)) {
+      logger2.warn(message);
+      return;
+    }
+    if (status === "interrupted") {
+      logger2.debug(message);
+      return;
+    }
+    logger2.warn(message);
+  }
   /** terminal 帧专属错误信息入账（⛔P-Z2 实证：真实 failed 终态的 errorCode/errorMessage
    *  只在 terminal 帧携带，read/delta 拿不到——先到/迟到都记录，消费层合成失败
    *  文案时优先采信）。二者均缺失时不挂 lastTerminalError 字段。 */
@@ -1604,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 {
@@ -1632,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）
@@ -1677,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,
@@ -1715,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();
@@ -1726,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);
@@ -1737,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,
@@ -1771,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, {
@@ -1811,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
       }
@@ -1831,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）；
@@ -1840,13 +2093,17 @@ var ZcodeEngine = class {
       // 不变量 3a 的拼接比对不含 reasoning）
       onTextDelta: (delta) => ctx.onEvent?.({ type: "text_delta", delta }),
       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 域接线）。
+      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→默认）
@@ -1894,14 +2151,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();
       }
     });
   }
@@ -1935,7 +2192,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 });
@@ -1960,19 +2217,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`
       );
     }
@@ -2001,7 +2258,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,
@@ -2019,6 +2276,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;
   }
   /**
@@ -2036,10 +2298,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 });
@@ -2066,17 +2328,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 = {
@@ -2145,17 +2396,6 @@ var ZcodeEngine = class {
     }
     for (const ev of synthesizeCoarseEvents(payload.response, payload.usage)) emit(ev);
   }
-  /**
-   * D1 可选面：zcode 首期不支持 conversation（capabilities 声明）——同步拒绝、
-   * 不创建进程，文案给可操作建议（A11）。
-   */
-  async interact(_handle, _action) {
-    return {
-      ok: false,
-      code: "engine_capability_unsupported",
-      message: "zcode \u5F15\u64CE\u4E0D\u652F\u6301 conversation \u4EA4\u4E92\u63A7\u5236\u9762\uFF08capabilities.conversation = 'unsupported'\uFF0C\u6BCF\u4EFB\u52A1\u81EA\u5305\u542B\u4F1A\u8BDD\uFF0C\u65E0\u540C\u8FDB\u7A0B idle \u590D\u7528\uFF09\u3002\u6062\u590D\u6307\u5F15\uFF1A\u6539\u7528\u5355\u6B21 subagent \u8C03\u7528\u91CD\u65B0\u6D3E\u53D1\u4EFB\u52A1\uFF0C\u6216\u4F7F\u7528 engine: 'pi'\uFF08chatMode idle \u590D\u7528\uFF0C\u652F\u6301 message/close/cancel\uFF09\u3002"
-    };
-  }
   /** [U7] 模型可发现性：v2 桌面登录态聚合（带凭据 provider × models），失败安全返回清单本身可能为空。 */
   listModels() {
     return listZcodeModels(this.deps.sources);
@@ -2176,8 +2416,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) {
@@ -2191,21 +2435,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)
@@ -2231,7 +2482,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 }
     );
@@ -2249,11 +2500,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+
@@ -2267,6 +2547,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" };
@@ -2284,8 +2596,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();
   });
 }
@@ -2355,9 +2667,6 @@ function authoritativeTerminalStatus(r) {
   if (r.lastTerminalStatus !== void 0) return r.lastTerminalStatus;
   return r.terminal.source === "turn.terminal" ? r.terminal.status : void 0;
 }
-function isFailedTerminalStatus(status) {
-  return status === "failed" || status === "error";
-}
 function parsedAppServerAttempt(task, r) {
   if (isFailedTerminalStatus(authoritativeTerminalStatus(r))) {
     return failedTerminalAppServerAttempt(r);
@@ -2443,7 +2752,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"],
@@ -2460,11 +2769,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;
@@ -2542,7 +2851,7 @@ var EngineProtocolServer = class {
       }
     }
   }
-  /** 10 正向方法分发（表驱动：method → 处理器；未知方法 → engine_protocol_unknown_method）。 */
+  /** 9 正向方法分发（表驱动：method → 处理器；未知方法 → engine_protocol_unknown_method）。 */
   async dispatch(id, method, params) {
     const handler = this.methodHandlers[method];
     if (handler === void 0) {
@@ -2555,7 +2864,7 @@ var EngineProtocolServer = class {
     return handler(params);
   }
   /**
-   * 10 正向方法 → 处理器映射（每个处理器消费原始 params 并自行收敛类型——
+   * 9 正向方法 → 处理器映射（每个处理器消费原始 params 并自行收敛类型——
    * 与原 switch case 表达式一一对应）。
    */
   methodHandlers = {
@@ -2563,7 +2872,6 @@ var EngineProtocolServer = class {
     probe: (p) => this.engine.probe(probeParamsOf(p)),
     run: (p) => this.run(p),
     cancel: (p) => this.cancel(p),
-    interact: (p) => this.interact(p),
     read: (p) => this.read(p),
     listModels: () => ({ models: this.engine.listModels?.() ?? null }),
     validateModel: (p) => this.validateModel(p),
@@ -2613,18 +2921,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 {
@@ -2639,9 +2946,6 @@ var EngineProtocolServer = class {
     if (active !== void 0) active.controller.abort(new Error(`cancelled by host: ${params.reason}`));
     return { ok: true };
   }
-  async interact(params) {
-    return this.engine.interact({ data: params.handle }, params.action);
-  }
   read(params) {
     return this.engine.read({ data: params.handle });
   }
@@ -2673,14 +2977,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 });
     });