pi-cursor-bridge 0.1.11 → 0.1.12

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "cursor-bridge",
-  "version": "5.8.1+codex.20260903121439",
+  "version": "5.8.2+codex.20260904092304",
   "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.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.
 
 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.8.2";
 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)=>{
@@ -24821,7 +24829,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 +24949,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 +25034,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 +25373,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 +25494,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);
@@ -25412,7 +25614,7 @@ var CursorBridge = class {
       this._throwIfCancelledBeforeSend(job);
       job.responseBaseline = await this._captureSessionResponseBaseline(c);
       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");
@@ -26629,6 +26831,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 +26847,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.12",
   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.12",
   "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.8.2"
   }
 }