pi-cursor-bridge 0.1.11 → 0.1.13

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "cursor-bridge",
-  "version": "5.8.1+codex.20260903121439",
+  "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.1. 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.1";
+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);
@@ -22963,10 +22963,7 @@ function createChatPanelUnavailableError(snapshot) {
   error2.uiDiagnostic = uiDiagnostic;
   return error2;
 }
-function exprFill(text) {
-  const js = JSON.stringify(text);
-  return `(function(){${INPUT_PICKER_BODY}const inp=pickInput();if(!inp)return 'NO_INPUT';inp.focus();try{const s=getSelection();const r=document.createRange();r.selectNodeContents(inp);s.removeAllRanges();s.addRange(r);}catch(e){}const ok=document.execCommand('insertText',false,${js});try{inp.dispatchEvent(new InputEvent('input',{bubbles:true,inputType:'insertText',data:${js}}));}catch(e){inp.dispatchEvent(new Event('input',{bubbles:true}));}return ok?(inp.innerText||'').slice(0,30):'EXEC_FAIL';})()`;
-}
+var EXPR_PREPARE_INPUT = `(function(){${INPUT_PICKER_BODY}const inp=pickInput();if(!inp)return 'NO_INPUT';inp.focus();try{const s=getSelection();const r=document.createRange();r.selectNodeContents(inp);s.removeAllRanges();s.addRange(r);}catch(e){}return 'READY';})()`;
 var EXPR_SNAP = `(function(){
   const md=[...document.querySelectorAll('.markdown-root,.aichat-container [class*=markdown]')]
     .filter(e=>e.offsetParent!==null&&!e.closest('.ui-model-picker__trigger,[class*=model-picker]'));
@@ -22977,14 +22974,17 @@ var EXPR_SNAP = `(function(){
   ${INPUT_PICKER_BODY}
   const input=pickInput();
   const inputText=String(input&&(input.innerText||input.textContent)||'').trim();
-  return JSON.stringify({messageCount:texts.length,replyLength:last.length,replyHash:hash,stop,inputTextLength:inputText.length});
+  const composer=input&&(input.closest('.composer-bar,.ui-prompt-input,.agent-prompt-input-root')||input.parentElement);
+  const sendButtons=composer?[...composer.querySelectorAll('button.ui-prompt-input-submit-button[data-state="send"],button.ui-prompt-input-submit-button[aria-label="Send message"],button[aria-label="Send"]')]
+    .filter(button=>button.offsetParent!==null&&!button.disabled&&button.closest('.composer-bar,.ui-prompt-input,.agent-prompt-input-root')===composer):[];
+  return JSON.stringify({messageCount:texts.length,replyLength:last.length,replyHash:hash,stop,inputTextLength:inputText.length,sendReady:sendButtons.length===1});
 })()`;
 var EXPR_CLICK_SEND = `(function(){${INPUT_PICKER_BODY}
   const input=pickInput();if(!input)return 'NO_INPUT';
-  const composer=input.closest('.composer-bar')||input.parentElement;
+  const composer=input.closest('.composer-bar,.ui-prompt-input,.agent-prompt-input-root')||input.parentElement;
   if(!composer)return 'NO_COMPOSER';
-  const buttons=[...composer.querySelectorAll('button.ui-prompt-input-submit-button[data-state="send"],button[aria-label="Send"]')]
-    .filter(button=>button.offsetParent!==null&&!button.disabled&&button.closest('.composer-bar')===input.closest('.composer-bar'));
+  const buttons=[...composer.querySelectorAll('button.ui-prompt-input-submit-button[data-state="send"],button.ui-prompt-input-submit-button[aria-label="Send message"],button[aria-label="Send"]')]
+    .filter(button=>button.offsetParent!==null&&!button.disabled&&button.closest('.composer-bar,.ui-prompt-input,.agent-prompt-input-root')===composer);
   if(buttons.length!==1)return buttons.length?'AMBIGUOUS_SEND':'NO_SEND';
   buttons[0].click();return 'CLICKED';
 })()`;
@@ -23102,7 +23102,7 @@ function exprClickBoundComposerStop(agentId) {
 var EXPR_FIND_NEWAGENT = `(function(){const b=[...document.querySelectorAll('button,[role=button],a.action-label,.codicon')].find(e=>{if(e.offsetParent===null||e.closest('.glass-sidebar-agent-menu-btn'))return false;const s=(e.getAttribute('aria-label')||'')+' '+(e.getAttribute('title')||'')+' '+(e.innerText||'');return /(?:^|\\s)New (?:Agent|Chat)(?:\\s|$)/i.test(s);});if(!b)return '';const r=b.getBoundingClientRect();return JSON.stringify({x:Math.round(r.x+r.width/2),y:Math.round(r.y+r.height/2)});})()`;
 var MODEL_PICKER_VISIBLE_BODY = `
   const visible=(node)=>!!(node&&(node.offsetParent!==null||(node.getClientRects&&node.getClientRects().length>0)));
