pi-cursor-bridge 0.1.12 → 0.1.13

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "cursor-bridge",
-  "version": "5.8.2+codex.20260904092304",
+  "version": "5.9.0+codex.20260905074950",
   "description": "Evidence-backed Cursor Context Engine search and bounded Cursor Agent execution, including a UI-suppressed minimal runtime.",
   "author": {
     "name": "Vanyangyang"

package/README.md

@@ -10,6 +10,6 @@ pi install npm:pi-cursor-bridge
 
 Restart Pi after installation. Initialize the current project by asking Pi to initialize Cursor Bridge for the absolute project path, then use it normally. The package includes the `cce-routing` and `cursor-delegate` Skills and registers the native Cursor Bridge MCP tools directly in Pi.
 
-This Pi package embeds Cursor Bridge 5.8.2. Cursor must be installed and signed in. Current end-to-end compatibility claims remain scoped to the environments documented in the main repository.
+This Pi package embeds Cursor Bridge 5.9.0. Cursor must be installed and signed in. Current end-to-end compatibility claims remain scoped to the environments documented in the main repository.
 
 Full documentation: [English](https://github.com/Vanyangyang/cursor-bridge#readme) · [简体中文](https://github.com/Vanyangyang/cursor-bridge/blob/main/README.zh-CN.md)

package/dist/cursor-bridge.mjs

@@ -22604,7 +22604,7 @@ function updateCursorSessionRegistry(filePath, mutator, options = {}) {
 // server.mjs
 init_cursor_ensure_core();
 init_lifecycle_paths();
-var PLUGIN_VERSION = "5.8.2";
+var PLUGIN_VERSION = "5.9.0";
 var CDP_PORT2 = Number(process.env.CURSOR_BRIDGE_CDP_PORT || 9223);
 var ORIGIN = `http://localhost:${CDP_PORT2}`;
 var QUERY_TIMEOUT = Number(process.env.CURSOR_BRIDGE_TIMEOUT || 3e5);
@@ -23690,6 +23690,7 @@ var CursorBridge = class {
     this.projectPath = options.projectPath !== void 0 ? resolve7(String(options.projectPath)) : persistedWorkspace && persistedWorkspace.projectPath || null;
     this.workspaceSource = options.projectPath !== void 0 ? "constructor" : persistedWorkspace ? "persistent_init" : "auto_detect";
     this.workspaceUpdatedAt = persistedWorkspace && persistedWorkspace.updatedAt || null;
+    this.workspaceConfirmationRequired = this.workspaceKey === "default" && !!persistedWorkspace;
     this.modelPreferencesFile = options.modelPreferencesFile === null ? null : resolve7(options.modelPreferencesFile || resolveCursorModelPreferencesFile());
     this.modelPreferences = readCursorModelPreferences(this.modelPreferencesFile);
     this.sessionFile = options.sessionFile === null ? null : resolve7(options.sessionFile || resolveCursorSessionRegistryFile());
@@ -23712,6 +23713,8 @@ var CursorBridge = class {
     const resolvedProjectPath = this.projectPath || this._lastLifecycle && this._lastLifecycle.projectPath || null;
     return {
       workspaceKey: this.workspaceKey,
+      workspaceConfirmationRequired: this.workspaceConfirmationRequired,
+      workspaceBindingWarning: this.workspaceConfirmationRequired ? "This adapter has no host workspace identity. Run cursor_init with the intended project before using its shared saved binding." : null,
       projectPath: resolvedProjectPath,
       workspaceSource: this.projectPath ? this.workspaceSource : resolvedProjectPath ? "host_auto_detect" : this.workspaceSource,
       workspaceUpdatedAt: this.workspaceUpdatedAt,
@@ -23746,7 +23749,10 @@ var CursorBridge = class {
       agentLabel: session.agentLabel || null,
       turnIndex: Number(session.turnIndex || 0),
       activeTaskId: session.activeTaskId || null,
-      lastTask: session.lastTask || null,
+      lastTask: session.lastTask ? {
+        ...session.lastTask,
+        resultUnavailable: this.tasks.get(session.lastTask.taskId)?.result == null
+      } : null,
       modelPreference: session.modelPreference || null,
       readOnly: session.scopeEnvelope && session.scopeEnvelope.readOnly === true,
       allowedPaths: session.scopeEnvelope && Array.isArray(session.scopeEnvelope.allowedPaths) ? session.scopeEnvelope.allowedPaths : [],
@@ -23758,6 +23764,7 @@ var CursorBridge = class {
     };
   }
   _claimNewSession({ taskId, projectPath, readOnly, allowedPaths, modelPreference, requestId, timeoutMs }) {
+    this._ensureTaskCapacity();
     if (!this.sessionFile) throw cursorSessionError("SESSION_STORAGE_DISABLED", "persistent session storage is disabled");
     const sessionId = createCursorSessionId();
     const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -23803,6 +23810,7 @@ var CursorBridge = class {
       if (requestId && session.lastRequestId === requestId) {
         return { duplicate: true, session: { ...session } };
       }
+      this._ensureTaskCapacity();
       if (!sameSessionProject(session.projectPath, projectPath)) {
         throw cursorSessionError("SESSION_WORKSPACE_MISMATCH", `session is bound to ${session.projectPath}`);
       }
@@ -23822,6 +23830,15 @@ var CursorBridge = class {
       if (session.state !== "ready") {
         throw cursorSessionError("SESSION_NOT_READY", `state=${session.state}; recovery=${session.recoveryState || "none"}`);
       }
+      if (session.lastTask?.status === "completed" && !session.lastTask.resultCollectedAt && this.tasks.has(session.lastTask.taskId)) {
+        throw cursorSessionError("SESSION_RESULT_UNCOLLECTED", `read cursor_status(task_id=${session.lastTask.taskId}) before continuing`);
+      }
+      if (session.lastTask?.status === "completed" && !session.lastTask.resultCollectedAt && !this.tasks.has(session.lastTask.taskId) && session.recoveryState !== "reconciled_result_uncollected") {
+        throw cursorSessionError("SESSION_RECONCILE_REQUIRED", "the prior reply was not read before this adapter restarted; reconcile the exact Agent before continuing");
+      }
+      if (session.recoveryState === "reconciled_result_uncollected" && (Number(session.turnIndex) <= 1 || session.responseBaseline)) {
+        throw cursorSessionError("SESSION_RESULT_UNCOLLECTED", "collect the interrupted reply with cursor_session_control(action=collect_result) before continuing");
+      }
       if (!session.agentId) throw cursorSessionError("SESSION_AGENT_NOT_BOUND", sessionId);
       const envelope = session.scopeEnvelope || { readOnly: false, allowedPaths: [] };
       if (envelope.readOnly === true) {
@@ -23841,6 +23858,7 @@ var CursorBridge = class {
       session.epoch = epoch;
       session.activeTaskId = taskId;
       session.lastRequestId = requestId || null;
+      delete session.responseBaseline;
       session.lease = {
         taskId,
         instanceId: this.sessionInstanceId,
@@ -23869,6 +23887,20 @@ var CursorBridge = class {
     });
     job.sessionState = "busy";
   }
+  _persistSessionResponseBaseline(job) {
+    if (!job.sessionId) return;
+    const baseline = job.responseBaseline;
+    if (!baseline || !["messageCount", "replyLength", "replyHash"].every((key) => Number.isFinite(baseline[key]))) {
+      throw cursorSessionError("SESSION_BASELINE_UNAVAILABLE", "a numeric response baseline is required before sending");
+    }
+    updateCursorSessionRegistry(this.sessionFile, (registry2) => {
+      const session = registry2.sessions[job.sessionId];
+      if (!session || session.activeTaskId !== job.id || Number(session.epoch) !== Number(job.sessionEpoch)) {
+        throw cursorSessionError("SESSION_STALE_SENDER", "the sender no longer owns this session turn");
+      }
+      session.responseBaseline = { messageCount: baseline.messageCount, replyLength: baseline.replyLength, replyHash: baseline.replyHash };
+    });
+  }
   _settleSessionJob(job, outcome, options = {}) {
     if (!job || !job.sessionId || !this.sessionFile) return;
     const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -23896,6 +23928,7 @@ var CursorBridge = class {
       }
       session.activeTaskId = null;
       session.lease = null;
+      if (outcome !== "completed") delete session.responseBaseline;
       session.recoveryState = null;
       session.attention = null;
       session.state = session.agentId ? "ready" : "failed";
@@ -23910,6 +23943,19 @@ var CursorBridge = class {
       job.sessionError = error2 instanceof Error ? error2.message : String(error2);
     }
   }
+  _markTaskResultCollected(job) {
+    if (!isTerminalTask(job) || job.result == null || job.resultCollectedAt) return;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    if (job.sessionId && this.sessionFile) {
+      updateCursorSessionRegistry(this.sessionFile, (registry2) => {
+        const session = registry2.sessions[job.sessionId];
+        if (!session || session.lastTask?.taskId !== job.id || Number(session.epoch) !== Number(job.sessionEpoch)) return;
+        session.lastTask.resultCollectedAt = now;
+        delete session.responseBaseline;
+      });
+    }
+    job.resultCollectedAt = now;
+  }
   sessionStatus(sessionId) {
     const session = this._readSession(sessionId);
     return {
@@ -23918,17 +23964,28 @@ var CursorBridge = class {
       ...session ? this._sessionView(session) : { sessionId: String(sessionId || "") }
     };
   }
-  async _reconcileSession(sessionId) {
+  async _reconcileSession(sessionId, { collectResult = false } = {}) {
+    const action = collectResult ? "collect_result" : "reconcile";
     const initial = this._readSession(sessionId);
-    if (!initial) return { found: false, action: "reconcile", sessionId };
-    if (initial.state === "ready" || initial.state === "closed" || initial.state === "failed") {
-      return { found: true, changed: false, action: "reconcile", ...this._sessionView(initial) };
+    if (!initial) return { found: false, action, sessionId };
+    if (collectResult && initial.recoveryState === "reconciled_result_collected") {
+      return { found: true, changed: false, action, ...this._sessionView(initial), state: "already_collected", resultPersisted: false };
+    }
+    const unreadAfterRestart = initial.lastTask?.status === "completed" && !initial.lastTask.resultCollectedAt && !this.tasks.has(initial.lastTask.taskId);
+    if (!collectResult && initial.state === "ready" && !unreadAfterRestart || initial.state === "closed" || initial.state === "failed") {
+      return { found: true, changed: false, action, ...this._sessionView(initial) };
+    }
+    if (collectResult && (initial.state !== "ready" || initial.activeTaskId || initial.lastTask?.status !== "completed" || initial.recoveryState !== "reconciled_result_uncollected")) {
+      throw cursorSessionError("SESSION_RESULT_NOT_READY", "reconcile a completed turn before collecting its reply");
+    }
+    if (collectResult && Number(initial.turnIndex) > 1 && !initial.responseBaseline) {
+      throw cursorSessionError("SESSION_RESULT_BASELINE_UNAVAILABLE", "this older interrupted turn has no reply signature; inspect the original Agent manually before continuing");
     }
     if (!initial.agentId) {
       return {
         found: true,
         changed: false,
-        action: "reconcile",
+        action,
         state: "agent_missing",
         attention: "No exact agentId is available. Confirm the Cursor task state manually before explicit abandon.",
         ...this._sessionView(initial)
@@ -23946,21 +24003,44 @@ var CursorBridge = class {
       effectiveExecution: "parallel_agent",
       lastRecoveryAt: null,
       recoveryState: null,
-      error: null
+      error: null,
+      responseBaseline: initial.responseBaseline || null
     };
     const observed = await this._readStableParallelEntry(probe);
+    let collectedReply;
+    if (collectResult) {
+      if (!observed.stable || !observed.entry || observed.entry.showSpinner || classifyParallelTerminalIcon(observed.entry.icon) !== "completed") {
+        throw cursorSessionError("SESSION_RESULT_NOT_READY", "the exact Agent must have a stable completed state");
+      }
+      try {
+        collectedReply = await this._withUiLock(() => this._collectParallelAgent(probe));
+      } catch (error2) {
+        if (probe.uiDiagnostic && error2 && typeof error2 === "object") error2.uiDiagnostic = probe.uiDiagnostic;
+        throw error2;
+      }
+      if (!String(collectedReply || "").trim()) throw cursorSessionError("SESSION_RESULT_UNAVAILABLE", "no final reply was collected");
+    }
     let result;
     updateCursorSessionRegistry(this.sessionFile, (registry2) => {
       const session = registry2.sessions[sessionId];
       if (!session) {
-        result = { found: false, action: "reconcile", sessionId };
+        result = { found: false, action, sessionId };
         return;
       }
-      if (Number(session.epoch || 0) !== Number(initial.epoch || 0) || session.activeTaskId !== initial.activeTaskId) {
-        result = { found: true, changed: false, action: "reconcile", state: "stale_observation", ...this._sessionView(session) };
+      if (Number(session.epoch || 0) !== Number(initial.epoch || 0) || session.activeTaskId !== initial.activeTaskId || session.state !== initial.state) {
+        result = { found: true, changed: false, action, state: "stale_observation", ...this._sessionView(session) };
         return;
       }
       const now = (/* @__PURE__ */ new Date()).toISOString();
+      if (collectResult) {
+        session.lastTask.resultCollectedAt = now;
+        delete session.responseBaseline;
+        session.recoveryState = "reconciled_result_collected";
+        session.attention = null;
+        session.updatedAt = now;
+        result = { found: true, changed: true, action, ...this._sessionView(session), result: collectedReply, resultPersisted: false, uiDiagnostic: probe.uiDiagnostic || null };
+        return;
+      }
       if (!observed.stable || !observed.entry) {
         session.state = "needs_attention";
         session.recoveryState = probe.recoveryState || "history_unavailable";
@@ -24000,7 +24080,8 @@ var CursorBridge = class {
       session.lease = null;
       session.state = "ready";
       session.recoveryState = terminalClass === "completed" ? "reconciled_result_uncollected" : null;
-      session.attention = terminalClass === "completed" ? "The interrupted turn completed in Cursor, but its reply was not persisted. Inspect that Agent before the next turn." : null;
+      session.attention = terminalClass === "completed" ? Number(session.turnIndex) > 1 && !session.responseBaseline ? "This older interrupted turn has no saved reply signature. Inspect the original Agent manually before continuing; automatic collection cannot identify its reply safely." : "The interrupted turn completed in Cursor, but its reply was not persisted. Use cursor_session_control(action=collect_result) before the next turn." : null;
+      if (terminalClass !== "completed") delete session.responseBaseline;
       session.updatedAt = now;
       result = { found: true, changed: true, action: "reconcile", state: terminalClass, ...this._sessionView(session) };
     });
@@ -24010,10 +24091,11 @@ var CursorBridge = class {
     const id = String(sessionId || "").trim();
     if (!id) throw cursorSessionError("SESSION_REQUIRED", "session_id must not be empty");
     const action = String(options.action || "").trim().toLowerCase();
-    if (!["reconcile", "close", "forget", "abandon"].includes(action)) {
-      throw cursorSessionError("SESSION_ACTION_UNSUPPORTED", "expected reconcile, close, forget, or abandon");
+    if (!["reconcile", "collect_result", "close", "forget", "abandon"].includes(action)) {
+      throw cursorSessionError("SESSION_ACTION_UNSUPPORTED", "expected reconcile, collect_result, close, forget, or abandon");
     }
     if (action === "reconcile") return this._reconcileSession(id);
+    if (action === "collect_result") return this._reconcileSession(id, { collectResult: true });
     let result;
     updateCursorSessionRegistry(this.sessionFile, (registry2) => {
       const session = registry2.sessions[id];
@@ -24071,6 +24153,7 @@ var CursorBridge = class {
     }
     const previousProjectPath = this.projectPath || this._lastLifecycle && this._lastLifecycle.projectPath || null;
     const saved = writeWorkspaceBinding(this.workspaceFile, this.workspaceKey, projectPath);
+    this.workspaceConfirmationRequired = false;
     this.projectPath = saved.projectPath;
     this.workspaceSource = "persistent_init";
     this.workspaceUpdatedAt = saved.updatedAt;
@@ -24265,6 +24348,7 @@ var CursorBridge = class {
     const text = String(query || "").trim();
     if (!text) throw new Error("query must not be empty");
     if (text.length > 2e4) throw new Error("query exceeds the 20,000-character limit");
+    this._assertWorkspaceConfirmed();
     if (this._hasGlobalReservation()) {
       throw new Error("A global Cursor reservation has an unconfirmed Stop state; resolve blockingTaskIds from cursor_status first");
     }
@@ -24277,7 +24361,9 @@ var CursorBridge = class {
       allowedPaths: [],
       modelPreference: this._modelPreferenceFor("cce")
     });
-    return normalizeCceSearchResult(await job.promise);
+    const result = normalizeCceSearchResult(await job.promise);
+    this._markTaskResultCollected(job);
+    return result;
   }
   // Unlisted compatibility aliases for clients that cached the pre-3.0 tool surface.
   async search(query) {
@@ -24293,6 +24379,7 @@ var CursorBridge = class {
     const text = String(prompt || "").trim();
     if (!text) throw new Error("prompt must not be empty");
     if (text.length > 1e5) throw new Error("prompt exceeds the 100,000-character limit");
+    this._assertWorkspaceConfirmed();
     if (this._hasGlobalReservation()) {
       throw new Error("A global Cursor reservation has an unconfirmed Stop state; no new task may be submitted until it is explicitly recovered or released");
     }
@@ -24428,6 +24515,7 @@ var CursorBridge = class {
     return `cursor-${Date.now().toString(36)}-${this.nextTaskId++}`;
   }
   _enqueue(kind, prompt, options) {
+    this._ensureTaskCapacity();
     const id = options.taskId || this._nextTaskId();
     let resolvePromise;
     let rejectPromise;
@@ -24471,6 +24559,8 @@ var CursorBridge = class {
       targetUiFlavor: null,
       fallbackReason: null,
       result: null,
+      resultCollectedAt: null,
+      waitDeadlineAt: null,
       error: null,
       cancelRequested: false,
       cancelReason: null,
@@ -25613,6 +25703,7 @@ var CursorBridge = class {
       await this._applyModelPreference(c, job.modelPreference, job);
       this._throwIfCancelledBeforeSend(job);
       job.responseBaseline = await this._captureSessionResponseBaseline(c);
+      this._persistSessionResponseBaseline(job);
       const providerErrorBaseline = providerErrorSignature(await this._readProviderError(c));
       const filled = await this._fillPrompt(c, job.prompt, job);
       if (filled === "NO_INPUT") await this._throwChatPanelUnavailableAfterNoInput(c);
@@ -25687,8 +25778,16 @@ var CursorBridge = class {
     job.monitorPromise = monitorPromise;
     return true;
   }
+  _taskWaitDeadline(job, timeoutMs = job?.timeoutMs) {
+    if (!job) return Date.now() + timeoutMs;
+    if (!Number.isFinite(job.waitDeadlineAt)) {
+      const sentAt = Date.parse(job.sentAt || "");
+      job.waitDeadlineAt = (Number.isFinite(sentAt) ? sentAt : Date.now()) + timeoutMs;
+    }
+    return job.waitDeadlineAt;
+  }
   async _monitorParallelAgent(job, generation) {
-    const started = Date.now();
+    const deadline = this._taskWaitDeadline(job);
     let sawGenerating = false;
     let completedStable = 0;
     let missingPolls = 0;
@@ -25697,7 +25796,7 @@ var CursorBridge = class {
     let lastTerminalErrorSignature = "";
     let collectionAttempts = 0;
     let lastCollectionError = "";
-    while (Date.now() - started < job.timeoutMs) {
+    while (Date.now() < deadline) {
       if (!this._monitorOwns(job, generation)) return;
       await sleep2(1400);
       if (!this._monitorOwns(job, generation)) return;
@@ -25815,51 +25914,63 @@ var CursorBridge = class {
     }
     throw new Error(`After opening ${agentId}, it could not be confirmed as the selected Agent`);
   }
+  async _withRestoredAgentSelection(c, job, operation) {
+    const entries = await this._readAgentEntries(c, true);
+    const previousSelectedId = (entries.find((entry) => entry.isSelected) || {}).id || null;
+    try {
+      return await operation();
+    } finally {
+      if (previousSelectedId && previousSelectedId !== job.agentId) {
+        try {
+          const opened = await this._requestExactAgentSelection(c, previousSelectedId);
+          if (opened !== "OPENED") throw new Error(`Unable to restore ${previousSelectedId}: ${opened}`);
+          await this._waitForSelectedAgent(c, previousSelectedId);
+        } catch (error2) {
+          job.uiDiagnostic = { ...job.uiDiagnostic, selectionRestore: { state: "failed", agentId: previousSelectedId, detail: String(error2.message).slice(0, 500) } };
+        }
+      }
+    }
+  }
   async _collectParallelAgent(job) {
     const page = await findPage({ targetId: job.targetId, purpose: "parallel_agent" });
     const c = makeClient(page.webSocketDebuggerUrl);
     await c.ready;
-    let previousSelectedId = null;
     try {
-      const entries = await this._readAgentEntries(c, true);
-      previousSelectedId = (entries.find((e) => e.isSelected) || {}).id || null;
-      const opened = await evalJS(c, exprOpenAgent(job.agentId));
-      if (opened !== "OPENED") throw new Error(`Unable to open ${job.agentId}: ${opened}`);
-      await this._closeHistory(c);
-      await this._waitForSelectedAgent(c, job.agentId);
-      let answer = "";
-      let lastKey = "";
-      let stable = 0;
-      for (let i = 0; i < 80; i++) {
-        const snap = await this._readResponseSnapshot(c);
-        const candidate = String(await evalJS(c, EXPR_EXTRACT) || "").trim();
-        const hasNewTurn = isSessionTurnReplyReady(job.responseBaseline, snap);
-        if (candidate && hasNewTurn && Number(snap.stop || 0) === 0) {
-          const key = `${snap.replyLength}:${snap.replyHash}`;
-          if (key === lastKey) stable++;
-          else {
-            lastKey = key;
-            stable = 0;
-          }
-          if (stable >= 1) {
-            answer = candidate;
-            break;
+      return await this._withRestoredAgentSelection(c, job, async () => {
+        const opened = await evalJS(c, exprOpenAgent(job.agentId));
+        if (opened !== "OPENED") throw new Error(`Unable to open ${job.agentId}: ${opened}`);
+        await this._closeHistory(c);
+        await this._waitForSelectedAgent(c, job.agentId);
+        let answer = "";
+        let lastKey = "";
+        let stable = 0;
+        for (let i = 0; i < 80; i++) {
+          const snap = await this._readResponseSnapshot(c);
+          const candidate = String(await evalJS(c, EXPR_EXTRACT) || "").trim();
+          const hasNewTurn = isSessionTurnReplyReady(job.responseBaseline, snap);
+          if (candidate && hasNewTurn && Number(snap.stop || 0) === 0) {
+            const key = `${snap.replyLength}:${snap.replyHash}`;
+            if (key === lastKey) stable++;
+            else {
+              lastKey = key;
+              stable = 0;
+            }
+            if (stable >= 1) {
+              answer = candidate;
+              break;
+            }
           }
+          await sleep2(300);
         }
-        await sleep2(300);
-      }
-      if (!answer) throw new Error(`${job.agentId} was opened, but no final assistant reply was found`);
-      if (previousSelectedId && previousSelectedId !== job.agentId) {
-        if (await this._ensureHistoryOpen(c)) {
-          await evalJS(c, exprOpenAgent(previousSelectedId));
-          await this._closeHistory(c);
-          await this._waitForSelectedAgent(c, previousSelectedId);
-        }
-      }
-      return answer;
+        if (!answer) throw new Error(`${job.agentId} was opened, but no final assistant reply was found`);
+        return answer;
+      });
     } finally {
-      await this._closeHistory(c);
-      c.close();
+      try {
+        await this._closeHistory(c);
+      } finally {
+        c.close();
+      }
     }
   }
   _reapWithoutResult(job, error2, evidence) {
@@ -25874,7 +25985,6 @@ var CursorBridge = class {
     job.terminalEvidence = evidence || "stable_completed_history_icon";
     job.recoveryState = "terminal_result_uncollected";
     job.reservationScope = uncertainSubmissionReservationScope(job, error2);
-    job.recoveryState = error2.recoveryState || "monitoring_uncertain_submission";
     this._safeSettleSessionJob(job, "terminal_result_uncollected", { needsAttention: true });
   }
   _abandonJob(job, reason) {
@@ -25951,6 +26061,7 @@ var CursorBridge = class {
       job.phase = "running";
       job.error = null;
       job.recoveryState = "monitoring";
+      if (options.reattach !== false && !job.cancelRequested) job.waitDeadlineAt = Date.now() + job.timeoutMs;
       const attached = options.reattach !== false && !job.cancelRequested && this._startParallelMonitor(job);
       return { changed: attached, state: "running", monitorReattached: attached, task: this._taskView(job, true) };
     }
@@ -26349,12 +26460,12 @@ var CursorBridge = class {
     }).catch((e) => console.error("\u26A0\uFE0F Failed to restore the original Cursor Agent: " + e.message));
   }
   async _waitComplete(c, timeoutMs = QUERY_TIMEOUT, baselineCount = 0, job = null, providerErrorBaseline = "") {
-    const start = Date.now();
+    const deadline = this._taskWaitDeadline(job, timeoutMs);
     const INTERVAL = 1e3;
     let sawStop = false;
     let lastReplyKey = "", stableReply = 0;
     await sleep2(1200);
-    while (Date.now() - start < timeoutMs) {
+    while (Date.now() < deadline) {
       await this._throwIfNewProviderError(c, providerErrorBaseline);
       if (job && job.cancelRequested) {
         if (job.agentId) {
@@ -26419,6 +26530,7 @@ var CursorBridge = class {
     throw new Error(`Cursor task timed out (${timeoutMs}ms) before generation was confirmed stopped with a complete assistant reply${taskHint}`);
   }
   _taskView(job, includeResult = false) {
+    if (includeResult) this._markTaskResultCollected(job);
     const view = {
       taskId: job.id,
       kind: job.kind,
@@ -26457,6 +26569,8 @@ var CursorBridge = class {
       monitorAttached: job.monitorAttached,
       monitorGeneration: job.monitorGeneration,
       resultUnavailable: job.resultUnavailable,
+      resultCollectedAt: job.resultCollectedAt || null,
+      waitDeadlineAt: Number.isFinite(job.waitDeadlineAt) ? new Date(job.waitDeadlineAt).toISOString() : null,
       terminalEvidence: job.terminalEvidence,
       providerError: job.providerError,
       uiDiagnostic: job.uiDiagnostic,
@@ -26466,7 +26580,7 @@ var CursorBridge = class {
       blocksFifo: this.activeParallel.has(job.id) && !isTerminalTask(job),
       blocksAll: this.activeParallel.has(job.id) && !isTerminalTask(job) && job.reservationScope === "global"
     };
-    if (includeResult || isTerminalTask(job)) view.result = job.result;
+    if (includeResult) view.result = job.result;
     if (job.phase === "orphaned") {
       if (job.recoveryState === "terminal_result_uncollected") {
         view.attention = "Agent History proves that the underlying task ended, but its final reply has not been collected. Retry with reap, or explicitly abandon only if a missing reply is acceptable.";
@@ -26476,11 +26590,22 @@ var CursorBridge = class {
     }
     return view;
   }
-  _trimTasks() {
-    if (this.tasks.size <= 50) return;
+  _assertWorkspaceConfirmed() {
+    if (this.workspaceConfirmationRequired) {
+      throw new Error("WORKSPACE_CONFIRMATION_REQUIRED: the saved default binding has no host workspace identity. Run cursor_init with the intended project before submitting work.");
+    }
+  }
+  _ensureTaskCapacity() {
+    this._trimTasks(49);
+    if (this.tasks.size >= 50) {
+      throw new Error("TASK_RETENTION_FULL: 50 tasks are active or have unread replies. Read unreadResultTaskIds with cursor_status(task_id), or wait for active tasks before submitting more work.");
+    }
+  }
+  _trimTasks(limit = 50) {
+    if (this.tasks.size <= limit) return;
     for (const [id, job] of this.tasks) {
-      if (isTerminalTask(job)) this.tasks.delete(id);
-      if (this.tasks.size <= 50) break;
+      if (isTerminalTask(job) && (job.result == null || job.resultCollectedAt)) this.tasks.delete(id);
+      if (this.tasks.size <= limit) break;
     }
   }
   async status(taskId = "") {
@@ -26510,6 +26635,8 @@ var CursorBridge = class {
       blockedQueuedCount: this.activeParallel.size > 0 ? this.queue.filter((job) => globalBlocked || job.effectiveExecution !== "parallel_agent").length : 0,
       activeParallel: [...this.activeParallel.values()].map((job) => this._taskView(job)),
       recentTasks: [...this.tasks.values()].slice(-10).map((job) => this._taskView(job)),
+      unreadResultTaskIds: [...this.tasks.values()].filter((job) => isTerminalTask(job) && job.result != null && !job.resultCollectedAt).map((job) => job.id),
+      taskRetentionLimit: 50,
       cdpPort: CDP_PORT2,
       lifecycle: this._lastLifecycle || {
         adapterPid: process.pid,
@@ -26575,7 +26702,7 @@ function buildToolDefinitions(bridgeInstance) {
           background: { type: "boolean", default: true, description: "When true, return the task ID immediately. When false, wait for the task to finish or need attention." },
           execution: { type: "string", enum: ["fifo", "parallel_agent"], default: "fifo", description: "fifo is the first-in, first-out serial queue and runs one task at a time in a clean chat. parallel_agent creates a separate top-level Cursor Agent." },
           read_only: { type: "boolean", default: false, description: "Set true when Cursor must not change the workspace." },
-          timeout_ms: { type: "integer", minimum: 3e4, maximum: 9e5, default: 6e5, description: "How long to wait before timing out, in milliseconds. The default is 10 minutes." },
+          timeout_ms: { type: "integer", minimum: 3e4, maximum: 9e5, default: 6e5, description: "One monitoring budget after submission, shared by FIFO and automatic Agent recovery. Expiry needs attention; it does not cancel work. Explicit reap may start a new budget. The default is 10 minutes." },
           allowed_paths: { type: "array", items: { type: "string" }, description: "Workspace-relative paths Cursor may write. Parallel write tasks require non-overlapping paths. This declaration is not a filesystem sandbox." },
           completion_contract: { type: "string", description: "Optional acceptance checks or a required final-report format." },
           session_mode: { type: "string", enum: [...CURSOR_SESSION_MODES], default: "isolated", description: "isolated preserves the current clean-task behavior. create starts an update-safe persistent session. continue sends one new turn to the exact session_id." },
@@ -26603,12 +26730,12 @@ function buildToolDefinitions(bridgeInstance) {
     },
     {
       name: "cursor_session_control",
-      description: "Recover, close, or forget one exact persistent cursor_do session. reconcile checks the exact Agent twice and never resends. close prevents future sends but does not stop or delete the Cursor Agent. An active or uncertain session cannot be closed. abandon is the explicit last resort when exact stop evidence is unavailable. forget requires confirm=true and is allowed only after close; it deletes only the Bridge mapping.",
+      description: "Recover, collect a reply, close, or forget one exact persistent cursor_do session. reconcile checks the exact Agent twice and never resends. collect_result reads the completed reconciled turn from that Agent without sending a prompt; it may temporarily select that Agent. close prevents future sends but does not stop or delete the Cursor Agent. An active or uncertain session cannot be closed. abandon is the explicit last resort when exact stop evidence is unavailable. forget requires confirm=true and is allowed only after close; it deletes only the Bridge mapping.",
       inputSchema: {
         type: "object",
         properties: {
           session_id: { type: "string", description: "The exact session ID returned by cursor_do(session_mode=create)." },
-          action: { type: "string", enum: ["reconcile", "close", "forget", "abandon"], description: "reconcile reads the exact Agent state; close ends safe continuity; forget removes a closed mapping; abandon releases an uncertain mapping without stop proof." },
+          action: { type: "string", enum: ["reconcile", "collect_result", "close", "forget", "abandon"], description: "reconcile reads the exact Agent state; collect_result retrieves its completed latest turn before continuing; close ends safe continuity; forget removes a closed mapping; abandon releases an uncertain mapping without stop proof." },
           confirm: { type: "boolean", default: false, description: "Required for forget and abandon." },
           reason: { type: "string", description: "Required and non-empty for abandon." },
           acknowledge_may_still_write: { type: "boolean", default: false, description: "Required for abandon; acknowledges that the underlying Cursor Agent may still run or write." }

package/extensions/index.ts

@@ -10,7 +10,7 @@ const hostWorkspaceId = hostCwd.replace(/\\/g, "/").toLowerCase();
 export default createStdioMcpExtension({
   label: "Cursor Bridge",
   clientName: "pi-cursor-bridge",
-  packageVersion: "0.1.12",
+  packageVersion: "0.1.13",
   serverName: "cursor-bridge",
   serverScript: join(packageRoot, "dist", "cursor-bridge.mjs"),
   cwd: hostCwd,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-cursor-bridge",
-  "version": "0.1.12",
+  "version": "0.1.13",
   "description": "Use Cursor Context Engine and bounded, explicitly continuous Cursor Agent execution from the Pi coding agent.",
   "type": "module",
   "license": "MIT",
@@ -47,6 +47,6 @@
   },
   "piPackage": {
     "embeddedProduct": "Cursor Bridge",
-    "embeddedProductVersion": "5.8.2"
+    "embeddedProductVersion": "5.9.0"
   }
 }