chainlesschain 0.162.174 → 0.162.176

package/src/runtime/headless-stream.js

@@ -79,6 +79,7 @@ import {
   reconcileSideEffects,
   classifyToolSideEffect,
 } from "../lib/side-effect-ledger.js";
+import { DiffReviewFollowUpTracker } from "../lib/diff-review-follow-up.js";
 import {
   loadSideEffectLedger,
   persistSideEffectLedger,
@@ -240,26 +241,106 @@ export function createStreamCoalescer({
 export function planSnapshot(pm) {
   let items = [];
   let risk = null;
+  let planId = null;
+  let planVersion = null;
+  let previousPlanId = null;
+  let executionLock = null;
   try {
     const plan = pm.currentPlan;
+    planId = plan?.id || null;
+    planVersion = plan?.version || null;
+    previousPlanId = plan?.revisionOf || null;
     items = (plan?.items || []).map((i) => ({
       id: i.id,
       title: i.title,
       tool: i.tool,
       impact: i.estimatedImpact || "low",
       status: i.status,
+      ...(i.turn ? { turn: i.turn } : {}),
+      ...(i.toolUseId ? { tool_use_id: i.toolUseId } : {}),
+      ...(i.startedAt ? { started_at: i.startedAt } : {}),
+      ...(i.completedAt ? { completed_at: i.completedAt } : {}),
+      ...(i.error ? { error: String(i.error).slice(0, 1000) } : {}),
     }));
     if (items.length > 0) {
       const r = pm.getRiskAssessment();
       if (r) risk = { level: r.level, totalScore: r.totalScore };
     }
+    executionLock = pm.getExecutionLock?.() || null;
   } catch {
     /* snapshot is best-effort */
   }
-  return { active: pm.isActive(), state: pm.state || null, items, risk };
+  return {
+    active: pm.isActive(),
+    state: pm.state || null,
+    plan_id: planId,
+    plan_version: planVersion,
+    previous_plan_id: previousPlanId,
+    items,
+    risk,
+    ...(executionLock ? { execution_lock: executionLock } : {}),
+  };
 }
 
 const MAX_PLAN_REVIEW_SNAPSHOT_CHARS = 24000;
+const MAX_PLAN_REVIEW_COMMENTS = 64;
+const MAX_PLAN_REVIEW_COMMENT_CHARS = 2000;
+
+function boundedReviewString(value, limit) {
+  return String(value == null ? "" : value).slice(0, limit);
+}
+
+function normalizePlanReviewComments(values) {
+  const out = [];
+  let remaining = MAX_PLAN_REVIEW_SNAPSHOT_CHARS;
+  for (const raw of Array.isArray(values)
+    ? values.slice(0, MAX_PLAN_REVIEW_COMMENTS)
+    : []) {
+    if (!raw || typeof raw !== "object" || remaining <= 0) continue;
+    const text = boundedReviewString(
+      raw.text,
+      Math.min(MAX_PLAN_REVIEW_COMMENT_CHARS, remaining),
+    ).trim();
+    if (!text) continue;
+    remaining -= text.length;
+    const positive = (value) => {
+      const number = Number(value);
+      return Number.isInteger(number) && number > 0 ? number : null;
+    };
+    out.push({
+      id: boundedReviewString(raw.id, 160) || `comment-${out.length + 1}`,
+      sourceLine: positive(raw.sourceLine),
+      itemId: boundedReviewString(raw.itemId, 160) || null,
+      text,
+      file: boundedReviewString(raw.file, 1024) || null,
+      line: positive(raw.line),
+      column: positive(raw.column),
+      turn: positive(raw.turn),
+    });
+  }
+  return out;
+}
+
+function normalizePlanExecutionLock(value) {
+  if (!value || typeof value !== "object") return null;
+  const strings = (input, limit = 128) => [
+    ...new Set(
+      (Array.isArray(input) ? input : [])
+        .slice(0, limit)
+        .map((entry) => boundedReviewString(entry, 160))
+        .filter(Boolean),
+    ),
+  ];
+  return {
+    planId: boundedReviewString(value.planId, 160),
+    permissionMode: boundedReviewString(value.permissionMode, 64) || "default",
+    approvedItemIds: strings(value.approvedItemIds),
+    allowedTools: strings(value.allowedTools),
+    ...(value.createdAt
+      ? { createdAt: boundedReviewString(value.createdAt, 64) }
+      : {}),
+  };
+}
 
 function planReviewFromInput(obj) {
   const review =
@@ -270,7 +351,8 @@ function planReviewFromInput(obj) {
       : typeof review?.snapshot === "string"
         ? review.snapshot
         : "";
-  if (!snapshot.trim()) return null;
+  const comments = normalizePlanReviewComments(review?.comments);
+  if (!snapshot.trim() && comments.length === 0) return null;
   const text =
     snapshot.length > MAX_PLAN_REVIEW_SNAPSHOT_CHARS
       ? snapshot.slice(0, MAX_PLAN_REVIEW_SNAPSHOT_CHARS) +
@@ -282,22 +364,43 @@ function planReviewFromInput(obj) {
       typeof review?.reviewedAt === "string" ? review.reviewedAt : null,
     conversationId:
       typeof review?.conversationId === "string" ? review.conversationId : null,
+    revision:
+      Number.isInteger(review?.revision) && review.revision > 0
+        ? review.revision
+        : null,
+    comments,
+    executionLock: normalizePlanExecutionLock(review?.executionLock),
     snapshot: text,
   };
 }
 
 function planReviewSystemMessage(review) {
-  if (!review?.snapshot) return null;
+  if (!review || (!review.snapshot && !review.comments?.length)) return null;
   const meta = [
     review.action ? `action=${review.action}` : null,
     review.reviewedAt ? `reviewedAt=${review.reviewedAt}` : null,
     review.conversationId ? `conversationId=${review.conversationId}` : null,
+    review.revision ? `revision=${review.revision}` : null,
   ]
     .filter(Boolean)
     .join(" ");
-  return (
-    "[PLAN REVIEW SNAPSHOT]" + (meta ? ` ${meta}` : "") + "\n" + review.snapshot
-  );
+  const sections = [
+    "[PLAN REVIEW SNAPSHOT]" + (meta ? ` ${meta}` : ""),
+    review.snapshot || "(no Markdown snapshot)",
+  ];
+  if (review.comments?.length) {
+    sections.push(
+      "[PLAN REVIEW STRUCTURED COMMENTS]",
+      JSON.stringify(review.comments),
+    );
+  }
+  if (review.executionLock) {
+    sections.push(
+      "[PLAN REVIEW REQUESTED EXECUTION LOCK - AUDIT ONLY]",
+      JSON.stringify(review.executionLock),
+    );
+  }
+  return sections.join("\n");
 }
 import { withQuietStdout } from "./quiet-stdout.js";
 
@@ -329,7 +432,8 @@ export function parseInputEvent(line) {
   // Plan-mode control events (chat-panel plan UI):
   //   {"type":"plan","action":"enter"|"approve"|"reject"}
   if (obj && typeof obj === "object" && obj.type === "plan") {
-    const action = String(obj.action || "").toLowerCase();
+    const rawAction = String(obj.action || "").toLowerCase();
+    const action = rawAction === "requestchanges" ? "revise" : rawAction;
     if (!action) return null;
     const planReview = planReviewFromInput(obj);
     return planReview ? { plan: action, planReview } : { plan: action };
@@ -583,7 +687,7 @@ function buildSideEffectRecovery(ledger) {
 async function runTurn(
   messages,
   loopOptions,
-  { runLoop, emit, costBudget, nextToolUseId, sideEffects },
+  { runLoop, emit, costBudget, nextToolUseId, sideEffects, turnNumber },
 ) {
   const usage = {
     input_tokens: 0,
@@ -595,10 +699,14 @@ async function runTurn(
   let finalText = "";
   let endReason = "complete";
   let stopForCost = false;
+  let responseCompleted = false;
   // P0-2: the side-effect op currently in flight (at most one — the loop runs
   // tools serially). Non-null only between a dangerous tool's tool-executing
   // and its tool-result.
   let currentSideEffectOpId = null;
+  const diffReviewFollowUps = new DiffReviewFollowUpTracker(
+    sideEffects?.ledger,
+  );
 
   // Collapse consecutive same-role turns before the model call ONLY when the
   // caller flags a resume-degenerate transcript (`mergeRoles`): a resumed
@@ -629,13 +737,28 @@ async function runTurn(
         // agent-sdk docs/PROTOCOL.md §1.2.1): the matching tool_result below
         // echoes the same id so UIs can pair calls without adjacency.
         const toolUseId = nextToolUseId ? nextToolUseId() : undefined;
-        toolCalls.push({ id: toolUseId, tool: event.tool, args: event.args });
+        const pm = getPlanModeManager();
+        const planItem = pm.startPlanItemForTool(event.tool, {
+          toolUseId,
+          turn: turnNumber,
+        });
+        toolCalls.push({
+          id: toolUseId,
+          tool: event.tool,
+          args: event.args,
+          planItemId: planItem?.id || null,
+        });
         emit({
           type: "tool_use",
           ...(toolUseId ? { id: toolUseId } : {}),
+          ...(planItem?.id ? { plan_item_id: planItem.id } : {}),
+          ...(planItem?.turn ? { turn: planItem.turn } : {}),
           tool: event.tool,
           args: event.args,
         });
+        if (planItem) {
+          emit({ type: "plan_update", ...planSnapshot(pm) });
+        }
         // P0-2: record an irreversible effect as STARTED (persisted before it
         // settles) so a crash before the matching tool-result leaves a
         // reconcilable "in flight" marker instead of a silent replay — mirrors
@@ -673,6 +796,13 @@ async function runTurn(
         // P0-2: settle the in-flight side-effect (commit on success, fail on
         // a clean error) and persist the updated ledger snapshot.
         if (sideEffects && currentSideEffectOpId) {
+          if (event.result?._diffReviewAudit) {
+            diffReviewFollowUps.observe(
+              sideEffects.ledger,
+              currentSideEffectOpId,
+              event.result._diffReviewAudit,
+            );
+          }
           if (err)
             sideEffects.ledger.fail(
               currentSideEffectOpId,
@@ -688,14 +818,29 @@ async function runTurn(
         const lastCall =
           toolCalls.length > 0 ? toolCalls[toolCalls.length - 1] : null;
         if (lastCall) lastCall.is_error = Boolean(err);
+        const pm = getPlanModeManager();
+        const settledItem = lastCall?.planItemId
+          ? pm.settlePlanItem(lastCall.planItemId, {
+              success: !err,
+              error: err,
+              result: event.result,
+            })
+          : null;
         emit({
           type: "tool_result",
           ...(lastCall?.id ? { id: lastCall.id } : {}),
+          ...(lastCall?.planItemId
+            ? { plan_item_id: lastCall.planItemId }
+            : {}),
+          ...(settledItem?.turn ? { turn: settledItem.turn } : {}),
           tool: event.tool,
           is_error: Boolean(err),
           error: err,
           result: event.result,
         });
+        if (settledItem) {
+          emit({ type: "plan_update", ...planSnapshot(pm) });
+        }
         break;
       }
       case "token-usage":
@@ -735,6 +880,7 @@ async function runTurn(
         break;
       case "response-complete":
         finalText = event.content || "";
+        responseCompleted = true;
         break;
       case "run-ended":
         if (event.reason) endReason = event.reason;
@@ -747,6 +893,18 @@ async function runTurn(
     // just the switch) so no further paid LLM call is made.
     if (stopForCost) break;
   }
+  if (
+    sideEffects &&
+    diffReviewFollowUps.complete(sideEffects.ledger, {
+      status:
+        responseCompleted || endReason === "complete"
+          ? "completed-without-reproposal"
+          : "interrupted",
+      reason: responseCompleted || endReason === "complete" ? null : endReason,
+    }).length > 0
+  ) {
+    sideEffects.persist();
+  }
   return { finalText, endReason, usage, toolCalls };
 }
 
@@ -1137,6 +1295,7 @@ export async function runAgentHeadlessStream(options = {}, deps = {}) {
     options: qOptions,
     multiSelect,
     timeoutMs,
+    metadata,
   } = {}) =>
     new Promise((resolve, reject) => {
       const id = `q-${++questionSeq}`;
@@ -1151,6 +1310,7 @@ export async function runAgentHeadlessStream(options = {}, deps = {}) {
         question: typeof question === "string" ? question : "",
         options: Array.isArray(qOptions) ? qOptions : null,
         multiSelect: multiSelect === true,
+        ...(metadata && typeof metadata === "object" ? { metadata } : {}),
       });
     });
 
@@ -1458,6 +1618,39 @@ export async function runAgentHeadlessStream(options = {}, deps = {}) {
     }
   }
 
+  // MCP servers may pause a tool flow with `elicitation/create`. Register the
+  // handler only after MCP resolution so the client is initialized before use.
+  // Reuse the structured Desktop/headless question channel, while preserving
+  // the MCP response shape (`action` + object `content`) at this boundary.
+  if (mcp?.mcpClient?.setElicitationHandler && interactiveQuestions) {
+    mcp.mcpClient.setElicitationHandler(async (request) => {
+      const { emitHooksV2Event } = await import("../lib/hooks-v2-producers.js");
+      emitHooksV2Event("MCPElicitation", {
+        server: request.server || null,
+        request_id: request.requestId ?? null,
+        message: request.message || "MCP server requests additional input",
+        requested_schema: request.requestedSchema || null,
+        session_id: sessionId,
+      });
+      const answer = await interactionAskUser({
+        question: request.message || "MCP server requests additional input",
+        timeoutMs: request.timeoutMs,
+        metadata: {
+          kind: "mcp_elicitation",
+          server: request.server,
+          requestId: request.requestId,
+          requestedSchema: request.requestedSchema || null,
+        },
+      });
+      if (answer == null) return { action: "cancel" };
+      return {
+        action: "accept",
+        content:
+          answer && typeof answer === "object" ? answer : { value: answer },
+      };
+    });
+  }
+
   // Seed MCP roots for --add-dir (roots/list_changed parity): advertise the full
   // workspace-root list to connected MCP servers when the stream session started
   // with extra roots. No --add-dir → workspaceRootDirs = [cwd] → no-op. Mirrors
@@ -1563,6 +1756,7 @@ export async function runAgentHeadlessStream(options = {}, deps = {}) {
     approvalGate,
     permissionRules,
     settingsHooks,
+    toolAdmission: options.toolAdmission || null,
     classifyAllShell,
     enabledToolNames,
     disabledTools,
@@ -1812,10 +2006,14 @@ export async function runAgentHeadlessStream(options = {}, deps = {}) {
     // exits plan mode. Every control answers with a `plan_update` event.
     if (parsed.plan) {
       const pm = getPlanModeManager();
-      const reviewMessage =
-        parsed.plan === "approve" || parsed.plan === "reject"
-          ? planReviewSystemMessage(parsed.planReview)
-          : null;
+      const reviewMessage = [
+        "approve",
+        "reject",
+        "revise",
+        "regenerate",
+      ].includes(parsed.plan)
+        ? planReviewSystemMessage(parsed.planReview)
+        : null;
       if (reviewMessage) {
         messages.push({ role: "system", content: reviewMessage });
       }
@@ -1848,7 +2046,47 @@ export async function runAgentHeadlessStream(options = {}, deps = {}) {
         });
         continue;
       }
-      if (parsed.plan === "approve") {
+      if (parsed.plan === "revise" || parsed.plan === "regenerate") {
+        if (!pm.isActive()) {
+          emit({
+            type: "plan_update",
+            ...planSnapshot(pm),
+            session_id: sessionId,
+            note: "nothing to revise",
+          });
+          continue;
+        }
+        const revision = pm.beginPlanRevision({
+          reason: parsed.plan,
+        });
+        if (revision.error) {
+          emit({
+            type: "plan_update",
+            ...planSnapshot(pm),
+            session_id: sessionId,
+            note: revision.error,
+          });
+          continue;
+        }
+        messages.push({
+          role: "system",
+          content:
+            `[PLAN REVISION REQUESTED] Plan ${revision.previousPlan.id} is frozen. ` +
+            `Create version ${revision.plan.version} as plan ${revision.plan.id}. ` +
+            (parsed.plan === "regenerate"
+              ? "Regenerate the plan from scratch using the review snapshot."
+              : "Revise the plan using the inline comments and reviewer notes."),
+        });
+        emit({
+          type: "plan_update",
+          ...planSnapshot(pm),
+          session_id: sessionId,
+        });
+        parsed.text =
+          parsed.plan === "regenerate"
+            ? "Regenerate the plan from the review feedback."
+            : "Revise the plan from the review feedback.";
+      } else if (parsed.plan === "approve") {
         if (!pm.isActive() || !(pm.currentPlan?.items?.length > 0)) {
           emit({
             type: "plan_update",
@@ -1858,10 +2096,17 @@ export async function runAgentHeadlessStream(options = {}, deps = {}) {
           });
           continue;
         }
-        pm.approvePlan();
+        const approval = pm.approvePlan({
+          permissionMode: options.permissionMode || "default",
+        });
+        const executionLock = approval.executionLock;
         messages.push({
           role: "system",
-          content: `[PLAN APPROVED] The user has approved your plan with ${pm.currentPlan.items.length} items. You can now use all tools including write_file, edit_file, run_shell, and run_skill. Execute the plan items in order.`,
+          content:
+            `[PLAN APPROVED] The user has approved your plan with ${pm.currentPlan.items.length} items. ` +
+            `Permission mode is ${executionLock.permissionMode}. The execution lock permits only: ` +
+            `${executionLock.allowedTools.join(", ")}. Execute the approved plan items in order; ` +
+            "request a plan revision before using any other tool.",
         });
         emit({
           type: "plan_update",
@@ -2166,7 +2411,14 @@ export async function runAgentHeadlessStream(options = {}, deps = {}) {
           // Resume-degenerate role merge for the first live model call only.
           mergeRoles: mergeRolesThisTurn,
         },
-        { runLoop, emit, costBudget, nextToolUseId, sideEffects },
+        {
+          runLoop,
+          emit,
+          costBudget,
+          nextToolUseId,
+          sideEffects,
+          turnNumber: turns,
+        },
       );
     } catch (err) {
       currentAbort = null;

package/src/runtime/mcp-config.js

@@ -34,6 +34,7 @@ import {
   isInJetbrainsContext,
 } from "../lib/jetbrains-bridge.js";
 import { collectPluginMcpServers } from "../lib/plugin-runtime/mcp.js";
+import { EventRuntimeStore } from "../lib/event-runtime-store.js";
 
 /**
  * Normalize a parsed config object into a `{ name: serverConfig }` map.
@@ -150,7 +151,9 @@ export function mcpAuthHint(url, errMessage) {
  */
 export async function setupMcpFromConfig(servers, deps = {}) {
   const writeErr = deps.writeErr || (() => {});
-  const createClient = deps.createClient || (() => new MCPClient());
+  const createClient =
+    deps.createClient ||
+    (() => new MCPClient({ eventRuntimeStore: deps.eventRuntimeStore || null }));
   servers = filterMcpServersByPolicy(servers, deps.mcpPolicy, writeErr);
 
   // `deps.into` lets a second batch (e.g. registered servers) accumulate into
@@ -191,6 +194,12 @@ export async function setupMcpFromConfig(servers, deps = {}) {
   if (deps.sessionId != null && typeof mcpClient.setSessionId === "function") {
     mcpClient.setSessionId(deps.sessionId);
   }
+  if (typeof mcpClient.setElicitationHandler === "function" &&
+      typeof deps.elicitationHandler === "function") {
+    mcpClient.setElicitationHandler(deps.elicitationHandler, {
+      timeoutMs: deps.elicitationTimeoutMs,
+    });
+  }
 
   for (const [name, cfg] of Object.entries(servers)) {
     // Skip a name already connected — an earlier batch (ad-hoc --mcp-config)
@@ -745,6 +754,11 @@ export async function resolveAgentMcp(args = {}, deps = {}) {
   const doIde = deps.loadIdeMcp || loadIdeMcp;
   const doPdh = deps.loadPdhMcp || loadPdhMcp;
   const doJetbrains = deps.loadJetbrainsMcp || loadJetbrainsMcp;
+  const runtimeEnv = args.env || process.env;
+  const eventRuntimeStore =
+    deps.eventRuntimeStore ||
+    args.eventRuntimeStore ||
+    (runtimeEnv.CC_EVENT_RUNTIME_DURABLE === "1" ? new EventRuntimeStore() : null);
   // Thread the agent session id down to setupMcpFromConfig so spawned stdio MCP
   // servers get CC_SESSION_ID / CLAUDE_CODE_SESSION_ID (Claude-Code parity).
   let mcpPolicy = deps.mcpPolicy || null;
@@ -759,6 +773,7 @@ export async function resolveAgentMcp(args = {}, deps = {}) {
   const fwd = {
     ...deps,
     ...(args.sessionId != null ? { sessionId: args.sessionId } : {}),
+    ...(eventRuntimeStore ? { eventRuntimeStore } : {}),
     mcpPolicy,
   };
   let result = null;

package/src/workers/background-agent-worker.js

@@ -25,6 +25,7 @@ import {
 } from "../lib/background-agent-supervisor.js";
 import { startBackgroundSessionServer } from "../lib/background-session-transport.js";
 import { idlePhaseFor } from "../lib/background-agent-phase.js";
+import { attachInteractionRequestHandler } from "../lib/background-interaction-resolver.js";
 
 const jobFile = process.argv[2];
 let job;
@@ -37,7 +38,10 @@ let phase = "turn";
 let turnCount = 0;
 let lastExit = { code: 0, signal: null };
 let transportState = null;
+let detachInteractionHandler = null;
 const promptQueue = [];
+// P0-2: 保存 pending 的交互请求，等 attach 客户端连接后转发
+const pendingInteractions = new Map();
 
 // Backpressure (Gap 4): an attached client can push prompts faster than
 // turns drain — an unbounded queue grows without limit and every entry is a
@@ -114,7 +118,7 @@ function startTurn(argv, promptText) {
   child = spawn(process.execPath, [job.cliEntry, ...argv], {
     cwd: job.cwd,
     env: { ...process.env, CC_BACKGROUND_AGENT_ID: job.id },
-    stdio: ["ignore", log.fd, log.fd],
+    stdio: ["ignore", log.fd, log.fd, "ipc"], // P0-2: 开启 IPC 通道用于人机交互
     windowsHide: true,
     // POSIX: give the agent child its own process group so an orphan reclaim
     // (worker crashed → supervisor kills the recorded agentPid) or /stop can
@@ -146,9 +150,71 @@ function startTurn(argv, promptText) {
     turn: turnCount,
     prompt: promptText || null,
   });
+
+  // P0-2: 挂载人机交互请求处理器，转发给 attach 客户端
+  detachInteractionHandler = attachInteractionRequestHandler(
+    child,
+    async (payload, msg) => {
+      const requestId = msg.requestId;
+      // 如果有 attach 客户端，转发给它等待响应
+      if (server && server.clientCount() > 0) {
+        return new Promise((resolve, reject) => {
+          const timer = setTimeout(
+            () => {
+              pendingInteractions.delete(requestId);
+              if (payload.defaultValue !== undefined) {
+                resolve(payload.defaultValue);
+              } else {
+                reject(new Error(`Interaction timed out: ${payload.question}`));
+              }
+            },
+            payload.timeoutMs || 5 * 60 * 1000,
+          );
+          timer.unref?.();
+          pendingInteractions.set(requestId, {
+            resolve,
+            reject,
+            timer,
+            payload,
+          });
+          server.broadcastInteractionRequest(requestId, payload);
+        });
+      }
+      // 没有客户端连接，返回默认值（如果有的话）
+      if (payload.defaultValue !== undefined) {
+        return payload.defaultValue;
+      }
+      // 没有默认值，记录到 state 让用户后续 attach 时能看到
+      mergeState({
+        pendingQuestion: {
+          intId: requestId,
+          requestId,
+          prompt: payload.prompt || payload.question,
+          hint: payload.hint,
+          options: payload.options,
+          multiSelect: payload.multiSelect,
+          timeoutMs: payload.timeoutMs,
+          askedAt: Date.now(),
+        },
+      });
+      // 等待用户 attach 后回复
+      return new Promise((resolve) => {
+        pendingInteractions.set(requestId, { resolve });
+      });
+    },
+  );
+
   child.on("exit", (code, signal) => {
     lastExit = { code, signal };
     child = null;
+    // 清理交互处理器
+    detachInteractionHandler?.();
+    detachInteractionHandler = null;
+    // 清理所有 pending 交互
+    for (const [, pending] of pendingInteractions) {
+      pending.reject?.(new Error("Agent exited"));
+    }
+    pendingInteractions.clear();
     server?.broadcast({ type: "turn-ended", turn: turnCount, exitCode: code });
     maybeContinue();
   });
@@ -259,6 +325,19 @@ async function main() {
           finalize(lastExit.code, lastExit.signal);
         }
       },
+      onInteractionResponse: ({ requestId, intId, answer, error }) => {
+        // Support both field names: requestId (from transport) and intId (legacy)
+        const resolvedId = requestId ?? intId;
+        const entry = pendingInteractions.get(resolvedId);
+        if (!entry) return;
+        pendingInteractions.delete(resolvedId);
+        clearTimeout(entry.timer);
+        if (error) {
+          entry.reject(new Error(error));
+        } else {
+          entry.resolve(answer);
+        }
+      },
     });
     transportState = { pipe: server.pipePath, token };
     mergeState({ transport: transportState });