-  const composers=[...document.querySelectorAll('.composer-bar[data-composer-id],.composer-bar,.ui-prompt-input-root')].filter(visible);
+  const composers=[...document.querySelectorAll('.composer-bar[data-composer-id],.composer-bar,.ui-prompt-input-root,.agent-prompt-input-root,.ui-prompt-input')].filter(visible);
   const composer=composers[composers.length-1]||document;
 `;
 var EXPR_MODEL_PICKER_TRIGGER = `(function(){
@@ -23158,15 +23158,23 @@ function selectModelPickerRow(rows, requested, kind = "model") {
   const candidates = (Array.isArray(rows) ? rows : []).filter((row) => row && row.disabled !== true && (kind === "any" || row.kind === kind)).map((row) => {
     const normalized = normalizeModelPickerText(row.text);
     let score = normalized === wanted ? 1e3 : 0;
-    if (!score && normalized.startsWith(wanted)) score = 800;
-    if (!score && wanted.startsWith(normalized)) score = 700;
-    if (!score && normalized.includes(wanted)) score = 600;
+    if (kind !== "parameter") {
+      if (!score && normalized.startsWith(wanted)) score = 800;
+      if (!score && wanted.startsWith(normalized)) score = 700;
+      if (!score && normalized.includes(wanted)) score = 600;
+    }
     return { row, score, distance: Math.abs(normalized.length - wanted.length) };
   }).filter((entry) => entry.score > 0).sort((a, b) => b.score - a.score || a.distance - b.distance);
   if (candidates.length === 0) return null;
   if (candidates.length > 1 && candidates[0].score === candidates[1].score && candidates[0].distance === candidates[1].distance) return null;
   return candidates[0].row;
 }
+function createModelSelectionError(message, failureClass, retryable, diagnostic = {}) {
+  const error2 = new Error(message);
+  error2.code = `CURSOR_MODEL_${String(failureClass || "PROBE_ERROR").toUpperCase()}`;
+  error2.modelSelectionFailure = { failureClass, retryable, ...diagnostic };
+  return error2;
+}
 var WORKSPACE_SECTION_BODY = `
   const headText=(el)=>String(el&&(el.innerText||el.textContent)||'').trim();
   const isNewAgentButton=(node)=>{
@@ -23682,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());
@@ -23704,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,
@@ -23738,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 : [],
@@ -23750,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();
@@ -23795,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}`);
       }
@@ -23814,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) {
@@ -23833,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,
@@ -23861,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();
@@ -23888,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";
@@ -23902,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 {
@@ -23910,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)
@@ -23938,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";
@@ -23992,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) };
     });
@@ -24002,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];
@@ -24063,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;
@@ -24257,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");
     }
@@ -24269,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) {
@@ -24285,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");
     }
