@zhushanwen/pi-subagent-cli 0.1.1

package/dist/index.cjs

@@ -0,0 +1,2538 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ChatSessionRegistry: () => ChatSessionRegistry,
+  DETERMINISTIC_SCHEMA_FAILURE_PREFIX: () => DETERMINISTIC_SCHEMA_FAILURE_PREFIX,
+  EPIPE_FAILURE_THRESHOLD: () => EPIPE_FAILURE_THRESHOLD,
+  EngineProtocolServer: () => EngineProtocolServer,
+  PI_ADAPTER_VERSION: () => PI_ADAPTER_VERSION,
+  PI_ENGINE_ID: () => PI_ENGINE_ID,
+  PI_POOL_KEY: () => PI_POOL_KEY,
+  PiEngine: () => PiEngine,
+  STALE_CONTEXT_PATTERNS: () => STALE_CONTEXT_PATTERNS,
+  WRAP_UP_HINT: () => WRAP_UP_HINT,
+  applySchemaEnvToChildEnv: () => applySchemaEnvToChildEnv,
+  buildEnvBlock: () => buildEnvBlock,
+  buildSpawnArgs: () => buildSpawnArgs,
+  classifyFailureKind: () => classifyFailureKind,
+  clearEpipeFailure: () => clearEpipeFailure,
+  collectOutcome: () => collectOutcome,
+  createDefaultPiEngine: () => createDefaultPiEngine,
+  createTurnLimiter: () => createTurnLimiter,
+  createUiRequestQueue: () => createUiRequestQueue,
+  deriveSessionFilePath: () => deriveSessionFilePath,
+  describeMissingParsedOutput: () => describeMissingParsedOutput,
+  extractParsedOutput: () => extractParsedOutput,
+  findSessionFileByHeaderId: () => findSessionFileByHeaderId,
+  getActiveChild: () => getActiveChild,
+  getPiInvocation: () => getPiInvocation,
+  isDeterministicSchemaFailureMsg: () => isDeterministicSchemaFailureMsg,
+  isStaleContextErrorMsg: () => isStaleContextErrorMsg,
+  killAllActiveChildren: () => killAllActiveChildren,
+  mapAssistantMessageDelta: () => mapAssistantMessageDelta,
+  mirrorMainProcessFlags: () => mirrorMainProcessFlags,
+  neutralizeStalePatterns: () => neutralizeStalePatterns,
+  parseChannel: () => import_subagent_engine_sdk9.parseChannel,
+  parseSpawnLine: () => parseSpawnLine,
+  parseSpawnModelRef: () => parseSpawnModelRef,
+  performGetStateHandshake: () => performGetStateHandshake,
+  recordEpipeFailure: () => recordEpipeFailure,
+  replayJournalToSessionView: () => replayJournalToSessionView,
+  requestGetStateOnce: () => requestGetStateOnce,
+  resetAllEpipeFailures: () => resetAllEpipeFailures,
+  respond: () => respond,
+  runSpawnOnce: () => runSpawnOnce,
+  sendGetStateCommand: () => sendGetStateCommand,
+  sendPromptCommand: () => sendPromptCommand
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/server.ts
+var import_subagent_engine_sdk20 = require("@zhushanwen/subagent-engine-sdk");
+
+// src/constants.ts
+var PI_ENGINE_ID = "pi";
+var PI_ADAPTER_VERSION = "1.0.0";
+var PI_POOL_KEY = "shared";
+var SCHEMA_ENV_VAR = "PI_WORKFLOW_SCHEMA";
+var SCHEMA_ENV_MAX_KIB = 256;
+var BYTES_PER_KIB = 1024;
+var SCHEMA_ENV_MAX_BYTES = SCHEMA_ENV_MAX_KIB * BYTES_PER_KIB;
+var PI_KILL_GRACE_MS = 3e4;
+
+// src/pi-engine.ts
+var import_node_child_process2 = require("child_process");
+var import_subagent_engine_sdk17 = require("@zhushanwen/subagent-engine-sdk");
+var fs5 = __toESM(require("fs"), 1);
+var path4 = __toESM(require("path"), 1);
+var import_subagent_engine_sdk18 = require("@zhushanwen/subagent-engine-sdk");
+
+// src/error-message.ts
+var import_subagent_engine_sdk = require("@zhushanwen/subagent-engine-sdk");
+
+// src/pi-invocation.ts
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+
+// src/relay-env.ts
+var import_subagent_engine_sdk2 = require("@zhushanwen/subagent-engine-sdk");
+
+// src/pi-invocation.ts
+var BUN_VIRTUAL_PREFIX = "/$bunfs/root/";
+var SELF_CLI_BIN_BASENAME = "pi-subagent-cli.mjs";
+function isGenericRuntime(execPath) {
+  const execName = path.basename(execPath).toLowerCase();
+  return /^(node|bun)(\.exe)?$/.test(execName);
+}
+var scriptExistsCache;
+function currentScriptExists() {
+  const currentScript = process.argv[1];
+  if (scriptExistsCache === void 0 || scriptExistsCache.script !== currentScript) {
+    scriptExistsCache = {
+      script: currentScript,
+      exists: currentScript !== void 0 && !currentScript.startsWith(BUN_VIRTUAL_PREFIX) && fs.existsSync(currentScript)
+    };
+  }
+  return scriptExistsCache.exists;
+}
+function getPiInvocation(userArgs, opts) {
+  const currentScript = process.argv[1];
+  const isBunVirtualScript = currentScript?.startsWith(BUN_VIRTUAL_PREFIX);
+  const isSelfCliBin = currentScript !== void 0 && path.basename(currentScript) === SELF_CLI_BIN_BASENAME;
+  if (opts?.relay !== false && (0, import_subagent_engine_sdk2.isRelayActive)(process.env)) {
+    const relayNode = process.env[import_subagent_engine_sdk2.RELAY_ENV_NODE];
+    const relayScript = process.env[import_subagent_engine_sdk2.RELAY_ENV_SCRIPT];
+    if (relayNode !== void 0 && relayScript !== void 0) {
+      return { command: relayNode, args: [relayScript, ...userArgs] };
+    }
+  }
+  if (currentScript && !isBunVirtualScript && !isSelfCliBin && currentScriptExists()) {
+    return { command: process.execPath, args: [currentScript, ...userArgs] };
+  }
+  if (!isGenericRuntime(process.execPath)) {
+    return { command: process.execPath, args: userArgs };
+  }
+  return { command: "pi", args: userArgs };
+}
+
+// src/stdin-writer.ts
+var crypto = __toESM(require("crypto"), 1);
+var import_subagent_engine_sdk3 = require("@zhushanwen/subagent-engine-sdk");
+var logger = (0, import_subagent_engine_sdk3.getLogger)("subagents");
+var epipeConsecutiveFailures = /* @__PURE__ */ new Map();
+var EPIPE_FAILURE_THRESHOLD = 2;
+function recordEpipeFailure(recordId) {
+  const count = (epipeConsecutiveFailures.get(recordId) ?? 0) + 1;
+  epipeConsecutiveFailures.set(recordId, count);
+  return count;
+}
+function clearEpipeFailure(recordId) {
+  epipeConsecutiveFailures.delete(recordId);
+}
+function resetAllEpipeFailures() {
+  epipeConsecutiveFailures.clear();
+}
+function respond(child, id, out, signal) {
+  if (signal?.aborted) return;
+  let line;
+  try {
+    if ("value" in out) line = JSON.stringify({ type: "extension_ui_response", id, value: out.value });
+    else if ("confirmed" in out) line = JSON.stringify({ type: "extension_ui_response", id, confirmed: out.confirmed });
+    else if ("cancelled" in out) line = JSON.stringify({ type: "extension_ui_response", id, cancelled: true });
+  } catch (err) {
+    logger.warn(`[subagents] JSON.stringify failed for ui response ${id}, degrading to cancelled`, {
+      detail: (0, import_subagent_engine_sdk.toErrorMessage)(err)
+    });
+    line = JSON.stringify({ type: "extension_ui_response", id, cancelled: true });
+  }
+  if (line === void 0) return;
+  writeStdinLine(child, line, `ui response for request ${id}`);
+}
+function sendPromptCommand(child, task, options) {
+  if (!child.stdin || child.stdin.destroyed) return;
+  const payload = {
+    id: crypto.randomUUID(),
+    type: "prompt",
+    message: task
+  };
+  if (options?.streamingBehavior) {
+    payload.streamingBehavior = options.streamingBehavior;
+  }
+  writeStdinLine(child, JSON.stringify(payload), "prompt command");
+}
+function sendGetStateCommand(child) {
+  const id = crypto.randomUUID();
+  const command = JSON.stringify({
+    id,
+    type: "get_state"
+  });
+  writeStdinLine(child, command, "get_state command");
+  return id;
+}
+function writeStdinLine(child, line, warnTag) {
+  if (!child.stdin || child.stdin.destroyed) return;
+  try {
+    const ok = child.stdin.write(line + "\n");
+    if (!ok) logger.warn(`[subagents] stdin backpressure on ${warnTag}`);
+  } catch (err) {
+    if (err !== null && typeof err === "object" && "code" in err && (err.code === "EPIPE" || err.code === "ERR_STREAM_DESTROYED")) {
+      throw new Error(
+        `[subagents] EPIPE on stdin write (${warnTag}): pipe broken, child process likely exited. Recovery: treat as dead process and resume via cold path.`
+      );
+    }
+    logger.warn(`[subagents] unexpected stdin write error on ${warnTag}`, {
+      detail: (0, import_subagent_engine_sdk.toErrorMessage)(err)
+    });
+  }
+}
+
+// src/spawn-runner.ts
+var fs4 = __toESM(require("fs"), 1);
+var import_node_path = require("path");
+var import_subagent_engine_sdk13 = require("@zhushanwen/subagent-engine-sdk");
+
+// src/argv-mirror.ts
+var VALUED_FLAGS = /* @__PURE__ */ new Set([
+  "--extension",
+  "-e",
+  "--skill",
+  "--model",
+  "--system-prompt",
+  "--append-system-prompt",
+  "--tools",
+  "-t",
+  "--exclude-tools",
+  "-xt",
+  "--fork",
+  "--session-dir",
+  "--mode",
+  "--thinking",
+  "--models"
+]);
+var BOOLEAN_FLAGS = /* @__PURE__ */ new Map([
+  ["--no-extensions", "noExtensions"],
+  ["-ne", "noExtensions"],
+  ["--approve", "approve"],
+  ["-a", "approve"],
+  ["--no-context-files", "noContextFiles"],
+  ["-nc", "noContextFiles"]
+]);
+var ARGV_FLAG_START = 2;
+var memoArgv;
+var memoResult;
+function mirrorMainProcessFlags(argv) {
+  if (memoResult !== void 0 && memoArgv === argv) return memoResult;
+  const result = parseMirrorFlagArgs(
+    argv.length > ARGV_FLAG_START ? argv.slice(ARGV_FLAG_START) : []
+  );
+  memoArgv = argv;
+  memoResult = result;
+  return result;
+}
+function parseMirrorFlagArgs(flagArgs) {
+  const flags = {
+    noExtensions: false,
+    approve: false,
+    noContextFiles: false
+  };
+  const extensionPaths = [];
+  for (let i = 0; i < flagArgs.length; i++) {
+    const tok = flagArgs[i];
+    const booleanKey = BOOLEAN_FLAGS.get(tok);
+    if (booleanKey !== void 0) {
+      flags[booleanKey] = true;
+      continue;
+    }
+    const eqMatch = /^(--extension|-e)=(.*)$/.exec(tok);
+    if (eqMatch) {
+      const val = eqMatch[2];
+      if (val) extensionPaths.push(val);
+      continue;
+    }
+    if (tok === "--extension" || tok === "-e") {
+      const next = flagArgs[i + 1];
+      if (next !== void 0 && !next.startsWith("--") && next.length > 0) {
+        extensionPaths.push(next);
+        i++;
+      }
+      continue;
+    }
+    if (VALUED_FLAGS.has(tok)) {
+      i++;
+      continue;
+    }
+  }
+  return {
+    noExtensions: flags.noExtensions,
+    approve: flags.approve,
+    extensionPaths,
+    noContextFiles: flags.noContextFiles
+  };
+}
+
+// src/active-children.ts
+var import_subagent_engine_sdk4 = require("@zhushanwen/subagent-engine-sdk");
+var activeChildren = /* @__PURE__ */ new Map();
+function registerActiveChild(recordId, child) {
+  activeChildren.set(recordId, child);
+}
+function unregisterActiveChild(recordId, child) {
+  if (activeChildren.get(recordId) === child) activeChildren.delete(recordId);
+}
+function getActiveChild(recordId) {
+  return activeChildren.get(recordId);
+}
+function killAllActiveChildren(signal = "SIGTERM") {
+  let killed = 0;
+  for (const [recordId, child] of activeChildren) {
+    if (child.exitCode === null && child.signalCode === null) {
+      killed++;
+      child.kill(signal);
+      void (0, import_subagent_engine_sdk4.killChain)(child, {
+        graceMs: PI_KILL_GRACE_MS,
+        unrefTimers: true,
+        escalationNote: `child ${recordId} (source: dispose killAll)`
+      });
+    }
+    activeChildren.delete(recordId);
+  }
+  return killed;
+}
+
+// src/output-collector.ts
+var STALE_CONTEXT_PATTERNS = [
+  "ctx is stale",
+  "stale after session replacement",
+  "context canceled",
+  "aborted"
+];
+function isStaleContextErrorMsg(msg) {
+  if (!msg) return false;
+  const lower = msg.toLowerCase();
+  return STALE_CONTEXT_PATTERNS.some((p) => lower.includes(p));
+}
+var DETERMINISTIC_SCHEMA_FAILURE_PREFIX = "Structured output failed deterministically:";
+function isDeterministicSchemaFailureMsg(msg) {
+  if (!msg) return false;
+  return msg.includes(DETERMINISTIC_SCHEMA_FAILURE_PREFIX);
+}
+function classifyFailureKind(msg) {
+  if (msg === void 0) return void 0;
+  if (isStaleContextErrorMsg(msg)) return "stale_context";
+  if (isDeterministicSchemaFailureMsg(msg)) return "schema_deterministic";
+  return "unknown";
+}
+var STRUCTURED_OUTPUT_TOOL = "structured-output";
+var FAILED_SO_SUMMARY_MAX_CHARS = 300;
+function extractParsedOutput(toolCalls) {
+  for (let i = toolCalls.length - 1; i >= 0; i--) {
+    const tc = toolCalls[i];
+    if (tc.toolName === STRUCTURED_OUTPUT_TOOL && tc.isError !== true && tc.result?.details !== void 0) {
+      return tc.result.details;
+    }
+  }
+  return void 0;
+}
+function neutralizeStalePatterns(text) {
+  let out = text;
+  for (const pattern of STALE_CONTEXT_PATTERNS) {
+    const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    out = out.replace(new RegExp(escaped, "gi"), "[redacted]");
+  }
+  return out;
+}
+function describeMissingParsedOutput(toolCalls) {
+  if (extractParsedOutput(toolCalls) !== void 0) return void 0;
+  const soCalls = toolCalls.filter((tc) => tc.toolName === STRUCTURED_OUTPUT_TOOL);
+  if (soCalls.length === 0) {
+    return `${DETERMINISTIC_SCHEMA_FAILURE_PREFIX} Agent finished without producing a structured output: the structured-output tool was never called. Recovery: verify the structured-output extension is installed and enabled for this agent, and that the agent's final answer conforms to the requested schema.`;
+  }
+  const failed = soCalls.filter((tc) => tc.isError === true);
+  if (failed.length > 0) {
+    const last = failed[failed.length - 1];
+    const lastErrorSummary = neutralizeStalePatterns(summarizeToolContent(last.result?.content));
+    const failureKind = lastErrorSummary.toLowerCase().includes("validation failed") ? "schema validation" : "execution failure";
+    return `${DETERMINISTIC_SCHEMA_FAILURE_PREFIX} Agent finished without a valid structured output: ${failed.length} structured-output call(s) failed (${failureKind}). Last error: ${lastErrorSummary}`;
+  }
+  return "Agent finished without a valid structured output: structured-output was called but none of the successful calls carried result details.";
+}
+function summarizeToolContent(content) {
+  let summary = "(no detail)";
+  if (Array.isArray(content)) {
+    const texts = content.map((item) => item && typeof item === "object" && "text" in item ? String(item.text) : "").filter((t) => t !== "");
+    if (texts.length > 0) summary = texts.join(" ");
+  } else if (typeof content === "string" && content !== "") {
+    summary = content;
+  }
+  return summary.length > FAILED_SO_SUMMARY_MAX_CHARS ? `${summary.slice(0, FAILED_SO_SUMMARY_MAX_CHARS)}...` : summary;
+}
+function getFullText(record) {
+  return record.turns.map((t) => t.text).filter((t) => t !== void 0 && t.length > 0).join("\n\n");
+}
+function getAllToolCalls(record) {
+  const out = [];
+  for (const turn of record.turns) {
+    out.push(...turn.toolCalls);
+  }
+  return out;
+}
+function aggregateUsageDelta(record) {
+  let input = 0;
+  let output = 0;
+  let cacheRead = 0;
+  let cacheWrite = 0;
+  let cost = 0;
+  let hasCost = false;
+  let any = false;
+  for (const turn of record.turns) {
+    const u = turn.usageDelta;
+    if (u === void 0) continue;
+    any = true;
+    input += u.input ?? 0;
+    output += u.output ?? 0;
+    cacheRead += u.cacheRead ?? 0;
+    cacheWrite += u.cacheWrite ?? 0;
+    if (u.cost !== void 0) {
+      cost += u.cost;
+      hasCost = true;
+    }
+  }
+  if (!any) return void 0;
+  return { input, output, cacheRead, cacheWrite, ...hasCost ? { cost } : {} };
+}
+function collectOutcome(record, args) {
+  const toolCalls = getAllToolCalls(record);
+  const parsedOutput = extractParsedOutput(toolCalls);
+  let success = args.success;
+  let error = args.error;
+  if (args.schemaExpected === true && success && parsedOutput === void 0) {
+    success = false;
+    error = describeMissingParsedOutput(toolCalls) ?? error;
+  }
+  if (success && record.lastError !== void 0) {
+    success = false;
+    error = record.lastError;
+  }
+  return {
+    content: getFullText(record),
+    turns: record.turnCount,
+    durationMs: Date.now() - args.startTime,
+    success,
+    error,
+    sessionId: args.sessionId,
+    sessionFile: args.sessionFile,
+    toolCalls,
+    parsedOutput,
+    usage: aggregateUsageDelta(record),
+    // [D5-③] 失败分诊结构化：error 最终确定后一次分类写入
+    failureKind: error !== void 0 ? classifyFailureKind(error) : void 0
+  };
+}
+
+// src/spawn-args.ts
+var import_node_child_process = require("child_process");
+var import_subagent_engine_sdk5 = require("@zhushanwen/subagent-engine-sdk");
+var logger2 = (0, import_subagent_engine_sdk5.getLogger)("session-runner");
+var THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "max"];
+function asThinkingLevel(v) {
+  return typeof v === "string" && THINKING_LEVELS.includes(v) ? v : void 0;
+}
+function parseSpawnModelRef(ref) {
+  if (ref === void 0 || ref.trim() === "") return void 0;
+  const slash = ref.indexOf("/");
+  if (slash <= 0 || slash === ref.length - 1) return void 0;
+  return { provider: ref.slice(0, slash), id: ref.slice(slash + 1) };
+}
+function buildSpawnArgs(params) {
+  const args = ["--mode", "rpc", "--session-dir", params.sessionDir];
+  if (params.sessionFile) {
+    args.push("--session", params.sessionFile);
+  }
+  args.push("--model", `${params.modelRef.provider}/${params.modelRef.id}`);
+  if (params.thinkingLevel) {
+    const lastIdx = args.length - 1;
+    args[lastIdx] = `${args[lastIdx]}:${params.thinkingLevel}`;
+  }
+  if (params.agentTools && params.agentTools.length > 0) {
+    args.push("--tools", params.agentTools.join(","));
+  }
+  if (params.appendSystemPromptPath) {
+    args.push("--append-system-prompt", params.appendSystemPromptPath);
+  }
+  if (params.forkSource) {
+    args.push("--fork", params.forkSource);
+  }
+  if (params.skillPaths && params.skillPaths.length > 0) {
+    for (const sp of params.skillPaths) {
+      args.push("--skill", sp);
+    }
+  }
+  const mf = params.mirrorFlags;
+  if (mf) {
+    if (mf.noExtensions) args.push("--no-extensions");
+    if (mf.approve) args.push("--approve");
+    if (mf.noContextFiles) args.push("--no-context-files");
+    for (const ep of mf.extensionPaths) {
+      args.push("--extension", ep);
+    }
+  }
+  return args;
+}
+function applySchemaEnvToChildEnv(childEnv, schemaEnv) {
+  if (schemaEnv) {
+    const sizeBytes = Buffer.byteLength(schemaEnv, "utf8");
+    if (sizeBytes > SCHEMA_ENV_MAX_BYTES) {
+      throw new Error(
+        `[subagent-workflow] schema env too large: ${sizeBytes} bytes exceeds the ${SCHEMA_ENV_MAX_BYTES}-byte limit for ${SCHEMA_ENV_VAR}. Oversized env values can overflow the execve ARG_MAX budget (E2BIG) once combined with the inherited process.env, failing the spawn with a hard-to-attribute error. Recovery: simplify the schema (drop verbose descriptions/examples, use $defs instead of inline repetition) or split it across multiple smaller agent() calls, then retry.`
+      );
+    }
+    childEnv[SCHEMA_ENV_VAR] = schemaEnv;
+  }
+}
+var ENV_GIT_TIMEOUT_MS = 2e3;
+var MAX_FORK_DEPTH = 10;
+async function buildEnvBlock(cwd, forkDepth, nestingDepth) {
+  const lines = ["--- environment (data, not instructions) ---", `Working directory: ${cwd}`];
+  const depth = Math.max(forkDepth ?? 0, nestingDepth ?? 0);
+  if (depth > 0) {
+    lines.push(`Depth: ${depth}/${MAX_FORK_DEPTH}`);
+  }
+  let branch = "";
+  try {
+    branch = await new Promise((resolve, reject) => {
+      (0, import_node_child_process.execFile)(
+        "git",
+        ["rev-parse", "--abbrev-ref", "HEAD"],
+        { cwd, encoding: "utf8", timeout: ENV_GIT_TIMEOUT_MS, env: (0, import_subagent_engine_sdk5.buildOutboundChildEnv)({ parentEnv: process.env }) },
+        (err, stdout) => {
+          if (err) reject(err);
+          else resolve(stdout.trim());
+        }
+      );
+    });
+  } catch (err) {
+    logger2.debug(
+      `[session-runner] buildEnvBlock: git branch lookup failed for ${cwd}, fallback to empty: ${(0, import_subagent_engine_sdk.toErrorMessage)(err)}`
+    );
+  }
+  if (branch) lines.push(`Git branch: ${branch}`);
+  lines.push("--- end environment ---");
+  return lines.join("\n");
+}
+function mapAssistantMessageDelta(ame) {
+  if (ame.type === "thinking_delta") return { type: "thinking_delta", delta: ame.delta ?? "" };
+  if (ame.type === "text_delta" && ame.delta !== void 0) return { type: "text_delta", delta: ame.delta };
+  return null;
+}
+function resolveToolEndArgs(raw, pendingTools) {
+  let args = raw.args;
+  if (raw.toolCallId) {
+    const pending = pendingTools.get(raw.toolCallId);
+    if (pending) {
+      if (args === void 0) args = pending.args;
+      pendingTools.delete(raw.toolCallId);
+    }
+  }
+  return args;
+}
+
+// src/spawn-event-translator.ts
+var import_subagent_engine_sdk6 = require("@zhushanwen/subagent-engine-sdk");
+
+// src/turn-limiter.ts
+var WRAP_UP_MESSAGE = [
+  "You have reached your turn limit. Wrap up now:",
+  "1. Summarize what you have completed (with evidence: file paths, command output).",
+  "2. List what remains undone and why.",
+  "3. State the single most important next step for whoever continues.",
+  "Do NOT claim the task is complete if any part remains unfinished."
+].join(" ");
+var WRAP_UP_HINT = [
+  `You have a turn limit. As you sense you are approaching it, proactively wrap up:`,
+  "1. Summarize what you have completed (with evidence: file paths, command output).",
+  "2. List what remains undone and why.",
+  "3. State the single most important next step for whoever continues.",
+  "Do NOT claim the task is complete if any part remains unfinished."
+].join(" ");
+function createTurnLimiter(opts) {
+  let steered = false;
+  let aborted = false;
+  const limit = opts.maxTurns > 0 ? opts.maxTurns : Infinity;
+  const grace = opts.graceTurns > 0 ? opts.graceTurns : 0;
+  const onTurnEnd = (turn) => {
+    if (aborted || !Number.isFinite(limit)) return;
+    if (!steered && turn >= limit) {
+      steered = true;
+      opts.steer(WRAP_UP_MESSAGE);
+    }
+    if (steered && turn >= limit + grace) {
+      aborted = true;
+      opts.abort();
+    }
+  };
+  const reset = () => {
+    steered = false;
+    aborted = false;
+  };
+  return {
+    onTurnEnd,
+    reset,
+    get didSteer() {
+      return steered;
+    },
+    get didAbort() {
+      return aborted;
+    }
+  };
+}
+
+// src/spawn-event-translator.ts
+var DEFAULT_GRACE_TURNS = 2;
+function handleToolExecutionStart(raw, pendingTools, agentEvent) {
+  const toolName = raw.toolName ?? "";
+  if (raw.toolCallId) {
+    pendingTools.set(raw.toolCallId, { toolName, args: raw.args });
+  }
+  agentEvent({ type: "tool_start", toolName, args: raw.args });
+}
+function handleToolExecutionEnd(raw, pendingTools, agentEvent) {
+  agentEvent({
+    type: "tool_end",
+    toolName: raw.toolName ?? "",
+    args: resolveToolEndArgs(raw, pendingTools),
+    result: raw.result,
+    isError: raw.isError
+  });
+}
+function handleAssistantMessageUpdate(raw, agentEvent) {
+  const mapped = mapAssistantMessageDelta(raw.assistantMessageEvent ?? {});
+  if (mapped) agentEvent(mapped);
+}
+function handleAgentEnd(raw, opts) {
+  if (raw.willRetry !== true) opts.onAgentEnd?.();
+}
+function handleAgentSettled(record, limiter, opts) {
+  if (opts.onAgentSettled !== void 0) {
+    record.turnCount = 0;
+    limiter.reset();
+    opts.onAgentSettled();
+  }
+}
+function accumulateMessageEnd(raw, agentEvent) {
+  const msg = raw.message;
+  if (msg?.usage) {
+    const { cost: costObj } = msg.usage;
+    const usage = {
+      input: msg.usage.input ?? 0,
+      output: msg.usage.output ?? 0,
+      cacheRead: msg.usage.cacheRead ?? 0,
+      cacheWrite: msg.usage.cacheWrite ?? 0,
+      ...costObj?.total !== void 0 ? { cost: costObj.total } : {}
+    };
+    agentEvent({ type: "message_end", usage });
+  }
+  const stopReason = msg?.stopReason;
+  if (stopReason === "error" || stopReason === "aborted") {
+    const errMsg = msg?.errorMessage ?? raw.reason ?? stopReason;
+    agentEvent({ type: "error", message: errMsg });
+  }
+}
+function createSdkEventTranslator(record, opts) {
+  const pendingTools = /* @__PURE__ */ new Map();
+  const limiter = createTurnLimiter({
+    maxTurns: opts.maxTurns ?? 0,
+    graceTurns: opts.graceTurns ?? DEFAULT_GRACE_TURNS,
+    steer: () => {
+    },
+    abort: opts.abort
+  });
+  const agentEvent = (event) => {
+    (0, import_subagent_engine_sdk6.updateFromEvent)(record, event);
+    if (event.type === "turn_end") limiter.onTurnEnd(record.turnCount);
+    if (event.type === "text_delta") opts.onDelta?.(event.delta);
+    opts.onEvent(event);
+  };
+  return (raw) => {
+    switch (raw.type) {
+      case "tool_execution_start":
+        handleToolExecutionStart(raw, pendingTools, agentEvent);
+        return;
+      case "tool_execution_end":
+        handleToolExecutionEnd(raw, pendingTools, agentEvent);
+        return;
+      case "message_update":
+        handleAssistantMessageUpdate(raw, agentEvent);
+        return;
+      case "turn_end":
+        agentEvent({ type: "turn_end" });
+        return;
+      case "agent_end":
+        handleAgentEnd(raw, opts);
+        return;
+      case "agent_settled":
+        handleAgentSettled(record, limiter, opts);
+        return;
+      case "message_end":
+        accumulateMessageEnd(raw, agentEvent);
+        return;
+      case "compaction_start":
+        agentEvent({ type: "compaction" });
+        return;
+      default:
+        return;
+    }
+  };
+}
+
+// src/spawn-run-pump.ts
+var import_subagent_engine_sdk7 = require("@zhushanwen/subagent-engine-sdk");
+
+// src/get-state-handshake.ts
+var GET_STATE_MAX_RETRIES = 3;
+var GET_STATE_RETRY_INTERVAL_MS = 500;
+var GET_STATE_TIMEOUT_MS = 2e3;
+function extractGetStateFields(data, into) {
+  if (data && typeof data === "object") {
+    const d = data;
+    if (typeof d.sessionFile === "string" && d.sessionFile.length > 0) {
+      into.sessionFile = d.sessionFile;
+    }
+    if (typeof d.sessionId === "string" && d.sessionId.length > 0) {
+      into.sessionId = d.sessionId;
+    }
+  }
+}
+function performGetStateHandshake(child, addResponseListener) {
+  return new Promise((resolve) => {
+    const collected = {};
+    let attempts = 0;
+    let resolved = false;
+    function tryOnce() {
+      if (resolved) return;
+      attempts++;
+      const reqId = sendGetStateCommand(child);
+      let pendingRetry;
+      const timer = setTimeout(() => {
+        pendingRetry = void 0;
+        if (attempts < GET_STATE_MAX_RETRIES && !resolved) {
+          pendingRetry = setTimeout(() => tryOnce(), GET_STATE_RETRY_INTERVAL_MS);
+          pendingRetry.unref();
+        } else if (!resolved) {
+          resolved = true;
+          resolve(collected);
+        }
+      }, GET_STATE_TIMEOUT_MS);
+      timer.unref();
+      addResponseListener(reqId, (data) => {
+        if (resolved) return;
+        clearTimeout(timer);
+        if (pendingRetry) clearTimeout(pendingRetry);
+        extractGetStateFields(data, collected);
+        if (collected.sessionFile) {
+          resolved = true;
+          resolve(collected);
+        }
+      });
+    }
+    tryOnce();
+  });
+}
+function requestGetStateOnce(child, addResponseListener, timeoutMs) {
+  return new Promise((resolve) => {
+    let settled = false;
+    let removeListener = () => {
+    };
+    const finish = (r) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      removeListener();
+      resolve(r);
+    };
+    let reqId;
+    try {
+      reqId = sendGetStateCommand(child);
+    } catch {
+      resolve({});
+      return;
+    }
+    removeListener = addResponseListener(reqId, (data) => {
+      const r = {};
+      extractGetStateFields(data, r);
+      finish(r);
+    }) ?? (() => {
+    });
+    const timer = setTimeout(() => finish({}), timeoutMs);
+    timer.unref();
+  });
+}
+
+// src/spawn-event-adapter.ts
+var fs2 = __toESM(require("fs"), 1);
+var path2 = __toESM(require("path"), 1);
+function isSessionHeader(obj) {
+  if (typeof obj !== "object" || obj === null) return false;
+  const r = obj;
+  return r.type === "session" && typeof r.id === "string" && typeof r.timestamp === "string" && typeof r.cwd === "string";
+}
+function isRpcResponse(obj) {
+  if (typeof obj !== "object" || obj === null) return false;
+  const r = obj;
+  return r.type === "response" && typeof r.command === "string" && typeof r.success === "boolean";
+}
+function isExtensionUiRequest(obj) {
+  if (typeof obj !== "object" || obj === null) return false;
+  const r = obj;
+  return r.type === "extension_ui_request" && typeof r.id === "string" && typeof r.method === "string";
+}
+function reqStr(r, key) {
+  const v = r[key];
+  return typeof v === "string" ? v : "";
+}
+function strArrayField(r, key, onMissing) {
+  const v = r[key];
+  return Array.isArray(v) ? v.filter((x) => typeof x === "string") : onMissing;
+}
+function optTimeout(r) {
+  return typeof r.timeout === "number" ? { timeout: r.timeout } : {};
+}
+function optPlaceholder(r) {
+  return typeof r.placeholder === "string" ? { placeholder: r.placeholder } : {};
+}
+function optPrefill(r) {
+  return typeof r.prefill === "string" ? { prefill: r.prefill } : {};
+}
+function optNotifyType(r) {
+  const v = r.notifyType;
+  return v === "info" || v === "warning" || v === "error" ? { notifyType: v } : {};
+}
+function optWidgetPlacement(r) {
+  const v = r.widgetPlacement;
+  return v === "aboveEditor" || v === "belowEditor" ? { widgetPlacement: v } : {};
+}
+function buildExtensionUiRequest(env) {
+  const r = env;
+  switch (env.method) {
+    case "select":
+      return {
+        method: "select",
+        title: reqStr(r, "title"),
+        options: strArrayField(r, "options", []),
+        ...optTimeout(r)
+      };
+    case "confirm":
+      return {
+        method: "confirm",
+        title: reqStr(r, "title"),
+        message: reqStr(r, "message"),
+        ...optTimeout(r)
+      };
+    case "input":
+      return {
+        method: "input",
+        title: reqStr(r, "title"),
+        ...optPlaceholder(r),
+        ...optTimeout(r)
+      };
+    case "editor":
+      return {
+        method: "editor",
+        title: reqStr(r, "title"),
+        ...optPrefill(r)
+      };
+    case "notify":
+      return {
+        method: "notify",
+        message: reqStr(r, "message"),
+        ...optNotifyType(r)
+      };
+    case "setStatus":
+      return {
+        method: "setStatus",
+        statusKey: reqStr(r, "statusKey"),
+        statusText: typeof r.statusText === "string" ? r.statusText : void 0
+      };
+    case "setWidget":
+      return {
+        method: "setWidget",
+        widgetKey: reqStr(r, "widgetKey"),
+        widgetLines: strArrayField(r, "widgetLines", void 0),
+        ...optWidgetPlacement(r)
+      };
+    case "setTitle":
+      return {
+        method: "setTitle",
+        title: reqStr(r, "title")
+      };
+    case "set_editor_text":
+      return {
+        method: "set_editor_text",
+        text: reqStr(r, "text")
+      };
+    default:
+      return { method: env.method, raw: r };
+  }
+}
+function parseSpawnLine(line) {
+  const trimmed = line.trim();
+  if (trimmed === "") return null;
+  let obj;
+  try {
+    obj = JSON.parse(trimmed);
+  } catch (err) {
+    return {
+      kind: "invalid",
+      raw: trimmed,
+      error: (0, import_subagent_engine_sdk.toErrorMessage)(err)
+    };
+  }
+  if (isSessionHeader(obj)) {
+    return { kind: "header", header: obj };
+  }
+  if (isExtensionUiRequest(obj)) {
+    return { kind: "extension_ui_request", id: obj.id, request: buildExtensionUiRequest(obj) };
+  }
+  if (isRpcResponse(obj)) {
+    return {
+      kind: "response",
+      ...typeof obj.id === "string" ? { id: obj.id } : {},
+      command: obj.command,
+      success: obj.success,
+      ...obj.data !== void 0 ? { data: obj.data } : {},
+      ...typeof obj.error === "string" ? { error: obj.error } : {}
+    };
+  }
+  if (typeof obj === "object" && obj !== null && typeof obj.type === "string") {
+    return { kind: "event", event: obj };
+  }
+  return {
+    kind: "invalid",
+    raw: trimmed,
+    error: "JSON missing string 'type' field"
+  };
+}
+function deriveSessionFilePath(header, sessionDir) {
+  const fileTimestamp = header.timestamp.replace(/[:.]/g, "-");
+  return `${sessionDir}/${fileTimestamp}_${header.id}.jsonl`;
+}
+function findSessionFileByHeaderId(sessionDir, sessionId) {
+  try {
+    const files = fs2.readdirSync(sessionDir);
+    const match = files.find((f) => f.endsWith(`_${sessionId}.jsonl`));
+    return match ? path2.join(sessionDir, match) : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/spawn-run-pump.ts
+var logger3 = (0, import_subagent_engine_sdk7.getLogger)("session-runner");
+var INVALID_LINE_LOG_CHARS = 160;
+var SIGNAL_EXIT_CODE_BASE = 128;
+function createSessionIdentityTracker(sessionDir, callbacks) {
+  let sessionId;
+  let sessionFile;
+  const stateListeners = /* @__PURE__ */ new Map();
+  const applyGetStateFields = (fields) => {
+    if (fields.sessionId !== void 0 && sessionId === void 0) sessionId = fields.sessionId;
+    if (fields.sessionFile !== void 0 && fields.sessionFile !== sessionFile) {
+      sessionFile = fields.sessionFile;
+      callbacks.onHandleReady?.({
+        sessionRef: {
+          ...sessionId !== void 0 ? { sessionId } : {},
+          sessionFile: fields.sessionFile
+        },
+        poolKey: "shared"
+      });
+    }
+  };
+  return {
+    get sessionId() {
+      return sessionId;
+    },
+    get sessionFile() {
+      return sessionFile;
+    },
+    noteHeader(header) {
+      sessionId = header.id;
+      sessionFile = deriveSessionFilePath(header, sessionDir);
+      callbacks.onHandleReady?.({
+        sessionRef: {
+          ...sessionId !== void 0 ? { sessionId } : {},
+          ...sessionFile !== void 0 ? { sessionFile } : {}
+        },
+        poolKey: "shared"
+      });
+    },
+    addStateListener(id, resolver) {
+      stateListeners.set(id, (data) => {
+        const picked = {};
+        extractGetStateFields(data, picked);
+        applyGetStateFields(picked);
+        resolver(data);
+      });
+    },
+    dispatchStateResponse(id, success, data) {
+      if (id === void 0 || !stateListeners.has(id)) return;
+      const resolver = stateListeners.get(id);
+      stateListeners.delete(id);
+      resolver?.(success ? data : void 0);
+    },
+    applyGetStateFields,
+    fallbackSessionFileByHeaderId() {
+      if (sessionFile === void 0 && sessionId !== void 0) {
+        sessionFile = findSessionFileByHeaderId(sessionDir, sessionId);
+      }
+    },
+    clearStateListeners() {
+      stateListeners.clear();
+    }
+  };
+}
+function createLineConsumer(deps) {
+  const { recordId, identity, handleSdkEvent, enqueueUi } = deps;
+  return (line) => {
+    const parsed = parseSpawnLine(line);
+    if (parsed === null) return;
+    switch (parsed.kind) {
+      case "header":
+        identity.noteHeader(parsed.header);
+        return;
+      case "event":
+        handleSdkEvent(parsed.event);
+        return;
+      case "response":
+        identity.dispatchStateResponse(parsed.id, parsed.success, parsed.data);
+        return;
+      case "extension_ui_request":
+        enqueueUi(parsed.id, parsed.request);
+        return;
+      case "invalid":
+        logger3.debug(
+          `[session-runner] invalid stdout line from ${recordId} (ignored): ${parsed.raw.slice(0, INVALID_LINE_LOG_CHARS)}`,
+          { error: parsed.error }
+        );
+        return;
+    }
+  };
+}
+function reportChildExited(child, recordId, callbacks, code, signal) {
+  if (child.pid === void 0) return;
+  callbacks.onChildStateChanged?.({
+    pid: child.pid,
+    recordId,
+    state: "exited",
+    killed: child.killed,
+    ...code !== null ? { exitCode: code } : {},
+    ...signal !== null ? { signal } : {}
+  });
+}
+function normalizeExitCode(endedCleanly, code, signal) {
+  return endedCleanly ? 0 : code ?? (signal !== null ? SIGNAL_EXIT_CODE_BASE : 0);
+}
+function createCloseFinalizer(deps, resolveExit) {
+  const { child, recordId, callbacks, identity, stderrTee, runEnd } = deps;
+  return (code, signal) => {
+    identity.clearStateListeners();
+    stderrTee?.close();
+    unregisterActiveChild(recordId, child);
+    reportChildExited(child, recordId, callbacks, code, signal);
+    identity.fallbackSessionFileByHeaderId();
+    resolveExit(normalizeExitCode(runEnd.endedCleanly, code, signal));
+  };
+}
+function wireChildStdoutPump(deps) {
+  const { child } = deps;
+  return new Promise((resolveExit) => {
+    deps.runEnd.resolveChatRun = resolveExit;
+    const consumeLine = createLineConsumer(deps);
+    const onClose = createCloseFinalizer(deps, resolveExit);
+    (0, import_subagent_engine_sdk7.pumpNdjsonLines)(child.stdout, consumeLine);
+    child.once("close", onClose);
+    child.once("error", (err) => {
+      logger3.error(`[session-runner] child ${deps.recordId} error event`, {
+        detail: (0, import_subagent_engine_sdk.toErrorMessage)(err)
+      });
+      onClose(null, null);
+    });
+    child.stdin?.on("error", (err) => {
+      if (err !== null && typeof err === "object" && "code" in err && (err.code === "EPIPE" || err.code === "ERR_STREAM_DESTROYED")) {
+        recordEpipeFailure(deps.recordId);
+      }
+    });
+  });
+}
+function reportChildSpawned(child, recordId, callbacks) {
+  if (child.pid === void 0) return;
+  callbacks.onChildSpawned?.(child.pid, recordId);
+  callbacks.onChildStateChanged?.({
+    pid: child.pid,
+    recordId,
+    state: "running",
+    killed: false
+  });
+}
+
+// src/temp-prompt.ts
+var fs3 = __toESM(require("fs"), 1);
+var os = __toESM(require("os"), 1);
+var path3 = __toESM(require("path"), 1);
+
+// src/best-effort.ts
+var import_subagent_engine_sdk8 = require("@zhushanwen/subagent-engine-sdk");
+
+// src/temp-prompt.ts
+async function writePromptToTempFile(agentName, prompt) {
+  const dir = await fs3.promises.mkdtemp(path3.join(os.tmpdir(), "pi-subagent-"));
+  const safeName = agentName.replace(/[^\w.-]+/g, "_");
+  const filePath = path3.join(dir, `prompt-${safeName}.md`);
+  await fs3.promises.writeFile(filePath, prompt, { encoding: "utf-8", mode: 384 });
+  return { dir, filePath };
+}
+async function cleanupTempPrompt(file) {
+  try {
+    await fs3.promises.rm(file.dir, { recursive: true, force: true });
+  } catch (err) {
+    (0, import_subagent_engine_sdk8.bestEffort)(err, `cleanup temp prompt dir ${file.dir}`);
+  }
+}
+
+// src/ui-request-queue.ts
+var import_subagent_engine_sdk10 = require("@zhushanwen/subagent-engine-sdk");
+
+// src/ui-channels.ts
+var import_subagent_engine_sdk9 = require("@zhushanwen/subagent-engine-sdk");
+
+// src/ui-request-queue.ts
+var logger4 = (0, import_subagent_engine_sdk10.getLogger)("subagents");
+function createUiRequestQueue(child, deps) {
+  const abortController = new AbortController();
+  const queue = [];
+  let processing = false;
+  let closed = false;
+  const warnedKeys = /* @__PURE__ */ new Set();
+  function processNext() {
+    if (processing || queue.length === 0 || closed) return;
+    processing = true;
+    const { id, request, signal } = queue.shift();
+    handleUiRequest(child, id, request, deps, signal, warnedKeys).catch((err) => {
+      const m = (0, import_subagent_engine_sdk.toErrorMessage)(err);
+      logger4.error(`[subagents] ui request ${id} (${request.method}) failed unexpectedly: ${m}`);
+    }).finally(() => {
+      processing = false;
+      processNext();
+    });
+  }
+  const onClose = () => {
+    if (closed) return;
+    closed = true;
+    abortController.abort();
+    queue.length = 0;
+  };
+  child.on("close", onClose);
+  child.on("error", onClose);
+  return function enqueue(id, request) {
+    if (closed) return;
+    queue.push({ id, request, signal: abortController.signal });
+    processNext();
+  };
+}
+async function handleUiRequest(child, id, request, deps, signal, warnedKeys) {
+  const handler = deps.uiRequestHandler;
+  if (!handler) {
+    const key = child.pid?.toString() ?? id;
+    if (!warnedKeys.has(key)) {
+      warnedKeys.add(key);
+      logger4.warn(
+        `[subagents] no ui request handler bound (host/askUser unsupported?); subsequent requests from this child will be auto-cancelled`,
+        { pid: child.pid, method: request.method }
+      );
+    }
+    respond(child, id, { cancelled: true }, signal);
+    return;
+  }
+  const { channel, channelPayload } = (0, import_subagent_engine_sdk9.parseChannel)(request);
+  const uiReq = {
+    id,
+    method: request.method,
+    ...child.pid !== void 0 ? { _childPid: child.pid } : {},
+    ...channel !== void 0 ? { channel } : {},
+    ...channelPayload !== void 0 ? { channelPayload } : {},
+    ...extractMethodFields(request)
+  };
+  try {
+    const result = await handler(uiReq);
+    if (signal?.aborted) return;
+    respond(child, id, result, signal);
+  } catch (err) {
+    if (signal?.aborted) return;
+    logger4.error("[subagents] uiRequestHandler threw", {
+      detail: (0, import_subagent_engine_sdk.toErrorMessage)(err)
+    });
+    respond(child, id, { cancelled: true }, signal);
+  }
+}
+function isStringValue(value) {
+  return typeof value === "string";
+}
+function isNumberValue(value) {
+  return typeof value === "number";
+}
+function isArrayValue(value) {
+  return Array.isArray(value);
+}
+var METHOD_FIELD_COPY_SPECS = [
+  { key: "title", guard: isStringValue },
+  { key: "options", guard: isArrayValue },
+  { key: "message", guard: isStringValue },
+  { key: "placeholder", guard: isStringValue },
+  { key: "prefill", guard: isStringValue },
+  { key: "notifyType", guard: isStringValue },
+  { key: "statusKey", guard: isStringValue },
+  { key: "statusText", guard: null },
+  { key: "widgetKey", guard: isStringValue },
+  { key: "widgetLines", guard: null },
+  { key: "widgetPlacement", guard: null },
+  { key: "text", guard: isStringValue },
+  { key: "timeout", guard: isNumberValue }
+];
+function extractMethodFields(req) {
+  const out = {};
+  const source = req;
+  for (const { key, guard } of METHOD_FIELD_COPY_SPECS) {
+    if (!(key in source)) continue;
+    const value = source[key];
+    if (guard !== null && !guard(value)) continue;
+    out[key] = value;
+  }
+  return out;
+}
+
+// src/logs/stderr-rotation.ts
+var import_subagent_engine_sdk11 = require("@zhushanwen/subagent-engine-sdk");
+var import_subagent_engine_sdk12 = require("@zhushanwen/subagent-engine-sdk");
+var PI_STDERR_LOG_PREFIX = "pi-task-stderr-";
+function stderrLogPathFor(engineDataDir, pid) {
+  return (0, import_subagent_engine_sdk11.stderrLogPathFor)(engineDataDir, pid, PI_STDERR_LOG_PREFIX);
+}
+function cleanupSiblingStderrLogs(logPath, env, now) {
+  return (0, import_subagent_engine_sdk11.cleanupSiblingStderrLogs)(logPath, env, PI_STDERR_LOG_PREFIX, now);
+}
+
+// src/spawn-runner.ts
+var logger5 = (0, import_subagent_engine_sdk13.getLogger)("session-runner");
+function buildChildEnv(params) {
+  const extras = {};
+  applySchemaEnvToChildEnv(extras, params.schemaEnv);
+  const childEnv = (0, import_subagent_engine_sdk13.buildOutboundChildEnv)({ parentEnv: process.env, extras });
+  if ((0, import_subagent_engine_sdk2.isRelayActive)(process.env)) {
+    const rootId = params.sessionRootId ?? process.env["PI_SUBAGENT_ROOT_SESSION_ID"];
+    if (rootId !== void 0 && rootId !== "") childEnv[import_subagent_engine_sdk2.RELAY_ENV_SESSION_ID] = rootId;
+    childEnv[import_subagent_engine_sdk2.RELAY_ENV_RECORD_ID] = params.recordId;
+  }
+  return childEnv;
+}
+function createStderrTee(child) {
+  if (child.stderr === null) return void 0;
+  let dataDir;
+  try {
+    dataDir = (0, import_subagent_engine_sdk13.resolveEngineDataDir)(process.env);
+  } catch {
+    return void 0;
+  }
+  const pid = child.pid;
+  if (pid === void 0) return void 0;
+  const logPath = stderrLogPathFor(dataDir, pid);
+  let stream = null;
+  let failed = false;
+  child.stderr.setEncoding("utf8");
+  child.stderr.on("data", (chunk) => {
+    if (failed) return;
+    try {
+      if (stream === null) {
+        fs4.mkdirSync((0, import_node_path.dirname)(logPath), { recursive: true });
+        stream = fs4.createWriteStream(logPath, { flags: "a" });
+        stream.on("error", () => {
+          failed = true;
+        });
+        cleanupSiblingStderrLogs(logPath, process.env);
+      }
+      stream.write(chunk);
+      if ((0, import_subagent_engine_sdk12.rotateStderrLogIfNeeded)(logPath, (0, import_subagent_engine_sdk12.stderrRotationParams)(process.env))) {
+        stream.end();
+        stream = null;
+      }
+    } catch {
+      failed = true;
+    }
+  });
+  return {
+    close() {
+      try {
+        stream?.end();
+      } catch (err) {
+        logger5.debug(`[session-runner] stderr tee close best-effort failed: ${(0, import_subagent_engine_sdk.toErrorMessage)(err)}`);
+      }
+      stream = null;
+    }
+  };
+}
+async function writeAppendPromptFile(params) {
+  const appendParts = [await buildEnvBlock(params.cwd)];
+  if (params.maxTurns && params.maxTurns > 0) appendParts.push(WRAP_UP_HINT);
+  if (params.appendSystemPrompt) appendParts.push(...params.appendSystemPrompt);
+  return appendParts.length > 0 ? await writePromptToTempFile(params.agentName, appendParts.join("\n\n")) : void 0;
+}
+function buildTranslatorOpts(params, callbacks, killChild, runEnd) {
+  const chatMode = params.chatMode === true;
+  return {
+    maxTurns: params.maxTurns,
+    graceTurns: params.graceTurns,
+    onEvent: callbacks.onEvent,
+    onDelta: callbacks.onDelta,
+    abort: () => killChild("turn limiter abort"),
+    onAgentEnd: chatMode ? () => {
+      runEnd.endedCleanly = true;
+      callbacks.onChatRoundEnd?.();
+    } : () => {
+      runEnd.endedCleanly = true;
+      killChild("agent_end final kill");
+    },
+    ...chatMode ? {
+      onAgentSettled: () => {
+        runEnd.endedCleanly = true;
+        callbacks.onChatAgentSettled?.();
+        runEnd.resolveChatRun?.(0);
+      }
+    } : {}
+  };
+}
+async function runSpawnOnce(params, callbacks) {
+  const record = (0, import_subagent_engine_sdk13.createReplayRecord)();
+  const startTime = Date.now();
+  const modelRef = parseSpawnModelRef(params.model);
+  const tempFile = await writeAppendPromptFile(params);
+  if (modelRef === void 0) {
+    throw new Error(
+      `[pi-subagent-cli] run requires a canonical model ref ("provider/id") in ctx.model, got: ${JSON.stringify(params.model)}. Recovery: the host must resolve the model before dispatching (run.params.ctx.model); check the engine routing layer.`
+    );
+  }
+  try {
+    const args = buildSpawnArgs({
+      modelRef,
+      thinkingLevel: asThinkingLevel(params.thinkingLevel),
+      agentTools: params.agentTools,
+      appendSystemPromptPath: tempFile?.filePath,
+      sessionDir: params.sessionDir,
+      sessionFile: params.resumeSessionFile,
+      forkSource: params.forkSource,
+      skillPaths: params.skillPaths,
+      mirrorFlags: params.mirrorFlags ?? mirrorMainProcessFlags(process.argv)
+    });
+    const invocation = getPiInvocation(args);
+    const child = (0, import_subagent_engine_sdk13.spawnEngineChild)({
+      command: invocation.command,
+      args: invocation.args,
+      env: buildChildEnv(params),
+      cwd: params.cwd,
+      ...params.signal !== void 0 ? { signal: params.signal } : {}
+    });
+    const killChild = (source) => {
+      void (0, import_subagent_engine_sdk13.killChain)(child, {
+        graceMs: PI_KILL_GRACE_MS,
+        unrefTimers: true,
+        escalationNote: `child ${params.recordId} (source: ${source})`
+      });
+    };
+    const runEnd = { endedCleanly: false };
+    const handleSdkEvent = createSdkEventTranslator(
+      record,
+      buildTranslatorOpts(params, callbacks, killChild, runEnd)
+    );
+    const stderrTee = createStderrTee(child);
+    if (stderrTee === void 0 && child.stderr !== null) {
+      child.stderr.resume();
+    }
+    registerActiveChild(params.recordId, child);
+    reportChildSpawned(child, params.recordId, callbacks);
+    const enqueueUi = createUiRequestQueue(child, {
+      ...callbacks.askUser !== void 0 ? { uiRequestHandler: callbacks.askUser } : {}
+    });
+    const identity = createSessionIdentityTracker(params.sessionDir, callbacks);
+    const exitPromise = wireChildStdoutPump({
+      child,
+      recordId: params.recordId,
+      callbacks,
+      identity,
+      handleSdkEvent,
+      enqueueUi,
+      stderrTee,
+      runEnd
+    });
+    void performGetStateHandshake(child, identity.addStateListener).then((r) => {
+      identity.applyGetStateFields(r);
+    });
+    sendPromptCommand(child, params.task);
+    const exitCode = await exitPromise;
+    clearEpipeFailure(params.recordId);
+    const outcome = collectOutcome(record, {
+      startTime,
+      success: exitCode === 0,
+      error: exitCode === 0 ? void 0 : `pi child exited with code ${exitCode}`,
+      sessionId: identity.sessionId ?? "",
+      sessionFile: identity.sessionFile,
+      ...params.schemaEnv !== void 0 ? { schemaExpected: true } : {}
+    });
+    return { ...outcome, sessionId: identity.sessionId };
+  } finally {
+    if (tempFile !== void 0) await cleanupTempPrompt(tempFile);
+  }
+}
+
+// src/chat-session.ts
+var import_subagent_engine_sdk14 = require("@zhushanwen/subagent-engine-sdk");
+var logger6 = (0, import_subagent_engine_sdk14.getLogger)("chat-session");
+var CHAT_KILL_GRACE_MS = 3e4;
+function emptyUsage() {
+  return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: void 0 };
+}
+function toAgentUsage(acc) {
+  return {
+    input: acc.input,
+    output: acc.output,
+    cacheRead: acc.cacheRead,
+    cacheWrite: acc.cacheWrite,
+    ...acc.cost !== void 0 ? { cost: acc.cost } : {}
+  };
+}
+function anchorOf(session) {
+  return {
+    sessionRef: {
+      recordId: session.recordId,
+      ...session.sessionFile !== void 0 ? { sessionFile: session.sessionFile } : {}
+    },
+    poolKey: PI_POOL_KEY
+  };
+}
+function roundKeyOf(session) {
+  return session.firstRoundDone ? { recordId: session.recordId } : { runId: session.spawnRunId };
+}
+function roundAbortedError(recordId, source) {
+  return {
+    code: "engine_round_aborted",
+    message: `chat round for ${recordId} was aborted by host (${source}): in-flight round terminated before settling`,
+    recovery: `The session file on disk is intact; dispatch a new run with ctx chat resume to cold-resume the conversation, or start a new chat session.`
+  };
+}
+function roundCrashedError(recordId, exit) {
+  const detail = exit.signal !== void 0 ? `signal ${exit.signal}` : `exit code ${String(exit.exitCode)}`;
+  return {
+    code: "engine_round_crashed",
+    message: `pi child for chat session ${recordId} died mid-round (${detail}); last streamed output is incomplete`,
+    recovery: `Inspect the engine stderr tee (logs/pi-task-stderr-<pid>.log) for the crash cause, then cold-resume via a new run with ctx chat resume if the session file is intact.`
+  };
+}
+function roundEpipeExhaustedError(recordId, count) {
+  return {
+    code: "engine_round_epipe_exhausted",
+    message: `EPIPE fallback exhausted for ${recordId}: ${count} consecutive stdin write failures (child process likely exited)`,
+    recovery: `Use interact close to clean up the dead session, then dispatch a new run with ctx chat resume (or a fresh chat session).`
+  };
+}
+function coldPathReject(recordId) {
+  return {
+    ok: false,
+    code: "engine_session_not_resumable",
+    message: `the pi session behind record ${recordId} has no live process in this engine instance (cold path). Recovery: dispatch a new run with ctx chat resume (pi --session cold resume), or start a new chat session.`
+  };
+}
+var ChatSessionRegistry = class {
+  executor;
+  channels;
+  sessions = /* @__PURE__ */ new Map();
+  constructor(deps = {}) {
+    this.executor = deps.spawnRunner ?? runSpawnOnce;
+  }
+  /** server 构造后注入反向通道发射面（未注入 = 无宿主面：帧丢弃 + askUser 自动 cancelled）。 */
+  bindHostChannels(channels) {
+    this.channels = channels;
+  }
+  /** recordId 是否有活会话（interact 路由判据；不建立会话）。 */
+  has(recordId) {
+    const s = this.sessions.get(recordId);
+    return s !== void 0 && !s.closed;
+  }
+  /**
+   * run 会话形态入口（首轮 + 冷续）：spawn 长驻子进程 + 首轮 prompt，本轮 agent_settled
+   * （真空闲）时 resolve（exit 0 口径，进程保活——对齐 inproc chatMode 首轮 resolve 语义）。
+   * resume 锚点存在 = 冷续（--session 续写原文件），不存在 = 首轮新建。
+   */
+  async startRound(params, opts) {
+    const stale = this.sessions.get(params.recordId);
+    if (stale !== void 0 && !stale.closed) {
+      stale.killReason = "superseded";
+      const oldChild = getActiveChild(params.recordId);
+      if (oldChild !== void 0 && !oldChild.killed) {
+        void (0, import_subagent_engine_sdk14.killChain)(oldChild, {
+          graceMs: CHAT_KILL_GRACE_MS,
+          unrefTimers: true,
+          escalationNote: `chat session ${params.recordId} (source: superseded by cold resume)`
+        });
+      }
+      this.sessions.delete(params.recordId);
+    }
+    const session = {
+      recordId: params.recordId,
+      spawnRunId: opts.runId,
+      firstRoundDone: false,
+      roundActive: true,
+      armedSeq: 1,
+      settledSeq: void 0,
+      usage: emptyUsage(),
+      roundTerminalWaiters: /* @__PURE__ */ new Set(),
+      closeAfterRound: false,
+      closed: false,
+      killReason: void 0,
+      streamEnabled: opts.stream !== void 0
+    };
+    this.sessions.set(params.recordId, session);
+    const callbacks = {
+      onEvent: (event) => {
+        this.accumulateUsage(session, event);
+        if (!session.firstRoundDone) opts.onEvent(event);
+      },
+      onHandleReady: (partial) => {
+        const sf = partial.sessionRef.sessionFile;
+        if (typeof sf === "string") session.sessionFile = sf;
+        const sid = partial.sessionRef.sessionId;
+        if (typeof sid === "string") session.sessionId = sid;
+        opts.onHandleReady?.(partial);
+      },
+      onChildSpawned: opts.onChildSpawned,
+      onChildStateChanged: (p) => {
+        if (p.state === "exited") this.handleChildExited(session, p);
+      },
+      onDelta: (delta) => {
+        if (!session.firstRoundDone) opts.stream?.onDelta(delta);
+        else if (session.streamEnabled) this.channels?.streamDelta({ recordId: session.recordId, delta });
+      },
+      askUser: (req) => {
+        if (this.channels === void 0) return Promise.resolve({ cancelled: true });
+        return this.channels.askUser(session.spawnRunId, req);
+      },
+      onChatRoundEnd: () => this.handleRoundEnd(session),
+      onChatAgentSettled: () => this.handleAgentSettled(session)
+    };
+    try {
+      return await this.executor({ ...params, chatMode: true }, callbacks);
+    } finally {
+      session.firstRoundDone = true;
+    }
+  }
+  /**
+   * interact message 热路径：prompt + streamingBehavior 直写 stdin（pi 权威裁决
+   * busy/idle：busy 时 followUp 入队 / steer 抢占，idle 时开新 turn——pi 上游语义，
+   * abort 不清 followUp 队列）。冷路径（无活进程）→ engine_session_not_resumable +
+   * 冷续指引（宿主发新 run chat+resume 接续，D1-A）。
+   */
+  deliverMessage(recordId, text, interrupt) {
+    const session = this.sessions.get(recordId);
+    const child = getActiveChild(recordId);
+    if (session === void 0 || session.closed || child === void 0 || child.killed) {
+      return coldPathReject(recordId);
+    }
+    try {
+      sendPromptCommand(child, text, {
+        streamingBehavior: interrupt ? "steer" : "followUp"
+      });
+      clearEpipeFailure(recordId);
+      session.roundActive = true;
+      session.armedSeq += 1;
+      return { ok: true, delivered: true };
+    } catch (err) {
+      if (err instanceof Error && err.message.includes("EPIPE")) {
+        const count = recordEpipeFailure(recordId);
+        if (count >= EPIPE_FAILURE_THRESHOLD) {
+          clearEpipeFailure(recordId);
+          session.roundActive = false;
+          this.emitPhase(session, { phase: "failed", error: roundEpipeExhaustedError(recordId, count) });
+          return {
+            ok: false,
+            code: "engine_interact_failed",
+            message: `EPIPE fallback exhausted for ${recordId}: ${count} consecutive failures. Recovery: close the session, then cold-resume via run chat resume or start a new chat.`
+          };
+        }
+        return {
+          ok: false,
+          code: "engine_session_not_resumable",
+          message: `EPIPE on hot path for ${recordId} (stdin pipe broken, child likely exited; attempt ${count}/${EPIPE_FAILURE_THRESHOLD}). Recovery: retry after close, or cold-resume via run chat resume.`
+        };
+      }
+      return {
+        ok: false,
+        code: "engine_interact_failed",
+        message: (0, import_subagent_engine_sdk.toErrorMessage)(err)
+      };
+    }
+  }
+  /**
+   * interact close：force = 立即杀链收割（在途轮 → failed aborted）；缺省 = 优雅关闭
+   * （在途轮标记 closeAfterRound，agent_settled 收口后收割——对齐 inproc closeSubagent
+   * 的 force 分流）；idle 态（无在途轮）立即收割（对齐 closeChatIdle 的进程回收）。
+   */
+  close(recordId, force) {
+    const session = this.sessions.get(recordId);
+    const child = getActiveChild(recordId);
+    if (session === void 0 || session.closed || child === void 0) {
+      return { ok: true, delivered: true };
+    }
+    if (force || !session.roundActive) {
+      if (session.roundActive) session.killReason = "close";
+      void (0, import_subagent_engine_sdk14.killChain)(child, {
+        graceMs: CHAT_KILL_GRACE_MS,
+        unrefTimers: true,
+        escalationNote: `chat session ${recordId} (source: interact close${force ? " force" : ""})`
+      });
+      return { ok: true, delivered: true };
+    }
+    session.closeAfterRound = true;
+    return { ok: true, delivered: true };
+  }
+  /**
+   * interact cancel（D3 协议层收敛语义，对齐 run 域 cancel 形态）：
+   * 受理（SIGTERM——run 域 AbortController→SIGTERM 同构）→ 等待目标轮次终态相位
+   * （roundLifecycle settled/idle/failed）→ 超 CANCEL_SETTLE_GRACE_MS 未收敛走与
+   * run 域同构的杀链升级（SIGTERM → grace → SIGKILL）。应答在收敛/升级完成后返回
+   * （协议层收敛语义）；无在途轮时无收敛对象，受理即返回（进程回收经 close 事件收口）。
+   */
+  async cancel(recordId) {
+    const session = this.sessions.get(recordId);
+    if (session === void 0 || session.closed) {
+      return { ok: true, delivered: true };
+    }
+    const child = getActiveChild(recordId);
+    if (child === void 0) {
+      this.sessions.delete(recordId);
+      return { ok: true, delivered: true };
+    }
+    const roundInFlight = session.roundActive;
+    const settle = roundInFlight ? this.waitForRoundTerminal(session, import_subagent_engine_sdk14.CANCEL_SETTLE_GRACE_MS) : void 0;
+    session.killReason = "cancel";
+    child.kill("SIGTERM");
+    if (settle === void 0) {
+      return { ok: true, delivered: true };
+    }
+    if (await settle) {
+      return { ok: true, delivered: true };
+    }
+    if (session.closed) {
+      return { ok: true, delivered: true };
+    }
+    logger6.warn(
+      `[chat-session] cancel for ${recordId} did not settle within ${import_subagent_engine_sdk14.CANCEL_SETTLE_GRACE_MS}ms, escalating kill chain`
+    );
+    const reaped = this.waitForRoundTerminal(session, import_subagent_engine_sdk14.CANCEL_SETTLE_GRACE_MS + CHAT_KILL_GRACE_MS);
+    void (0, import_subagent_engine_sdk14.killChain)(child, {
+      graceMs: CHAT_KILL_GRACE_MS,
+      unrefTimers: true,
+      escalationNote: `chat session ${recordId} (source: interact cancel settle timeout)`
+    });
+    await reaped;
+    return { ok: true, delivered: true };
+  }
+  // ── 内部：轮次相位处置 ──
+  /** agent_end（非 willRetry，队列排空）：本轮收敛 → settled 相位（带本轮用量）。 */
+  handleRoundEnd(session) {
+    if (session.closed || !session.roundActive) {
+      return;
+    }
+    session.roundActive = false;
+    session.settledSeq = session.armedSeq;
+    const usage = toAgentUsage(session.usage);
+    session.lastRoundUsage = usage;
+    session.usage = emptyUsage();
+    this.emitPhase(session, { phase: "settled", usage });
+  }
+  /** agent_settled（真空闲）：idle 相位（usage + anchor 回填）+ 优雅关闭收割。 */
+  handleAgentSettled(session) {
+    if (session.closed) return;
+    if (session.armedSeq === session.settledSeq) {
+      session.roundActive = false;
+    }
+    this.emitPhase(session, {
+      phase: "idle",
+      ...session.lastRoundUsage !== void 0 ? { usage: session.lastRoundUsage } : {},
+      anchor: anchorOf(session)
+    });
+    if (session.closeAfterRound) {
+      session.closeAfterRound = false;
+      const child = getActiveChild(session.recordId);
+      if (child !== void 0 && !child.killed) {
+        void (0, import_subagent_engine_sdk14.killChain)(child, {
+          graceMs: CHAT_KILL_GRACE_MS,
+          unrefTimers: true,
+          escalationNote: `chat session ${session.recordId} (source: close after round)`
+        });
+      }
+    }
+  }
+  /** 子进程退出：会话消亡；在途轮 → failed 相位（引擎主动杀 = aborted / 否则 crashed）。 */
+  handleChildExited(session, exit) {
+    if (session.closed) return;
+    session.closed = true;
+    const hadRound = session.roundActive;
+    session.roundActive = false;
+    if (this.sessions.get(session.recordId) === session) {
+      this.sessions.delete(session.recordId);
+    }
+    if (!hadRound) return;
+    if (session.killReason !== void 0) {
+      this.emitPhase(session, { phase: "failed", error: roundAbortedError(session.recordId, session.killReason) });
+      return;
+    }
+    this.emitPhase(session, { phase: "failed", error: roundCrashedError(session.recordId, exit) });
+  }
+  /**
+   * 相位发射（关联键 = 首轮 runId / 续聊 recordId）+ 轮终等待体逐一 resolve。
+   * superseded 会话抑制宿主发射（S5，守卫放单一咽喉点而非仅 handleChildExited）：
+   * 同 recordId 冷续 run 已重建会话，旧会话残留终态帧（killChain 杀死在途轮的 failed、
+   * SIGTERM 优雅收口竞态下的 settled+idle——pi trap 语义先收口再退）以 recordId 键发射
+   * 会与新会话在途轮同键串扰，core 可能把旧轮终态误配到新轮（误终态化）。superseded
+   * 信号本身 = 新 run 的 start（宿主主动发起），core 无需旧会话帧。等待体仍逐一
+   * resolve：cancel 等待中 killReason 被后续冷续覆写为 superseded 的极端时序下收敛
+   * 不悬挂。
+   *
+   * [F-4 S6 引擎半边] 旧轮的 idle 相位（agent_settled 空闲边界）在 settled→idle 间隙
+   * 宿主已投递新轮时抑制宿主发射（`armedSeq !== settledSeq` = settled 以来有新轮 arm，
+   * 该 idle 帧属旧轮——时序恒晚于新轮投递）。与 S6 的 armedSeq 守卫（handleAgentSettled
+   * 保 settled 相位、不清新轮 roundActive）同模式：旧 idle 帧若放行，core 的
+   * handleChatRoundPhase(idle) 无轮次身份可判——disarmRoundFromProtocol 拆掉新轮中段
+   * 守护 + armChatIdleTimer 挂 5min idle timer → 新轮进行中超 5min 被误杀。新轮的
+   * idle 由新轮自身 agent_settled 发射（其 armedSeq === settledSeq）。等待体仍逐一
+   * resolve（在途 cancel 的收敛兜底语义不变）。
+   */
+  emitPhase(session, phase) {
+    if (phase.phase === "idle" && session.armedSeq !== session.settledSeq) {
+      logger6.debug(
+        `[chat-session] suppress stale idle phase for ${session.recordId} (armedSeq=${session.armedSeq} advanced past settledSeq=${session.settledSeq} \u2014 a new round was armed in the settled\u2192idle gap; its own agent_settled will emit idle)`
+      );
+    } else if (session.killReason === "superseded") {
+      logger6.debug(
+        `[chat-session] suppress ${phase.phase} phase for superseded session ${session.recordId} (record cold-resumed by a new run)`
+      );
+    } else {
+      this.channels?.roundLifecycle({ ...roundKeyOf(session), ...phase });
+    }
+    for (const w of session.roundTerminalWaiters) w();
+    session.roundTerminalWaiters.clear();
+  }
+  /** message_end 用量累加（轮内增量；interact 轮无 event 通知通道，用量经相位帧回填）。 */
+  accumulateUsage(session, event) {
+    if (event.type !== "message_end" || event.usage === void 0) return;
+    session.usage.input += event.usage.input;
+    session.usage.output += event.usage.output;
+    session.usage.cacheRead += event.usage.cacheRead;
+    session.usage.cacheWrite += event.usage.cacheWrite;
+    if (event.usage.cost !== void 0) {
+      session.usage.cost = (session.usage.cost ?? 0) + event.usage.cost;
+    }
+  }
+  /** 轮终等待（cancel 收敛判据；超时 resolve false——不清理其他等待体）。 */
+  waitForRoundTerminal(session, timeoutMs) {
+    return new Promise((resolve) => {
+      const done = () => {
+        clearTimeout(timer);
+        resolve(true);
+      };
+      const timer = setTimeout(() => {
+        session.roundTerminalWaiters.delete(done);
+        resolve(false);
+      }, timeoutMs);
+      if (typeof timer.unref === "function") timer.unref();
+      session.roundTerminalWaiters.add(done);
+    });
+  }
+};
+
+// src/read-fallback.ts
+var import_node_fs = require("fs");
+var import_subagent_engine_sdk15 = require("@zhushanwen/subagent-engine-sdk");
+var import_subagent_engine_sdk16 = require("@zhushanwen/subagent-engine-sdk");
+var logger7 = (0, import_subagent_engine_sdk15.getLogger)("pi-engine/read-fallback");
+function replayJournalToSessionView(handle, engineId) {
+  const journalPath = handle.data.journalPath;
+  if (journalPath === void 0 || journalPath === "") return void 0;
+  let raw;
+  try {
+    raw = (0, import_node_fs.readFileSync)(journalPath, "utf8");
+  } catch {
+    return void 0;
+  }
+  const events = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed === "") continue;
+    try {
+      const obj = JSON.parse(trimmed);
+      const candidate = typeof obj === "object" && obj !== null && "event" in obj ? obj.event : obj;
+      if (isAgentEvent(candidate)) events.push(candidate);
+    } catch (err) {
+      logger7.debug(`[read-fallback] skip corrupt journal line: ${(0, import_subagent_engine_sdk.toErrorMessage)(err)}`);
+    }
+  }
+  if (events.length === 0) return void 0;
+  const sessionId = (0, import_subagent_engine_sdk16.sessionIdFromHandle)(handle.data);
+  return (0, import_subagent_engine_sdk16.eventsToSessionView)(events, engineId, sessionId);
+}
+function isAgentEvent(x) {
+  if (typeof x !== "object" || x === null || !("type" in x)) return false;
+  const t = x.type;
+  return t === "tool_start" || t === "tool_end" || t === "text_delta" || t === "thinking_delta" || t === "turn_end" || t === "message_end" || t === "compaction" || t === "error";
+}
+
+// src/pi-engine.ts
+var logger8 = (0, import_subagent_engine_sdk18.getLogger)("pi-engine");
+var PROBE_VERSION_TIMEOUT_MS = 1e4;
+function resolveSessionDir(dataDir, cwd) {
+  const encoded = cwd.replace(/[^a-zA-Z0-9_-]+/g, "_");
+  return path4.join(dataDir, "subagents", "sessions", encoded);
+}
+function resolveDataRoot(explicit) {
+  if (explicit !== void 0 && explicit !== "") return explicit;
+  const env = process.env.XYZ_AGENT_DATA_DIR;
+  return env !== void 0 && env !== "" ? env : void 0;
+}
+var PiEngine = class {
+  id = PI_ENGINE_ID;
+  deps;
+  probeCache;
+  /** [v1.x] chat 会话注册表（长驻会话状态面——见 chat-session.ts 文件头）。 */
+  chatSessions;
+  constructor(deps = {}) {
+    this.deps = deps;
+    this.chatSessions = new ChatSessionRegistry(
+      deps.spawnRunner !== void 0 ? { spawnRunner: deps.spawnRunner } : {}
+    );
+  }
+  /** pi 链路实际接通的能力（与 core PiEngine.capabilities() 逐位一致——manifest 同源）。 */
+  capabilities() {
+    return {
+      // PI_WORKFLOW_SCHEMA env 注入 + structured-output 扩展（方案 A 唯一校验权威）
+      schemaEnforcement: "native",
+      // pi RPC 有 steer，但 spawn 链路未接通（turn-limiter steer no-op）
+      steer: "unsupported",
+      // chatMode idle 复用 + message/close/cancel 交互面已接通（v1.x 协议路径：
+      // run 会话形态 + chat-session 会话管理器承载轮次）
+      conversation: "native",
+      // persona 经 --skill / --append-system-prompt flag 通道注入
+      personaInjection: "flag",
+      // 30+ 事件流（六引擎最细粒度）
+      eventGranularity: "stream",
+      // 无 OS sandbox；worktree 隔离（公共层）= emulated
+      sandbox: "emulated",
+      // pi session JSONL 完整重建（session-reconstructor）
+      sessionRead: "full",
+      // chatMode 同进程 idle 复用（热）+ --session 冷续写
+      resume: "native",
+      // 现链路 abort = SIGTERM（pi 子进程 trap 后 graceful shutdown）
+      interrupt: "kill-only",
+      // argv-mirror 镜像主进程 --approve 等 flag
+      permissionMode: "native",
+      // turn limiter + spawn watchdog 估算兑现轮数上限
+      maxTurns: true
+    };
+  }
+  /** 探针（D7）：invocation 可解析（二进制/脚本存在）+ 版本解析。relay:false 显式
+   *  直连——探针测 pi 本体可解析性，经 relay 探到的是 runtime 健康，语义错位。 */
+  async probe(opts) {
+    if (!opts?.force && this.probeCache) return this.probeCache;
+    const invocation = getPiInvocation(["--version"], { relay: false });
+    const invocationOk = isInvocationResolvable(invocation);
+    const checks = [
+      {
+        name: "invocation",
+        ok: invocationOk,
+        detail: invocationOk ? `${invocation.command} ${invocation.args.join(" ")}` : `cannot resolve pi executable: ${invocation.command} (script missing and not on PATH)`
+      }
+    ];
+    let engineVersion = "";
+    if (invocationOk) {
+      const runVersion = this.deps.probeVersion ?? defaultProbeVersion;
+      const version = await runVersion(invocation);
+      const versionOk = version !== void 0 && version.length > 0;
+      checks.push({
+        name: "version",
+        ok: versionOk,
+        detail: versionOk ? version : "pi --version returned empty or failed"
+      });
+      engineVersion = version ?? "";
+    }
+    const ok = checks.every((c) => c.ok);
+    const report = {
+      ok,
+      engineVersion,
+      checks,
+      ...ok ? {} : {
+        error: {
+          code: "engine_probe_failed",
+          recovery: `Run \`${invocation.command} --version\` to confirm the pi binary works, then retry the probe. If the binary is missing, reinstall pi (npm i -g @earendil-works/pi-coding-agent) or fix PATH.`
+        }
+      }
+    };
+    this.probeCache = report;
+    return report;
+  }
+  /** run 的引擎侧实现：协议 RunParams → spawn-runner 单次执行。
+   *
+   * run 期间事件经 ctx.onEvent（server 层 → `event` 通知）；session 身份经
+   * ctx.onHandleReady（→ host/handleReady）；子进程 pid/状态经镜像回调上报。
+   * 抛错语义（core PiEngine.run ①）：prepare 期失败 reject，不产生 handle。
+   *
+   * [v1.x] ctx.chat 存在 = chat 会话形态（首轮/冷续）：委托 chat-session 长驻执行
+   * （agent_end 不 kill、agent_settled resolve——本轮收口进程保活，续聊经 interact）。 */
+  async run(task, ctx) {
+    const dataDir = resolveEngineDataRootOrThrow(this.deps.dataDir);
+    ctx.onPoolResolved?.(PI_POOL_KEY);
+    const cwd = task.cwd ?? process.cwd();
+    if (ctx.chat !== void 0) {
+      return this.runChatRound(task, ctx, dataDir, cwd);
+    }
+    const spawn = this.deps.spawnRunner ?? runSpawnOnce;
+    const result = await spawn(
+      buildOneShotRunParams(task, ctx, dataDir, cwd),
+      buildRunCallbacks(ctx, this.askUserHandler)
+    );
+    return buildEngineRunResult(ctx.taskId, result);
+  }
+  /**
+   * [v1.x] run 会话形态主体（首轮/冷续，chat-domain 设计 §3.2 D1-A）：spawn 长驻子进程
+   * + 首轮 prompt，本轮 agent_settled（真空闲）resolve（进程保活）。record 锚定键 =
+   * chat.recordId（区别于一次性 run 的 runId 锚定——interact/roundLifecycle 据此定位）；
+   * resume 锚点存在 = 冷续（--session 续写原文件），不存在 = 首轮新建。
+   */
+  async runChatRound(task, ctx, dataDir, cwd) {
+    const chat = ctx.chat;
+    const resumeFile = refString(chat.resume?.sessionRef ?? {}, "sessionFile");
+    const result = await this.chatSessions.startRound(
+      buildChatRoundParams(task, ctx, dataDir, cwd, chat.recordId, resumeFile),
+      buildChatRoundCallbacks(ctx)
+    );
+    return buildEngineRunResult(chat.recordId, result);
+  }
+  /**
+   * D1 交互控制面。[v1.x] chat 会话（chat-session 命中）优先路由：
+   *   - message：热路径 sendPromptCommand + streamingBehavior（interrupt=steer 抢占/
+   *     缺省 followUp 排队——pi 上游语义）+ EPIPE 兜底（耗尽 → roundLifecycle failed）；
+   *     冷路径（进程死）→ engine_session_not_resumable + 冷续指引（宿主发新 run chat+resume）；
+   *   - close：force=杀链立即收割 / 缺省=优雅（轮收口后收割）；
+   *   - cancel：D3 收敛语义（受理 → 等轮终相位 → 超 CANCEL_SETTLE_GRACE_MS 杀链升级）。
+   *
+   * 未命中（一次性 run 的活跃子进程 / 冷句柄）走下方既有路径：message 热路径直写、
+   * close = SIGTERM、cancel = SIGTERM（无收敛等待——run 域 cancel 帧另有 AbortController
+   * 通道，收敛由 run 应答承载）。
+   */
+  async interact(handle, action) {
+    try {
+      const recordId = refString(handle.data.sessionRef, "recordId");
+      if (recordId === void 0) return notResumable(handle);
+      if (this.chatSessions.has(recordId)) return this.interactChatSession(recordId, action);
+      return this.interactRunDomain(recordId, action);
+    } catch (err) {
+      return {
+        ok: false,
+        code: "engine_interact_failed",
+        message: (0, import_subagent_engine_sdk.toErrorMessage)(err)
+      };
+    }
+  }
+  /** chat 会话命中分支（长驻）：cancel/close/message 直派 chat-session
+   *  （close force=杀链立即收割 / 缺省=优雅；message streamingBehavior 由 interrupt 决定）。 */
+  async interactChatSession(recordId, action) {
+    if (action.kind === "cancel") return this.chatSessions.cancel(recordId);
+    if (action.kind === "close") return this.chatSessions.close(recordId, action.payload?.force === true);
+    return this.chatSessions.deliverMessage(recordId, action.payload, action.interrupt === true);
+  }
+  /** 未命中分支：一次性 run 的活跃子进程 / 冷句柄——message 热路径直写 stdin、
+   *  close/cancel = SIGTERM（run 域 cancel 帧另有 AbortController 通道，收敛由 run 应答承载）。 */
+  interactRunDomain(recordId, action) {
+    if (action.kind === "cancel") {
+      const child = getActiveChild(recordId);
+      if (child === void 0) return { ok: true, delivered: true };
+      child.kill("SIGTERM");
+      return { ok: true, delivered: true };
+    }
+    if (action.kind === "close") {
+      killRecordChild(recordId);
+      return { ok: true, delivered: true };
+    }
+    return this.deliverHotPathMessage(recordId, action);
+  }
+  /** message 热路径（进程活）sendPromptCommand 直写 stdin + EPIPE 兜底
+   *  （连续失败达阈值 → 抛错升级为 engine_interact_failed；未达 → not_resumable 降级）。 */
+  deliverHotPathMessage(recordId, action) {
+    const child = getActiveChild(recordId);
+    if (child === void 0 || child.killed) {
+      return {
+        ok: false,
+        code: "engine_session_not_resumable",
+        message: `the pi session behind this handle has no live process in this engine instance (cold path). Recovery: dispatch a new run with ctx resume (pi --session cold resume), or start a new subagent.`
+      };
+    }
+    try {
+      sendPromptCommand(child, action.payload, {
+        streamingBehavior: action.interrupt === true ? "steer" : "followUp"
+      });
+      clearEpipeFailure(recordId);
+      return { ok: true, delivered: true };
+    } catch (err) {
+      if (err instanceof Error && err.message.includes("EPIPE")) {
+        const count = recordEpipeFailure(recordId);
+        if (count >= EPIPE_FAILURE_THRESHOLD) {
+          clearEpipeFailure(recordId);
+          throw new Error(
+            `[subagents] EPIPE fallback exhausted for ${recordId}: ${count} consecutive EPIPE failures. Recovery: use action:'close' to clean up, then action:'start' a new subagent.`
+          );
+        }
+        return {
+          ok: false,
+          code: "engine_session_not_resumable",
+          message: `EPIPE on hot path for ${recordId} (stdin pipe broken, child likely exited; attempt ${count}/${EPIPE_FAILURE_THRESHOLD}). Recovery: retry after close, or start a new subagent run.`
+        };
+      }
+      throw err;
+    }
+  }
+  /**
+   * read 三级降级（协议化形态）：②级 journal 重放（SDK journal-replay 纯投影）
+   * → ③级 outcome-only。①级 pi 原生读取（session-reconstructor）按 §2.7 保持
+   * core，不随迁（deviations 登记）。
+   */
+  async read(handle) {
+    const sessionFile = refString(handle.data.sessionRef, "sessionFile");
+    const journaled = replayJournalToSessionView(handle, PI_ENGINE_ID);
+    if (journaled !== void 0) return journaled;
+    void sessionFile;
+    return { engineId: PI_ENGINE_ID, turns: [], source: "outcome-only" };
+  }
+  /** dispose：全量收割活跃子进程 + 清 EPIPE 计数（幂等）。 */
+  async dispose() {
+    killAllActiveChildren();
+    resetAllEpipeFailures();
+  }
+  // ── 反向通道注入面（server 构造后接线 host/askUser） ──
+  askUserHandler;
+  /** server 层注入 host/askUser 两阶段等待体（ui-request-queue 消费）。 */
+  bindAskUser(handler) {
+    this.askUserHandler = handler;
+  }
+  /**
+   * server 层注入 [v1.x] chat 会话的反向通道发射面（host/roundLifecycle、recordId 键
+   * host/streamDelta、会话级 host/askUser）。会话跨 run 存活，绑定是引擎进程生命周期
+   * 级（区别于一次性 run 的 per-run askUser 绑定）。
+   */
+  bindHostChannels(channels) {
+    this.chatSessions.bindHostChannels(channels);
+  }
+};
+function resolveEngineDataRootOrThrow(explicit) {
+  const dataDir = resolveDataRoot(explicit);
+  if (dataDir !== void 0) return dataDir;
+  throw new import_subagent_engine_sdk18.EngineSdkError(
+    "engine_not_found",
+    "pi-subagent-cli cannot resolve the engine data root (neither initialize hostInfo.dataRoot nor env XYZ_AGENT_DATA_DIR is set)",
+    "The host must pass hostInfo.dataRoot at initialize, or inject XYZ_AGENT_DATA_DIR into the engine child env. Expected shape: <xyz-agent dataDir> (sessions live under <dataDir>/subagents/sessions/)."
+  );
+}
+function buildOneShotRunParams(task, ctx, dataDir, cwd) {
+  return {
+    recordId: ctx.taskId,
+    task: task.prompt,
+    agentName: task.description ?? task.agent ?? "workflow-agent",
+    model: ctx.ctxModel !== void 0 ? `${ctx.ctxModel.provider}/${ctx.ctxModel.id}` : task.model,
+    ...task.thinkingLevel !== void 0 ? { thinkingLevel: task.thinkingLevel } : {},
+    sessionDir: resolveSessionDir(dataDir, cwd),
+    cwd,
+    ...task.schemaEnv !== void 0 ? { schemaEnv: task.schemaEnv } : {},
+    ...task.maxTurns !== void 0 ? { maxTurns: task.maxTurns } : {},
+    ...task.graceTurns !== void 0 ? { graceTurns: task.graceTurns } : {},
+    ...ctx.signal !== void 0 ? { signal: ctx.signal } : {},
+    ...task.skillPath !== void 0 ? { skillPaths: [task.skillPath] } : {},
+    ...task.appendSystemPrompt !== void 0 ? { appendSystemPrompt: task.appendSystemPrompt } : {},
+    // fork-from 显式分叉源（协议 task.forkSource → --fork；一次性 run 承载——
+    // fork-from 无 chatMode，chat 轮续写走 resumeSessionFile 通路互不相交）。
+    ...task.forkSource !== void 0 ? { forkSource: task.forkSource } : {}
+  };
+}
+function buildRunCallbacks(ctx, askUserHandler) {
+  return {
+    onEvent: (event) => ctx.onEvent?.(event),
+    onHandleReady: (partial) => ctx.onHandleReady?.(partial),
+    onChildSpawned: (pid) => {
+      ctx.onChildSpawned?.({ pid, killed: false });
+    },
+    ...ctx.stream !== void 0 ? { onDelta: (delta) => ctx.stream?.onDelta(delta) } : {},
+    ...askUserHandler !== void 0 ? { askUser: (req) => askUserHandler(req) } : {}
+  };
+}
+function buildChatRoundParams(task, ctx, dataDir, cwd, recordId, resumeFile) {
+  return {
+    recordId,
+    task: task.prompt,
+    agentName: task.description ?? task.agent ?? "chat-agent",
+    model: ctx.ctxModel !== void 0 ? `${ctx.ctxModel.provider}/${ctx.ctxModel.id}` : task.model,
+    ...task.thinkingLevel !== void 0 ? { thinkingLevel: task.thinkingLevel } : {},
+    sessionDir: resolveSessionDir(dataDir, cwd),
+    cwd,
+    ...task.schemaEnv !== void 0 ? { schemaEnv: task.schemaEnv } : {},
+    ...task.maxTurns !== void 0 ? { maxTurns: task.maxTurns } : {},
+    ...task.graceTurns !== void 0 ? { graceTurns: task.graceTurns } : {},
+    ...ctx.signal !== void 0 ? { signal: ctx.signal } : {},
+    ...task.skillPath !== void 0 ? { skillPaths: [task.skillPath] } : {},
+    ...task.appendSystemPrompt !== void 0 ? { appendSystemPrompt: task.appendSystemPrompt } : {},
+    ...resumeFile !== void 0 ? { resumeSessionFile: resumeFile } : {}
+  };
+}
+function buildChatRoundCallbacks(ctx) {
+  return {
+    runId: ctx.taskId,
+    onEvent: (event) => ctx.onEvent?.(event),
+    ...ctx.stream !== void 0 ? { stream: ctx.stream } : {},
+    onHandleReady: (partial) => ctx.onHandleReady?.(partial),
+    onChildSpawned: (pid) => {
+      ctx.onChildSpawned?.({ pid, killed: false });
+    }
+  };
+}
+function buildEngineRunResult(recordId, result) {
+  return {
+    handle: {
+      data: {
+        v: 1,
+        engineId: PI_ENGINE_ID,
+        sessionRef: {
+          recordId,
+          ...result.sessionId !== void 0 ? { sessionId: result.sessionId } : {},
+          ...result.sessionFile !== void 0 ? { sessionFile: result.sessionFile } : {}
+        },
+        poolKey: PI_POOL_KEY,
+        adapterVersion: PI_ADAPTER_VERSION
+      }
+    },
+    outcome: toOutcome(result)
+  };
+}
+function toOutcome(result) {
+  return {
+    content: result.content,
+    ...result.failureKind !== void 0 ? { failureKind: result.failureKind } : {},
+    ...result.parsedOutput !== void 0 ? { parsedOutput: result.parsedOutput } : {},
+    ...result.usage !== void 0 ? { usage: toOutcomeUsage(result) } : {},
+    durationMs: result.durationMs,
+    ...result.error !== void 0 ? { error: result.error } : {},
+    ...result.sessionId !== void 0 ? { sessionId: result.sessionId } : {},
+    ...result.sessionFile !== void 0 ? { sessionFile: result.sessionFile } : {},
+    toolCalls: result.toolCalls.map((tc) => ({
+      name: tc.toolName,
+      input: tc.args === void 0 ? "" : JSON.stringify(tc.args)
+    })),
+    engineId: PI_ENGINE_ID
+  };
+}
+function toOutcomeUsage(result) {
+  const u = result.usage;
+  return {
+    input: u.input,
+    output: u.output,
+    cacheRead: u.cacheRead,
+    cacheWrite: u.cacheWrite,
+    cost: u.cost ?? 0,
+    contextTokens: u.input + u.cacheRead,
+    turns: result.turns
+  };
+}
+function refString(ref, key) {
+  const v = ref[key];
+  return typeof v === "string" ? v : void 0;
+}
+function killRecordChild(recordId) {
+  const child = getActiveChild(recordId);
+  if (child === void 0 || child.killed) return;
+  child.kill("SIGTERM");
+}
+function notResumable(handle) {
+  return {
+    ok: false,
+    code: "engine_session_not_resumable",
+    message: `the pi session behind this handle is not resumable via interact (record not found for sessionRef ${JSON.stringify(handle.data.sessionRef)}). Recovery: use a cold resume path (pi --session with the session file), or start a new subagent.`
+  };
+}
+async function defaultProbeVersion(invocation) {
+  try {
+    return await new Promise((resolve, reject) => {
+      (0, import_node_child_process2.execFile)(
+        invocation.command,
+        invocation.args,
+        { encoding: "utf8", timeout: PROBE_VERSION_TIMEOUT_MS, env: (0, import_subagent_engine_sdk17.buildOutboundChildEnv)({ parentEnv: process.env }) },
+        (err, stdout) => {
+          if (err) reject(err);
+          else resolve(stdout.trim().split("\n")[0]?.trim() || void 0);
+        }
+      );
+    });
+  } catch (err) {
+    logger8.debug(
+      `[pi-engine] probe version check failed (best-effort continue): ${(0, import_subagent_engine_sdk.toErrorMessage)(err)}`
+    );
+    return void 0;
+  }
+}
+function isInvocationResolvable(invocation) {
+  if (invocation.command !== "pi") return true;
+  const pathEnv = process.env.PATH ?? "";
+  for (const dir of pathEnv.split(path4.delimiter)) {
+    if (dir === "") continue;
+    try {
+      if (fs5.existsSync(path4.join(dir, "pi"))) return true;
+    } catch (err) {
+      logger8.debug(
+        `[pi-engine] PATH dir probe failed (continue scanning): ${dir}: ${(0, import_subagent_engine_sdk.toErrorMessage)(err)}`
+      );
+    }
+  }
+  return false;
+}
+
+// src/port-types.ts
+var import_subagent_engine_sdk19 = require("@zhushanwen/subagent-engine-sdk");
+
+// src/server.ts
+var REVERSE_TIMEOUT_DEFAULT_MS = 6e4;
+function createDefaultPiEngine() {
+  return new PiEngine();
+}
+var EngineProtocolServer = class {
+  write;
+  engine;
+  reverseClock;
+  reverseTimeoutMs;
+  activeRuns = /* @__PURE__ */ new Map();
+  reversePending = /* @__PURE__ */ new Map();
+  /** 10 正向方法 → EnginePort 装配表（构造期冻结；表驱动分发）。 */
+  dispatchTable;
+  revSeq = 0;
+  initialized = false;
+  constructor(opts) {
+    this.write = opts.write;
+    this.engine = opts.engine ?? createDefaultPiEngine();
+    this.reverseClock = opts.reverseClock;
+    this.reverseTimeoutMs = opts.reverseTimeoutMs ?? REVERSE_TIMEOUT_DEFAULT_MS;
+    this.dispatchTable = this.buildDispatchTable();
+    this.engine.bindHostChannels?.({
+      streamDelta: (p) => {
+        void this.reverseRequestInternal("host/streamDelta", p);
+      },
+      roundLifecycle: (p) => {
+        void this.reverseRequestInternal("host/roundLifecycle", p);
+      },
+      askUser: (runId, request) => this.reverseRequestInternal("host/askUser", { runId, request })
+    });
+  }
+  /** 入站帧消费（请求帧 + 反向请求应答帧；main.ts 的行解析器拆行后喂入）。 */
+  handleFrame(frame) {
+    if ((0, import_subagent_engine_sdk20.isResponseFrame)(frame)) {
+      this.settleReverse(frame.id, frame);
+      return;
+    }
+    if ((0, import_subagent_engine_sdk20.isReverseRequestFrame)(frame)) {
+      this.write({
+        id: 0,
+        error: {
+          code: "engine_protocol_bad_frame",
+          message: `unexpected reverse request frame from host: ${String(frame.method)}`,
+          recovery: "The engine protocol v1 only carries host/* requests engine\u2192host."
+        }
+      });
+      return;
+    }
+    if (typeof frame === "object" && frame !== null && "id" in frame && "method" in frame && typeof frame.method === "string") {
+      const { id, method, params } = frame;
+      if (typeof id === "number") {
+        void this.dispatch(id, method, params).then(
+          (result) => this.write({ id, result }),
+          (err) => this.write({ id, error: toProtocolError(err) })
+        );
+        return;
+      }
+    }
+  }
+  /** 10 正向方法 → EnginePort 装配表（协议载荷 cast 收敛在各方法适配行）。 */
+  buildDispatchTable() {
+    return {
+      initialize: (params) => this.initialize(params),
+      probe: (params) => this.engine.probe(typeof params === "object" && params !== null ? params : void 0),
+      run: (params) => this.run(params),
+      cancel: (params) => this.cancel(params),
+      interact: (params) => this.interact(params),
+      read: (params) => this.read(params),
+      listModels: () => ({ models: this.engine.listModels?.() ?? null }),
+      validateModel: (params) => this.validateModel(params),
+      dispose: async () => {
+        await this.engine.dispose?.();
+        return { ok: true };
+      },
+      ping: () => ({ pong: true })
+    };
+  }
+  /** 10 正向方法分发（表驱动；未知方法 → engine_protocol_unknown_method）。 */
+  async dispatch(id, method, params) {
+    const handler = this.dispatchTable[method];
+    if (handler === void 0) {
+      throw new import_subagent_engine_sdk20.EngineSdkError(
+        "engine_protocol_unknown_method",
+        `unknown protocol method: ${method} (request id ${id})`,
+        "The engine speaks protocol v1; check the installed engine package version vs the host."
+      );
+    }
+    return handler(params);
+  }
+  // ── initialize：版本协商（越界 → engine_protocol_mismatch）+ 能力应答 ──
+  initialize(params) {
+    if (params?.protocolVersion !== import_subagent_engine_sdk20.ENGINE_PROTOCOL_VERSION) {
+      throw new import_subagent_engine_sdk20.EngineSdkError(
+        "engine_protocol_mismatch",
+        `host protocol version ${String(params?.protocolVersion)} is not compatible with engine protocol v${import_subagent_engine_sdk20.ENGINE_PROTOCOL_VERSION}`,
+        `Upgrade the engine package or the host so both speak protocol v${import_subagent_engine_sdk20.ENGINE_PROTOCOL_VERSION}.`
+      );
+    }
+    this.initialized = true;
+    const models = this.engine.listModels?.() ?? null;
+    return {
+      protocolVersion: import_subagent_engine_sdk20.ENGINE_PROTOCOL_VERSION,
+      engineId: this.engine.id,
+      engineVersion: PI_ADAPTER_VERSION,
+      adapterVersion: PI_ADAPTER_VERSION,
+      capabilities: this.engine.capabilities(),
+      ...models !== null ? { models: models.map((m) => ({ id: m.id })) } : {}
+    };
+  }
+  // ── run：协议载荷 → 本地 AgentCallOpts/RunContext；事件 → 通知/host 通道 ──
+  async run(params) {
+    if (!this.initialized) {
+      throw new import_subagent_engine_sdk20.EngineSdkError(
+        "engine_protocol_not_initialized",
+        "run before initialize is a protocol violation",
+        "The host must complete the initialize handshake before dispatching runs."
+      );
+    }
+    if (params.chat !== void 0) this.assertChatRunFrame(params.chat);
+    const { runId, task, ctx } = params;
+    const controller = new AbortController();
+    this.activeRuns.set(runId, { controller, seq: 0 });
+    const isChatRun = params.chat !== void 0;
+    if (!isChatRun) {
+      this.engine.bindAskUser?.(
+        (request) => this.reverseRequestInternal("host/askUser", { runId, request })
+      );
+    }
+    const fullTask = { ...task, ...ctx.model !== void 0 ? { model: ctx.model } : {} };
+    try {
+      const r = await this.engine.run(
+        fullTask,
+        this.buildRunContext(params, controller, params.chat?.recordId)
+      );
+      return { handle: r.handle.data, outcome: r.outcome };
+    } finally {
+      this.activeRuns.delete(runId);
+      if (!isChatRun) this.engine.bindAskUser?.(void 0);
+    }
+  }
+  /** run.chat 帧校验 + chat 能力位 gate（A6 方向防御）：recordId 非空 + conversation
+   *  位 unsupported 同步拒——判据单源 = SDK assertChatConversationSupported（与 core
+   *  capability-gate 同一能力位，防两侧判据漂移）。本引擎 manifest 声明 native，
+   *  此处仅防御 manifest/实装漂移。 */
+  assertChatRunFrame(chat) {
+    if (typeof chat.recordId !== "string" || chat.recordId === "") {
+      throw new import_subagent_engine_sdk20.EngineSdkError(
+        "engine_protocol_bad_frame",
+        `run.chat requires a non-empty recordId (got: ${JSON.stringify(chat.recordId)})`,
+        "The host must mint a record id before dispatching a chat-form run; it keys interact routing and roundLifecycle association."
+      );
+    }
+    (0, import_subagent_engine_sdk20.assertChatConversationSupported)(this.engine.id, this.engine.capabilities());
+  }
+  /** RunContext 装配（协议 ctx 还原 + host/* 反向通道接线；事件 seq 由 emitEvent 计数）。 */
+  buildRunContext(params, controller, chatRecordId) {
+    const { runId, ctx } = params;
+    const ctxModel = (0, import_subagent_engine_sdk19.parseCtxModel)(ctx.ctxModel);
+    const stream = ctx.streamMode === "stream" ? { onDelta: (delta) => {
+      void this.reverseRequestInternal("host/streamDelta", { runId, delta });
+    } } : void 0;
+    return {
+      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 } : {},
+      ...params.chat !== void 0 ? { chat: params.chat } : {},
+      onPoolResolved: (poolKey) => {
+        void this.reverseRequestInternal("host/poolResolved", { runId, poolKey });
+      },
+      onHandleReady: (partial) => {
+        void this.reverseRequestInternal("host/handleReady", { runId, sessionRef: partial.sessionRef, poolKey: partial.poolKey });
+      },
+      onChildSpawned: (child) => {
+        if (child.pid === void 0) return;
+        void this.reverseRequestInternal("host/childSpawned", { pid: child.pid, recordId: chatRecordId ?? runId });
+      }
+    };
+  }
+  cancel(params) {
+    const active = this.activeRuns.get(params.runId);
+    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 });
+  }
+  validateModel(params) {
+    if (this.engine.validateModel === void 0) {
+      throw new import_subagent_engine_sdk20.EngineSdkError(
+        "engine_capability_unsupported",
+        "engine does not implement validateModel",
+        "Manifest omits modelCatalog; model validation falls back to run-time engine checks."
+      );
+    }
+    return this.engine.validateModel(params.modelRef);
+  }
+  // ── 出站：事件通知 + 反向请求客户端 ──
+  emitEvent(runId, event) {
+    const active = this.activeRuns.get(runId);
+    const seq = active !== void 0 ? ++active.seq : 0;
+    this.write({ method: "event", params: { runId, seq, event } });
+  }
+  /** 反向请求发送（公开面：main.ts 的 host/log 桥接消费；内部 run 通道同路）。 */
+  reverseRequest(method, params) {
+    return this.reverseRequestInternal(method, params);
+  }
+  reverseRequestInternal(method, params) {
+    const id = `rev-${++this.revSeq}`;
+    return new Promise((resolve, 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.reverseClock?.started(id);
+      this.write({ id, method, params });
+    });
+  }
+  /** 反向请求应答落位。
+   *
+   * ack 两阶段（R9-2）：人机交互通道（host/askUser / host/permission）宿主先回
+   * `{ack:true}`——只 ack 计时面（移出 in-flight 自灭计时），**不终结等待**；最终
+   * 结果帧才 settle。数据面通道宿主直接回终态（{ok:true} 等），ack 即 settle。 */
+  settleReverse(id, frame) {
+    const pending = this.reversePending.get(String(id));
+    if (pending === void 0) return;
+    this.reverseClock?.acked(String(id));
+    if (frame.error === void 0 && typeof frame.result === "object" && frame.result !== null && "ack" in frame.result && frame.result.ack === true) {
+      return;
+    }
+    this.reversePending.delete(String(id));
+    clearTimeout(pending.timer);
+    this.reverseClock?.settled(String(id));
+    if (frame.error !== void 0) pending.reject(new Error(`reverse request ${String(id)} rejected: ${(0, import_subagent_engine_sdk.toErrorMessage)(frame.error)}`));
+    else pending.resolve(frame.result);
+  }
+};
+function toProtocolError(err) {
+  if (err instanceof import_subagent_engine_sdk20.EngineSdkError) return err.toStructured();
+  return {
+    code: "engine_run_failed",
+    message: (0, import_subagent_engine_sdk.toErrorMessage)(err),
+    recovery: "Check the engine process logs (host/log stream + stderr) and rerun; if persistent, reinstall or upgrade the engine package."
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ChatSessionRegistry,
+  DETERMINISTIC_SCHEMA_FAILURE_PREFIX,
+  EPIPE_FAILURE_THRESHOLD,
+  EngineProtocolServer,
+  PI_ADAPTER_VERSION,
+  PI_ENGINE_ID,
+  PI_POOL_KEY,
+  PiEngine,
+  STALE_CONTEXT_PATTERNS,
+  WRAP_UP_HINT,
+  applySchemaEnvToChildEnv,
+  buildEnvBlock,
+  buildSpawnArgs,
+  classifyFailureKind,
+  clearEpipeFailure,
+  collectOutcome,
+  createDefaultPiEngine,
+  createTurnLimiter,
+  createUiRequestQueue,
+  deriveSessionFilePath,
+  describeMissingParsedOutput,
+  extractParsedOutput,
+  findSessionFileByHeaderId,
+  getActiveChild,
+  getPiInvocation,
+  isDeterministicSchemaFailureMsg,
+  isStaleContextErrorMsg,
+  killAllActiveChildren,
+  mapAssistantMessageDelta,
+  mirrorMainProcessFlags,
+  neutralizeStalePatterns,
+  parseChannel,
+  parseSpawnLine,
+  parseSpawnModelRef,
+  performGetStateHandshake,
+  recordEpipeFailure,
+  replayJournalToSessionView,
+  requestGetStateOnce,
+  resetAllEpipeFailures,
+  respond,
+  runSpawnOnce,
+  sendGetStateCommand,
+  sendPromptCommand
+});