@@ -24420,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;
@@ -24463,6 +24559,8 @@ var CursorBridge = class {
       targetUiFlavor: null,
       fallbackReason: null,
       result: null,
+      resultCollectedAt: null,
+      waitDeadlineAt: null,
       error: null,
       cancelRequested: false,
       cancelReason: null,
@@ -24821,7 +24919,7 @@ var CursorBridge = class {
         this._throwIfCancelledBeforeSend(options);
         await this._applyModelPreference(c, options.modelPreference, options);
         this._throwIfCancelledBeforeSend(options);
-        const filled = await evalJS(c, exprFill(prompt));
+        const filled = await this._fillPrompt(c, prompt, options);
         if (filled === "NO_INPUT") await this._throwChatPanelUnavailableAfterNoInput(c);
         if (filled === "NO_INPUT" || filled === "EXEC_FAIL") throw new Error("Failed to enter the query because the input state was invalid");
         await sleep2(450);
@@ -24941,25 +25039,83 @@ var CursorBridge = class {
     modelRow = selectModelPickerRow(expanded && expanded.rows, requestedModel, "model");
     return { snapshot: expanded, modelRow };
   }
-  async _selectedEffortRow(c, modelRow, effort) {
-    let snapshot = await this._readModelPickerRows(c);
-    let effortRow = selectModelPickerRow(snapshot.rows, cursorEffortUiValue(effort), "parameter");
-    if (!effortRow) {
-      snapshot = await this._openModelPickerControl(c, snapshot, "effort_control");
-      effortRow = selectModelPickerRow(snapshot.rows, cursorEffortUiValue(effort), "parameter");
+  _inspectModelPickerRows(snapshot, requested, kind) {
+    const rows = (snapshot && Array.isArray(snapshot.rows) ? snapshot.rows : []).filter((row) => row && row.disabled !== true && row.kind === kind);
+    const wanted = normalizeModelPickerText(requested);
+    const exact = rows.filter((row) => normalizeModelPickerText(row.text) === wanted);
+    return {
+      snapshot,
+      row: exact.length === 1 ? exact[0] : null,
+      ambiguous: exact.length > 1,
+      available: rows.map((row) => row.text)
+    };
+  }
+  async _waitForModelPickerMatch(c, requested, kind, job, options = {}) {
+    const timeoutMs = Math.max(0, Number(options.timeoutMs ?? 700));
+    const pollMs = Math.max(10, Number(options.pollMs ?? 100));
+    const stableMs = Math.max(0, Number(options.stableMs ?? 250));
+    const deadline = Date.now() + timeoutMs;
+    let stableSignature = null;
+    let stableSince = 0;
+    let last = this._inspectModelPickerRows({ open: false, rows: [] }, requested, kind);
+    do {
+      this._throwIfCancelledBeforeSend(job);
+      last = this._inspectModelPickerRows(await this._readModelPickerRows(c), requested, kind);
+      if (last.row) return { ...last, state: "matched" };
+      const signature = JSON.stringify(last.available);
+      if (last.available.length > 0) {
+        if (signature !== stableSignature) {
+          stableSignature = signature;
+          stableSince = Date.now();
+        } else if (Date.now() - stableSince >= stableMs) {
+          return { ...last, state: last.ambiguous ? "ambiguous" : "unsupported" };
+        }
+      } else {
+        stableSignature = null;
+        stableSince = 0;
+      }
+      if (Date.now() >= deadline) break;
+      await sleep2(Math.min(pollMs, Math.max(0, deadline - Date.now())));
+    } while (Date.now() <= deadline);
+    return { ...last, state: last.ambiguous ? "ambiguous" : "not_rendered" };
+  }
+  async _selectedEffortRow(c, modelRow, effort, job) {
+    const requested = cursorEffortUiValue(effort);
+    const snapshot = await this._readModelPickerRows(c);
+    const immediate = this._inspectModelPickerRows(snapshot, requested, "parameter");
+    if (immediate.row) return { ...immediate, state: "matched", attempts: ["visible"] };
+    const attempts = [];
+    const effortControl = (snapshot.rows || []).find((row) => row.kind === "effort_control" && row.disabled !== true);
+    if (effortControl) {
+      this._throwIfCancelledBeforeSend(job);
+      attempts.push("effort_control");
+      await this._clickModelPickerPoint(c, effortControl);
+      const result2 = await this._waitForModelPickerMatch(c, requested, "parameter", job, { timeoutMs: 700 });
+      if (result2.state !== "not_rendered") return { ...result2, attempts };
     }
-    if (effortRow) return effortRow;
+    this._throwIfCancelledBeforeSend(job);
+    attempts.push("model_hover");
     await this._hoverModelPickerPoint(c, modelRow);
-    await sleep2(400);
-    snapshot = await this._readModelPickerRows(c);
-    effortRow = selectModelPickerRow(snapshot.rows, cursorEffortUiValue(effort), "parameter");
-    if (!effortRow && modelRow && modelRow.hasSubmenu) {
+    let result = await this._waitForModelPickerMatch(c, requested, "parameter", job, { timeoutMs: 700 });
+    if (result.state !== "not_rendered") return { ...result, attempts };
+    if (modelRow && modelRow.hasSubmenu) {
+      this._throwIfCancelledBeforeSend(job);
+      attempts.push("model_click");
       await this._clickModelPickerPoint(c, modelRow);
-      await sleep2(350);
-      snapshot = await this._readModelPickerRows(c);
-      effortRow = selectModelPickerRow(snapshot.rows, cursorEffortUiValue(effort), "parameter");
+      result = await this._waitForModelPickerMatch(c, requested, "parameter", job, { timeoutMs: 1100 });
     }
-    return effortRow;
+    return { ...result, attempts };
+  }
+  async _waitForSelectedModelPickerRow(c, requested, kind, job, timeoutMs = 1500) {
+    const deadline = Date.now() + timeoutMs;
+    do {
+      this._throwIfCancelledBeforeSend(job);
+      const inspected = this._inspectModelPickerRows(await this._readModelPickerRows(c), requested, kind);
+      if (inspected.row && inspected.row.selected) return inspected.row;
+      if (Date.now() >= deadline) break;
+      await sleep2(Math.min(100, Math.max(0, deadline - Date.now())));
+    } while (Date.now() <= deadline);
+    return null;
   }
   async _applyModelPreference(c, preference, job) {
     if (!preference) {
@@ -24968,63 +25124,167 @@ var CursorBridge = class {
     }
     const requestedModel = String(preference.model || "").trim();
     const requestedEffort = preference.effort ? normalizeCursorModelEffort(preference.effort, "") : null;
-    const opened = await this._openModelPicker(c);
-    let located = await this._findModelPickerModel(c, opened, requestedModel);
-    let modelRow = located.modelRow;
-    if (!modelRow) {
-      throw new Error(`Configured Cursor model is unavailable or ambiguous: ${requestedModel}`);
-    }
-    let selectedEffortRow = null;
-    if (requestedEffort && modelRow.hasSubmenu) {
-      selectedEffortRow = await this._selectedEffortRow(c, modelRow, requestedEffort);
-      if (!selectedEffortRow) {
-        throw new Error(`Cursor model ${requestedModel} does not expose effort ${requestedEffort}`);
-      }
-      if (!selectedEffortRow.selected || !modelRow.selected) {
-        await this._clickModelPickerPoint(c, selectedEffortRow);
-        await sleep2(550);
-      }
-    } else if (!modelRow.selected) {
-      await this._clickModelPickerPoint(c, modelRow);
-      await sleep2(550);
-    }
-    let trigger = await this._readModelPickerTrigger(c);
-    if (!trigger.found || !normalizeModelPickerText(trigger.text).includes(normalizeModelPickerText(requestedModel))) {
-      const reopened = await this._openModelPicker(c);
-      located = await this._findModelPickerModel(c, reopened, requestedModel);
-      const selected = selectModelPickerRow(located.snapshot.rows.filter((row) => row.selected), requestedModel, "model");
-      if (!selected) throw new Error(`Cursor did not confirm configured model ${requestedModel}`);
-      modelRow = selected;
-    }
+    let modelRow = null;
     let effectiveEffort = null;
-    if (requestedEffort) {
-      const reopened = await this._openModelPicker(c);
-      located = await this._findModelPickerModel(c, reopened, requestedModel);
+    let primaryError = null;
+    try {
+      const opened = await this._openModelPicker(c);
+      let located = await this._findModelPickerModel(c, opened, requestedModel);
       modelRow = located.modelRow;
-      if (!modelRow) throw new Error(`Cursor model row disappeared while applying effort: ${requestedModel}`);
-      let effortRow = await this._selectedEffortRow(c, modelRow, requestedEffort);
-      if (!effortRow) {
-        throw new Error(`Cursor model ${requestedModel} does not expose effort ${requestedEffort}`);
+      if (!modelRow) {
+        throw createModelSelectionError(
+          `Configured Cursor model is unavailable or ambiguous: ${requestedModel}`,
+          "model_unavailable",
+          false,
+          { available: (located.snapshot.rows || []).filter((row) => row.kind === "model").map((row) => row.text) }
+        );
       }
-      if (!effortRow.selected) {
-        await this._clickModelPickerPoint(c, effortRow);
-        await sleep2(450);
+      let effortPickerReopened = false;
+      const resolveEffort = async () => {
+        let outcome = await this._selectedEffortRow(c, modelRow, requestedEffort, job);
+        if (!outcome.row && outcome.state === "not_rendered" && !effortPickerReopened) {
+          effortPickerReopened = true;
+          await this._closeModelPicker(c);
+          const reopened = await this._openModelPicker(c);
+          located = await this._findModelPickerModel(c, reopened, requestedModel);
+          modelRow = located.modelRow;
+          if (!modelRow) {
+            throw createModelSelectionError(
+              `Cursor model row disappeared while applying effort: ${requestedModel}`,
+              "model_unavailable",
+              true
+            );
+          }
+          outcome = await this._selectedEffortRow(c, modelRow, requestedEffort, job);
+          outcome.attempts = ["picker_reopen", ...outcome.attempts || []];
+        }
+        return outcome;
+      };
+      const throwEffortFailure = (outcome) => {
+        const failureClass = outcome.state === "ambiguous" ? "effort_ambiguous" : outcome.state === "unsupported" ? "effort_unsupported" : "effort_menu_not_rendered";
+        const message = failureClass === "effort_menu_not_rendered" ? `Cursor effort menu did not render for model ${requestedModel}` : failureClass === "effort_ambiguous" ? `Cursor model ${requestedModel} exposes ambiguous effort ${requestedEffort}` : `Cursor model ${requestedModel} does not expose effort ${requestedEffort}`;
+        throw createModelSelectionError(
+          message,
+          failureClass,
+          failureClass === "effort_menu_not_rendered",
+          { available: outcome.available || [], attempts: outcome.attempts || [] }
+        );
+      };
+      if (requestedEffort && modelRow.hasSubmenu) {
+        const selectedEffort = await resolveEffort();
+        if (!selectedEffort.row) throwEffortFailure(selectedEffort);
+        if (!selectedEffort.row.selected || !modelRow.selected) {
+          this._throwIfCancelledBeforeSend(job);
+          await this._clickModelPickerPoint(c, selectedEffort.row);
+          await sleep2(550);
+        }
+      } else if (!modelRow.selected) {
+        this._throwIfCancelledBeforeSend(job);
+        await this._clickModelPickerPoint(c, modelRow);
+        await sleep2(550);
       }
-      trigger = await this._readModelPickerTrigger(c);
-      const detailMatches = normalizeModelPickerText(`${trigger.detail || ""} ${trigger.text || ""}`).includes(normalizeModelPickerText(requestedEffort));
-      if (!detailMatches) {
-        const verify = await this._openModelPicker(c);
-        const verifiedModel = await this._findModelPickerModel(c, verify, requestedModel);
-        const selectedModel = verifiedModel.modelRow;
-        effortRow = await this._selectedEffortRow(c, selectedModel, requestedEffort);
+      let trigger2 = await this._readModelPickerTrigger(c);
+      if (!trigger2.found || !normalizeModelPickerText(trigger2.text).includes(normalizeModelPickerText(requestedModel))) {
+        const reopened = await this._openModelPicker(c);
+        located = await this._findModelPickerModel(c, reopened, requestedModel);
+        const selected = selectModelPickerRow(located.snapshot.rows.filter((row) => row.selected), requestedModel, "model");
+        if (!selected) {
+          throw createModelSelectionError(
+            `Cursor did not confirm configured model ${requestedModel}`,
+            "model_not_confirmed",
+            true
+          );
+        }
+        modelRow = selected;
+      }
+      if (requestedEffort) {
+        const reopened = await this._openModelPicker(c);
+        located = await this._findModelPickerModel(c, reopened, requestedModel);
+        modelRow = located.modelRow;
+        if (!modelRow) {
+          throw createModelSelectionError(
+            `Cursor model row disappeared while applying effort: ${requestedModel}`,
+            "model_unavailable",
+            true
+          );
+        }
+        const effortOutcome = await resolveEffort();
+        if (!effortOutcome.row) throwEffortFailure(effortOutcome);
+        let effortRow = effortOutcome.row;
+        if (!effortRow.selected) {
+          effortRow = await this._waitForSelectedModelPickerRow(
+            c,
+            cursorEffortUiValue(requestedEffort),
+            "parameter",
+            job
+          );
+        }
         if (!effortRow || !effortRow.selected) {
-          throw new Error(`Cursor did not confirm effort ${requestedEffort} for model ${requestedModel}`);
+          throw createModelSelectionError(
+            `Cursor did not confirm effort ${requestedEffort} for model ${requestedModel}`,
+            "effort_not_confirmed",
+            true
+          );
         }
+        effectiveEffort = requestedEffort;
+      }
+    } catch (error2) {
+      primaryError = error2 instanceof Error ? error2 : new Error(String(error2));
+      let failure = primaryError.modelSelectionFailure;
+      if (!failure) {
+        const pickerUnavailable = /model picker (?:is unavailable|did not open)/i.test(primaryError.message);
+        failure = {
+          failureClass: pickerUnavailable ? "picker_did_not_open" : "probe_error",
+          retryable: true
+        };
+      }
+      const diagnostic = {
+        configured: true,
+        applied: false,
+        requestedModel,
+        requestedEffort,
+        failureClass: failure.failureClass,
+        retryable: failure.retryable === true,
+        errorCode: primaryError.code || `CURSOR_MODEL_${String(failure.failureClass).toUpperCase()}`,
+        available: failure.available || [],
+        attempts: failure.attempts || [],
+        runtimeMode: this.runtimeMode,
+        lastError: primaryError.message,
+        failedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      primaryError.modelSelection = diagnostic;
+      if (job) job.modelSelection = diagnostic;
+      throw primaryError;
+    } finally {
+      try {
+        await this._closeModelPicker(c);
+      } catch (cleanupError) {
+        const message = cleanupError instanceof Error ? cleanupError.message : String(cleanupError);
+        if (!primaryError) {
+          const error2 = createModelSelectionError(message, "picker_cleanup_failed", true);
+          const diagnostic = {
+            configured: true,
+            applied: false,
+            requestedModel,
+            requestedEffort,
+            failureClass: "picker_cleanup_failed",
+            retryable: true,
+            errorCode: error2.code,
+            available: [],
+            attempts: [],
+            runtimeMode: this.runtimeMode,
+            lastError: message,
+            failedAt: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          error2.modelSelection = diagnostic;
+          if (job) job.modelSelection = diagnostic;
+          throw error2;
+        }
+        if (primaryError.modelSelection) primaryError.modelSelection.cleanupError = message;
+        if (job && job.modelSelection) job.modelSelection.cleanupError = message;
       }
-      effectiveEffort = requestedEffort;
     }
-    await this._closeModelPicker(c);
-    trigger = await this._readModelPickerTrigger(c);
+    const trigger = await this._readModelPickerTrigger(c);
     const result = {
       configured: true,
       applied: true,
@@ -25203,6 +25463,38 @@ var CursorBridge = class {
       }
     }
   }
+  async _fillPrompt(c, text, job, timeoutMs = 2500) {
+    const prepared = await evalJS(c, EXPR_PREPARE_INPUT);
+    if (prepared !== "READY") return prepared;
+    try {
+      await c.send("Input.insertText", { text: String(text) });
+    } catch {
+      return "EXEC_FAIL";
+    }
+    const deadline = Date.now() + timeoutMs;
+    let snapshot = {};
+    do {
+      this._throwIfCancelledBeforeSend(job);
+      try {
+        snapshot = JSON.parse(await evalJS(c, EXPR_SNAP));
+      } catch {
+      }
+      if (Number(snapshot.inputTextLength || 0) > 0 && snapshot.sendReady === true) {
+        return String(text).slice(0, 30);
+      }
+      if (Date.now() >= deadline) break;
+      await sleep2(Math.min(100, Math.max(0, deadline - Date.now())));
+    } while (Date.now() <= deadline);
+    const error2 = new Error("Cursor composer did not become send-ready after trusted input");
+    error2.code = "CURSOR_COMPOSER_NOT_SEND_READY";
+    error2.confirmedNotSent = true;
+    error2.composerDiagnostic = {
+      inputTextLength: Number(snapshot.inputTextLength || 0),
+      sendReady: snapshot.sendReady === true,
+      runtimeMode: this.runtimeMode
+    };
+    throw error2;
+  }
   async _confirmSubmission(c, baselineCount = 0, providerErrorBaseline = "") {
     const accepted = async () => {
       await this._throwIfNewProviderError(c, providerErrorBaseline);
@@ -25292,7 +25584,7 @@ var CursorBridge = class {
       this._throwIfCancelledBeforeSend(job);
       await this._applyModelPreference(c, job.modelPreference, job);
       this._throwIfCancelledBeforeSend(job);
-      const filled = await evalJS(c, exprFill(job.prompt));
+      const filled = await this._fillPrompt(c, job.prompt, job);
       if (filled === "NO_INPUT") await this._throwChatPanelUnavailableAfterNoInput(c);
       if (filled === "NO_INPUT" || filled === "EXEC_FAIL") throw new Error("Failed to enter the parallel_agent task");
       await sleep2(350);
@@ -25411,8 +25703,9 @@ 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 evalJS(c, exprFill(job.prompt));
+      const filled = await this._fillPrompt(c, job.prompt, job);
       if (filled === "NO_INPUT") await this._throwChatPanelUnavailableAfterNoInput(c);
       if (filled === "NO_INPUT" || filled === "EXEC_FAIL") {
         throw cursorSessionError("SESSION_INPUT_FAILED", "failed to enter the continued task");
@@ -25485,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;
@@ -25495,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;
@@ -25613,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) {
@@ -25672,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) {
@@ -25749,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) };
     }
@@ -26147,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) {
@@ -26217,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,
@@ -26255,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,
@@ -26264,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.";
@@ -26274,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 = "") {
@@ -26308,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,
@@ -26373,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." },
@@ -26401,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." }
@@ -26629,6 +26958,7 @@ export {
   EXPR_MODEL_PICKER_ROWS,
   EXPR_MODEL_PICKER_TRIGGER,
   EXPR_PAGE_CAPABILITIES,
+  EXPR_PREPARE_INPUT,
   EXPR_PROVIDER_ERROR,
   EXPR_VISIBLE,
   EXPR_VISIBLE_COMPOSER,
@@ -26644,7 +26974,6 @@ export {
   exprClickBoundComposerStop,
   exprClickSelectedAgentStop,
   exprCreateAgentForWorkspace,
-  exprFill,
   exprInspectWorkspaceRepository,
   exprOpenAgent,
   isConfirmedCompletedReply,

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.11",
+  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.11",
+  "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.1"
+    "embeddedProductVersion": "5.9.0"
   }
 }