pi-cursor-bridge 0.1.16 → 0.2.0

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "cursor-bridge",
-  "version": "5.10.0+codex.20260908042457",
+  "version": "6.0.0+codex.20260908194916",
   "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.10.0, including explicit request provenance for CCE and delegated tasks. Cursor must be installed and signed in. Current end-to-end compatibility claims remain scoped to the environments documented in the main repository.
+Pi wrapper 0.2.0 embeds Cursor Bridge 6.0.0, including explicit request provenance for CCE and delegated tasks. Its breaking result contract returns a compact receipt for background `cursor_do` work: poll `cursor_status(task_id)` normally, then retrieve a terminal result with `cursor_status(task_id, detail="full")`. 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

@@ -22344,6 +22344,7 @@ var StdioServerTransport = class {
 
 // server.mjs
 import { basename as basename6, dirname as dirname6, join as join8, resolve as resolve7 } from "node:path";
+import { statSync as statSync3 } from "node:fs";
 
 // node_modules/ws/wrapper.mjs
 var import_stream = __toESM(require_stream(), 1);
@@ -22604,7 +22605,7 @@ function updateCursorSessionRegistry(filePath, mutator, options = {}) {
 // server.mjs
 init_cursor_ensure_core();
 init_lifecycle_paths();
-var PLUGIN_VERSION = "5.10.0";
+var PLUGIN_VERSION = "6.0.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);
@@ -23344,6 +23345,60 @@ function exprInspectWorkspaceRepository(projectPath) {
     return JSON.stringify(inspectWorkspace(${JSON.stringify(String(projectPath || ""))}).diagnostic);
   })()`;
 }
+function exprRegisterAgentsWorkspace(projectPath, workspaceFile = false) {
+  return `(async function(){
+    ${WORKSPACE_SECTION_BODY}
+    const path=${JSON.stringify(String(projectPath || ""))};
+    const before=inspectWorkspace(path).diagnostic;
+    if(before.state!=='workspace_registration_required')return JSON.stringify(before);
+    const fail=(state,error)=>JSON.stringify({...before,state,error});
+    const services=new Set();
+    for(const node of document.querySelectorAll('button[aria-label="Open Workspace"],.ui-sidebar-section-head')){
+      const key=Object.keys(node).find(k=>k.startsWith('__reactFiber$'));
+      for(let f=key&&node[key],i=0;f&&i<48;i++,f=f.return){
+        for(let d=f.dependencies&&f.dependencies.firstContext;d;d=d.next){
+          const service=d.memoizedValue&&d.memoizedValue.workspace&&d.memoizedValue.workspace.instantiationService;
+          if(service)services.add(service);
+        }
+      }
+    }
+    const candidates=new Map();
+    for(const service of services){
+      const entries=new Map();
+      for(let s=service,i=0;s&&i<8;i++,s=s._parent){
+        for(const [id,value] of s._services&&s._services._entries||[]){
+          if(!entries.has(String(id)))entries.set(String(id),value);
+        }
+      }
+      const projects=entries.get('glassWorkspacesService');
+      const workspaces=entries.get('workspacesService');
+      const URI=entries.get('environmentService')?.userHome?.constructor;
+      if(typeof projects?.replaceWorkspaceProject==='function'&&typeof URI?.file==='function'
+          &&typeof workspaces?.getSingleFolderWorkspaceIdentifier==='function'
+          &&typeof workspaces?.getWorkspaceIdentifier==='function'
+          &&typeof projects?.refresh==='function'){
+        candidates.set(projects,{projects,workspaces,URI});
+      }
+    }
+    if(candidates.size!==1)return fail('workspace_registration_unavailable','Expected one Cursor workspace registration service');
+    try{
+      const {projects,workspaces,URI}=[...candidates.values()][0];
+      const uri=URI.file(path);
+      const identifier=await workspaces[${JSON.stringify(workspaceFile ? "getWorkspaceIdentifier" : "getSingleFolderWorkspaceIdentifier")}](uri);
+      if(!identifier?.id||localWorkspacePath(identifier)!==normalizeWorkspacePath(path)){
+        return fail('workspace_registration_identity_mismatch','Cursor returned a different workspace identity');
+      }
+      const current=inspectWorkspace(path).diagnostic;
+      if(current.state!=='workspace_registration_required')return JSON.stringify(current);
+      // addProject can skip folders already represented by Agent history.
+      // With no 'replaces', this public service method upserts only this exact ID.
+      await projects.replaceWorkspaceProject({project:{type:'workspace',workspaceIdentifier:identifier}});
+      await projects.refresh();
+      return JSON.stringify({ok:false,state:'workspace_registration_requested',wanted:before.wanted,
+        workspaceId:identifier.id,registrationSource:'cursor_glass_workspaces_service'});
+    }catch(error){return fail('workspace_registration_failed',String(error.message||error));}
+  })()`;
+}
 function exprInspectAgentWorkspace(projectPath, options = {}) {
   return `(function(){
     ${WORKSPACE_SECTION_BODY}
@@ -23974,7 +24029,7 @@ var CursorBridge = class {
         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`);
+        throw cursorSessionError("SESSION_RESULT_UNCOLLECTED", `read cursor_status(task_id=${session.lastTask.taskId}, detail="full") 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");
@@ -24291,6 +24346,8 @@ var CursorBridge = class {
     return result;
   }
   async initializeWorkspace(projectPath) {
+    if (this._healing) await this._healing.catch(() => {
+    });
     if (this.busy || this.activeParallel.size > 0 || this.queue.length > 0) {
       throw new Error("cursor_init cannot change workspace while Cursor tasks are queued or running");
     }
@@ -24303,7 +24360,7 @@ var CursorBridge = class {
     this._lastLifecycle = null;
     this._lastWorkspaceBinding = null;
     try {
-      await this._ensureCursor();
+      await this._ensureCursor({ registerWorkspace: true });
     } catch (error2) {
       const lifecycle = this._lastLifecycle;
       const recoverableStatuses = /* @__PURE__ */ new Set([
@@ -24339,7 +24396,7 @@ var CursorBridge = class {
       lifecycle: this._lastLifecycle
     };
   }
-  async _findAgentsWorkspace(projectPath) {
+  async _findAgentsWorkspace(projectPath, { registerWorkspace = false } = {}) {
     if (!projectPath) return null;
     this._lastWorkspaceBinding = null;
     let page;
@@ -24352,7 +24409,24 @@ var CursorBridge = class {
     const c = makeClient(page.webSocketDebuggerUrl);
     try {
       await c.ready;
-      const repository = JSON.parse(await evalJS(c, exprInspectWorkspaceRepository(projectPath)) || "{}");
+      let repository = JSON.parse(await evalJS(c, exprInspectWorkspaceRepository(projectPath)) || "{}");
+      if (registerWorkspace && repository.state === "workspace_registration_required") {
+        const registration = await this._withUiLock(async () => {
+          if (this.busy || this.activeParallel.size > 0 || this.queue.length > 0) {
+            return { ok: false, state: "workspace_registration_busy", error: "Cursor tasks became queued or running before registration" };
+          }
+          return JSON.parse(await evalJS(c, exprRegisterAgentsWorkspace(projectPath, statSync3(projectPath).isFile())) || "{}");
+        });
+        repository = registration;
+        if (registration.state === "workspace_registration_requested") {
+          for (let attempt = 0; attempt < 20; attempt++) {
+            repository = JSON.parse(await evalJS(c, exprInspectWorkspaceRepository(projectPath)) || "{}");
+            if (repository.state !== "workspace_registration_required") break;
+            await sleep2(250);
+          }
+          repository = { ...repository, registration };
+        }
+      }
       this._lastWorkspaceBinding = { ...repository, checkedAt: (/* @__PURE__ */ new Date()).toISOString() };
       if (!repository.ok) return null;
       return {
@@ -24556,7 +24630,9 @@ var CursorBridge = class {
       throw cursorSessionError("SESSION_EXECUTION_INVALID", "persistent sessions require execution=parallel_agent and never fall back to FIFO");
     }
     const readOnly = options.readOnly === true;
-    const timeoutMs = Math.max(3e4, Math.min(9e5, Number(options.timeoutMs || 6e5)));
+    const requestedTimeoutMs = Number(options.timeoutMs ?? 6e5);
+    if (!Number.isFinite(requestedTimeoutMs)) throw new Error("timeout_ms must be finite");
+    const timeoutMs = Math.max(3e4, Math.min(9e5, requestedTimeoutMs));
     const allowedPaths = Array.isArray(options.allowedPaths) ? options.allowedPaths.map((x) => String(x).trim()).filter(Boolean) : [];
     if (readOnly && allowedPaths.length > 0) {
       throw new Error("read_only=true cannot be combined with allowed_paths because a read-only task cannot declare a write scope");
@@ -24612,13 +24688,14 @@ var CursorBridge = class {
       modelPreference = session.modelPreference || null;
       if (duplicate) {
         const existing = this.tasks.get(session.activeTaskId || session.lastTask && session.lastTask.taskId || "");
-        return existing ? { duplicate: true, ...this._taskView(existing, true) } : { duplicate: true, ...this._sessionView(session) };
+        return existing ? { duplicate: true, ...options.background === false ? this._collectedTaskView(existing) : this._compactTaskView(existing) } : { duplicate: true, ...this._sessionView(session) };
       }
     }
     const job = this._enqueue("do", fullPrompt, {
       requestContext,
       taskId,
       timeoutMs,
+      requestedTimeoutMs,
       newChat: sessionMode !== "continue",
       execution,
       readOnly,
@@ -24635,9 +24712,9 @@ var CursorBridge = class {
       agentId: sessionMode === "continue" ? session && session.agentId : null,
       agentLabel: sessionMode === "continue" ? session && session.agentLabel : null
     });
-    if (options.background !== false) return this._taskView(job);
+    if (options.background !== false) return this._compactTaskView(job);
     await job.promise;
-    return this._taskView(job, true);
+    return this._collectedTaskView(job);
   }
   _assertNoParallelPathConflict(allowedPaths) {
     if (this._hasGlobalReservation()) {
@@ -24682,6 +24759,7 @@ var CursorBridge = class {
       prompt,
       requestContext: options.requestContext || normalizeRequestContext(),
       timeoutMs: options.timeoutMs,
+      requestedTimeoutMs: options.requestedTimeoutMs ?? options.timeoutMs,
       newChat: options.newChat,
       preferLegacyUi: options.preferLegacyUi === true,
       execution: options.execution || "fifo",
@@ -24847,7 +24925,7 @@ var CursorBridge = class {
   // 自愈：每次查询前委托 ensureCursorRunning。并发去重。失败静默降级（_run 报清晰错）。
   // 统一走 ensureCursorRunning 复用其【单一身份校验来源】（cdpUp + cdpIsCursor）——避免热路径裸 /json/version 检查
   // 绕过身份校验、在别的 IDE 占 9223 时驱动错应用（2026-06-08 review #6）。
-  _ensureCursor() {
+  _ensureCursor({ registerWorkspace = false } = {}) {
     this._refreshPersistedRuntimeMode();
     if (this._healing) return this._healing;
     this._healing = (async () => {
@@ -24860,17 +24938,11 @@ var CursorBridge = class {
           ...this.projectPath ? { projectPath: this.projectPath } : {}
         });
         this._lastLifecycle = lifecycleFromEnsureResult(rr, this.runtimeMode);
-        if (!rr.ok && rr.status === "workspace-not-ready" && rr.projectPath) {
-          const agentsWorkspace = await this._findAgentsWorkspace(rr.projectPath);
-          if (agentsWorkspace) {
-            this._lastLifecycle = promoteAgentsWorkspaceLifecycle(this._lastLifecycle, agentsWorkspace);
-          }
-        }
-        if (rr.ok && rr.workspaceAction === "reused-agents-window" && rr.projectPath) {
-          const agentsWorkspace = await this._findAgentsWorkspace(rr.projectPath);
+        if ((rr.ok || rr.status === "workspace-not-ready") && rr.projectPath) {
+          const agentsWorkspace = await this._findAgentsWorkspace(rr.projectPath, { registerWorkspace });
           if (agentsWorkspace) {
             this._lastLifecycle = promoteAgentsWorkspaceLifecycle(this._lastLifecycle, agentsWorkspace);
-          } else {
+          } else if (rr.ok && (rr.workspaceAction === "reused-agents-window" || this._lastWorkspaceBinding)) {
             this._lastLifecycle = {
               ...this._lastLifecycle,
               status: "workspace-not-ready",
@@ -25011,10 +25083,11 @@ var CursorBridge = class {
             this.activeParallel.delete(job.id);
             this._failJob(job, error2);
           } else if (error2 && error2.sent) {
+            job.firstWaitError ||= error2.message;
             job.error = `Submission state is uncertain; monitoring continues by agentId: ${error2.message}`;
             if (job.agentId) {
               job.phase = "running";
-              job.reservationScope = job.readOnly ? "agent" : "paths";
+              job.reservationScope = job.effectiveExecution === "fifo" ? "global" : job.readOnly ? "agent" : "paths";
               this.activeParallel.set(job.id, job);
               this._startParallelMonitor(job);
             } else {
@@ -25083,6 +25156,7 @@ var CursorBridge = class {
           baseline = JSON.parse(await evalJS(c, EXPR_SNAP));
         } catch {
         }
+        options.responseBaseline = baseline;
         const providerErrorBaseline = providerErrorSignature(await this._readProviderError(c));
         await this._verifyAgentsWorkspace(c, options, "before_send");
         options.sendState = "dispatching";
@@ -25671,6 +25745,7 @@ var CursorBridge = class {
     if (!diagnostic.ok) throw createWorkspaceBindingError(diagnostic);
   }
   async _confirmSubmission(c, baselineCount = 0, providerErrorBaseline = "", job = null) {
+    let lastSnapshot = {};
     const accepted = async () => {
       await this._throwIfNewProviderError(c, providerErrorBaseline);
       let snap = {};
@@ -25678,6 +25753,7 @@ var CursorBridge = class {
         snap = JSON.parse(await evalJS(c, EXPR_SNAP));
       } catch {
       }
+      lastSnapshot = snap;
       const inputTextLength = Number(snap.inputTextLength);
       return Number(snap.stop || 0) > 0 || Number(snap.messageCount || 0) > Number(baselineCount || 0) || Number.isFinite(inputTextLength) && inputTextLength === 0;
     };
@@ -25693,14 +25769,22 @@ var CursorBridge = class {
       throw error3;
     }
     const clicked = await evalJS(c, EXPR_CLICK_SEND);
-    if (clicked === "CLICKED") {
+    if (clicked === "CLICKED" || clicked === "NO_SEND") {
       for (let i = 0; i < 20; i++) {
         await sleep2(250);
-        if (await accepted()) return "button";
+        if (await accepted()) return clicked === "CLICKED" ? "button" : "enter";
       }
     }
-    const error2 = new Error(`Cursor did not accept the submission (submit_not_accepted: ${clicked || "unknown"}); the prompt remains in the input and no orphan task was created`);
-    error2.confirmedNotSent = true;
+    const error2 = new Error(`Cursor submission could not be confirmed (submission_uncertain: ${clicked || "unknown"}); Enter was dispatched, so inspect the bound Agent before retrying`);
+    error2.confirmedNotSent = false;
+    error2.sent = true;
+    error2.composerDiagnostic = {
+      inputTextLength: Number.isFinite(Number(lastSnapshot.inputTextLength)) ? Number(lastSnapshot.inputTextLength) : null,
+      sendReady: lastSnapshot.sendReady === true,
+      stop: Number(lastSnapshot.stop || 0),
+      messageCount: Number(lastSnapshot.messageCount || 0),
+      fallbackResult: clicked || "unknown"
+    };
     throw error2;
   }
   async _readProviderError(c) {
@@ -26072,7 +26156,12 @@ var CursorBridge = class {
     }
     if (!this._monitorOwns(job, generation)) return;
     const detail = lastCollectionError ? `; last collection error: ${lastCollectionError}` : "";
-    throw new Error(`Cursor parallel_agent task timed out (${job.timeoutMs}ms)${detail}`);
+    const recovered = await this._withJobLock(job, async () => {
+      if (!this._monitorOwns(job, generation)) return true;
+      const result = await this._reapParallelJobLocked(job, { reattach: false, preserveMonitor: true });
+      return isTerminalTask(job) || result.state === "terminal_uncollected";
+    });
+    if (!recovered) throw new Error(`Cursor ${job.effectiveExecution || job.execution || "Agent"} task timed out (${job.timeoutMs}ms)${detail}`);
   }
   async _requestExactAgentSelection(c, agentId) {
     if (!await this._ensureHistoryOpen(c)) return "REACT_ADAPTER_UNAVAILABLE";
@@ -26168,7 +26257,7 @@ var CursorBridge = class {
     job.resultUnavailable = true;
     job.terminalEvidence = evidence || "stable_completed_history_icon";
     job.recoveryState = "terminal_result_uncollected";
-    job.reservationScope = uncertainSubmissionReservationScope(job, error2);
+    job.reservationScope = job.effectiveExecution === "fifo" ? "global" : uncertainSubmissionReservationScope(job, error2);
     this._safeSettleSessionJob(job, "terminal_result_uncollected", { needsAttention: true });
   }
   _abandonJob(job, reason) {
@@ -26216,7 +26305,7 @@ var CursorBridge = class {
       job.recoveryState = "agent_missing";
       return { stable: false, error: "The bound agentId was not found in Agent History", entry: second || first || null };
     }
-    const stable = first.id === second.id && first.showSpinner === second.showSpinner && String(first.icon || "") === String(second.icon || "");
+    const stable = first.id === second.id && second.id === job.agentId && first.showSpinner === second.showSpinner && String(first.icon || "") === String(second.icon || "");
     return { stable, entry: second, error: stable ? null : "Agent History state is not yet stable" };
   }
   async _reapParallelJob(job, options = {}) {
@@ -26225,15 +26314,15 @@ var CursorBridge = class {
   }
   async _reapParallelJobLocked(job, options = {}) {
     if (!job || isTerminalTask(job)) return { changed: false, state: "terminal", task: this._taskView(job, true) };
-    if (job.execution !== "parallel_agent" || !this.activeParallel.has(job.id)) {
+    if (!this.activeParallel.has(job.id)) {
       return { changed: false, state: "not_parallel_reservation", task: this._taskView(job, true) };
     }
     if (!job.agentId) {
       job.lastRecoveryAt = (/* @__PURE__ */ new Date()).toISOString();
       job.recoveryState = "unbound_agent";
-      return { changed: false, state: "unbound_agent", task: this._taskView(job, true) };
+      return { changed: false, state: "unbound_agent", next: "The FIFO orphan has no agentId that can be safely rebound. Confirm that it stopped in the Cursor UI before explicitly abandoning it.", task: this._taskView(job, true) };
     }
-    this._invalidateParallelMonitor(job);
+    if (!options.preserveMonitor) this._invalidateParallelMonitor(job);
     const observed = await this._readStableParallelEntry(job);
     if (!observed.stable || !observed.entry) {
       return { changed: false, state: job.recoveryState || "unstable", error: observed.error, task: this._taskView(job, true) };
@@ -26471,17 +26560,19 @@ var CursorBridge = class {
       job.cancelReason = reason || (job.execution === "parallel_agent" ? "User requested Cursor Agent cancellation" : "User requested FIFO task cancellation");
       job.cancelRequestSeq = Number(job.cancelRequestSeq || 0) + 1;
     }
-    return this._withJobLock(job, () => this._taskControlLocked(job, action, {
+    const result = await this._withJobLock(job, () => this._taskControlLocked(job, action, {
       ...options,
       reason,
       expectedAgentId
     }));
+    if (result && result.task) result.task = this._compactTaskView(job);
+    return result;
   }
   async _taskControlLocked(job, action, options) {
     if (action === "reap") {
       const result = await this._reapParallelJobLocked(job, { reattach: true });
       if (result.state === "not_parallel_reservation" && job.phase === "orphaned") {
-        result.next = job.agentId ? "FIFO is bound to an agentId, but reap applies only to parallel_agent. Use cancel for a targeted stop, or abandon after confirmation." : "The FIFO orphan has no agentId that can be safely rebound. Confirm that it stopped in the Cursor UI before explicitly abandoning it.";
+        result.next = job.agentId ? "The bound task has no recoverable reservation. Inspect its current state before cancelling." : "The FIFO orphan has no agentId that can be safely rebound. Confirm that it stopped in the Cursor UI before explicitly abandoning it.";
       }
       return { found: true, action, ...result };
     }
@@ -26539,10 +26630,13 @@ var CursorBridge = class {
     }
     const canTargetStop = job.execution === "parallel_agent" || !!job.agentId;
     if (canTargetStop && (job.execution === "parallel_agent" || job.phase === "orphaned")) {
-      if (job.execution === "parallel_agent") {
+      if (this.activeParallel.has(job.id)) {
         this._invalidateParallelMonitor(job);
         const reaped = await this._reapParallelJobLocked(job, { reattach: false });
-        if (isTerminalTask(job)) return { found: true, action, ...reaped };
+        if (isTerminalTask(job) || reaped.state === "terminal_uncollected") {
+          job.cancelRequested = false;
+          return { found: true, action, ...reaped };
+        }
       }
       job.phase = "cancelling";
       job.recoveryState = "stopping";
@@ -26677,6 +26771,7 @@ var CursorBridge = class {
       } catch {
         s = { stop: 0, messageCount: 0, replyLength: 0, replyHash: 0 };
       }
+      if (job) job.lastWaitObservation = { at: (/* @__PURE__ */ new Date()).toISOString(), stop: s.stop, messageCount: s.messageCount, replyLength: s.replyLength, sawStop: sawStop || s.stop > 0 };
       if (s.stop > 0) sawStop = true;
       if (sawStop && s.stop === 0 && s.replyLength > 0) {
         await sleep2(800);
@@ -26714,9 +26809,12 @@ 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,
+      requestedTimeoutMs: job.requestedTimeoutMs ?? job.timeoutMs,
+      effectiveTimeoutMs: job.timeoutMs,
+      firstWaitError: job.firstWaitError || null,
+      lastWaitObservation: job.lastWaitObservation || null,
       kind: job.kind,
       status: job.status,
       phase: job.phase,
@@ -26772,11 +26870,162 @@ var CursorBridge = class {
       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.";
       } else {
-        view.attention = job.agentId ? job.execution === "parallel_agent" ? "Use cursor_task_control(action=reap) to recheck the original agentId. Use cancel when a stop is needed, and abandon only after manual confirmation while accepting residual write risk." : "FIFO is bound to an agentId. Use cursor_task_control(action=cancel) with the exact expected_agent_id for a targeted stop." : "This orphan has no agentId that can be safely rebound and globally blocks new delegation. Confirm that it stopped in the Cursor UI, then explicitly release it with cursor_task_control(action=abandon).";
+        view.attention = job.agentId ? job.execution === "parallel_agent" ? "Use cursor_task_control(action=reap) to recheck the original agentId. Use cancel when a stop is needed, and abandon only after manual confirmation while accepting residual write risk." : "FIFO is bound to an agentId. Use reap to collect or resume monitoring; use cancel with the exact expected_agent_id to stop running work." : "This orphan has no agentId that can be safely rebound and globally blocks new delegation. Confirm that it stopped in the Cursor UI, then explicitly release it with cursor_task_control(action=abandon).";
       }
     }
     return view;
   }
+  _collectedTaskView(job) {
+    this._markTaskResultCollected(job);
+    return this._taskView(job, true);
+  }
+  _compactTaskView(job, { summary = false } = {}) {
+    const full = this._taskView(job);
+    const selection = full.modelSelection && {
+      configured: full.modelSelection.configured,
+      applied: full.modelSelection.applied,
+      model: full.modelSelection.model,
+      effort: full.modelSelection.effort,
+      requestedModel: full.modelSelection.requestedModel ?? full.modelSelection.model ?? full.modelPreference?.model,
+      requestedEffort: full.modelSelection.requestedEffort ?? full.modelSelection.effort ?? full.modelPreference?.effort,
+      effectiveModel: full.modelSelection.effectiveModel,
+      effectiveEffort: full.modelSelection.effectiveEffort,
+      failureClass: full.modelSelection.failureClass,
+      retryable: full.modelSelection.retryable,
+      errorCode: full.modelSelection.errorCode,
+      lastError: full.modelSelection.lastError,
+      failedAt: full.modelSelection.failedAt,
+      verifiedAt: full.modelSelection.verifiedAt
+    };
+    const view = {
+      taskId: full.taskId,
+      kind: full.kind,
+      status: full.status,
+      phase: full.phase,
+      execution: full.execution,
+      effectiveExecution: full.effectiveExecution,
+      projectPath: full.projectPath,
+      sessionId: full.sessionId,
+      agentId: full.agentId,
+      sendState: full.sendState,
+      modelSelection: selection,
+      reservationHeld: full.reservationHeld,
+      reservationScope: full.reservationScope,
+      blocksFifo: full.blocksFifo,
+      blocksAll: full.blocksAll,
+      recoveryState: full.recoveryState,
+      attention: full.attention,
+      cancelRequested: full.cancelRequested,
+      cancelReason: full.cancelReason,
+      underlyingStopConfirmed: full.underlyingStopConfirmed,
+      lastRecoveryAt: full.lastRecoveryAt,
+      terminalEvidence: full.terminalEvidence,
+      resultAvailable: job.result != null,
+      resultLength: job.result == null ? 0 : String(job.result).length,
+      resultUnread: job.result != null && !full.resultCollectedAt,
+      resultUnavailable: full.resultUnavailable,
+      resultCollectedAt: full.resultCollectedAt,
+      error: full.error
+    };
+    if (selection && Object.values(selection).every((value) => value === void 0)) view.modelSelection = null;
+    if (full.sessionError) view.sessionError = full.sessionError;
+    if (full.firstWaitError) view.firstWaitError = full.firstWaitError;
+    if (full.providerError) view.providerError = full.providerError;
+    if (full.uiDiagnostic) view.uiDiagnostic = full.uiDiagnostic;
+    if (full.workspaceBinding && full.workspaceBinding.ok === false) view.workspaceBinding = full.workspaceBinding;
+    if ((full.error || full.status === "needs_attention") && full.workspaceBindingChecks) {
+      view.workspaceBindingChecks = full.workspaceBindingChecks;
+    }
+    if (full.status === "needs_attention" && full.lastWaitObservation) view.lastWaitObservation = full.lastWaitObservation;
+    if (summary) {
+      return {
+        taskId: view.taskId,
+        status: view.status,
+        phase: view.phase,
+        agentId: view.agentId,
+        sessionId: view.sessionId,
+        resultAvailable: view.resultAvailable,
+        resultLength: view.resultLength,
+        resultUnread: view.resultUnread,
+        resultCollectedAt: view.resultCollectedAt,
+        ...view.sendState ? { sendState: view.sendState } : {},
+        ...view.reservationHeld ? { reservationHeld: true, reservationScope: view.reservationScope } : {},
+        ...view.blocksFifo ? { blocksFifo: true } : {},
+        ...view.blocksAll ? { blocksAll: true } : {},
+        ...view.recoveryState ? { recoveryState: view.recoveryState } : {},
+        ...view.attention ? { attention: view.attention } : {},
+        ...view.cancelRequested ? { cancelRequested: true } : {},
+        ...view.cancelReason ? { cancelReason: view.cancelReason } : {},
+        ...view.underlyingStopConfirmed != null ? { underlyingStopConfirmed: view.underlyingStopConfirmed } : {},
+        ...view.lastRecoveryAt ? { lastRecoveryAt: view.lastRecoveryAt } : {},
+        ...view.terminalEvidence ? { terminalEvidence: view.terminalEvidence } : {},
+        ...view.resultUnavailable ? { resultUnavailable: true } : {},
+        ...view.error ? { error: view.error } : {},
+        ...view.providerError ? { providerError: view.providerError } : {},
+        ...view.uiDiagnostic ? { uiDiagnostic: view.uiDiagnostic } : {},
+        ...view.workspaceBinding ? { workspaceBinding: view.workspaceBinding } : {},
+        ...view.workspaceBindingChecks ? { workspaceBindingChecks: view.workspaceBindingChecks } : {}
+      };
+    }
+    return {
+      ...view,
+      requestedTimeoutMs: full.requestedTimeoutMs,
+      effectiveTimeoutMs: full.effectiveTimeoutMs,
+      readOnly: full.readOnly,
+      allowedPaths: full.allowedPaths,
+      modelPreference: full.modelPreference,
+      requestContext: full.requestContext,
+      sessionMode: full.sessionMode,
+      sessionTurn: full.sessionTurn,
+      sessionState: full.sessionState,
+      requestId: full.requestId,
+      provisionalAgentId: full.provisionalAgentId,
+      agentLabel: full.agentLabel,
+      createdAt: full.createdAt,
+      startedAt: full.startedAt,
+      sentAt: full.sentAt,
+      finishedAt: full.finishedAt
+    };
+  }
+  _compactStatusCommon() {
+    const workspace = this.workspaceView();
+    const runtime = this.runtimeModeView();
+    const models = this.modelPreferencesView();
+    return {
+      pluginVersion: PLUGIN_VERSION,
+      statusPath: "json-list",
+      workspaceKey: workspace.workspaceKey,
+      workspaceConfirmationRequired: workspace.workspaceConfirmationRequired,
+      workspaceBindingWarning: workspace.workspaceBindingWarning,
+      projectPath: workspace.projectPath,
+      initialized: workspace.initialized,
+      ...workspace.workspaceBinding && workspace.workspaceBinding.ok === false ? { workspaceBinding: workspace.workspaceBinding } : {},
+      ...this.delegationView(),
+      runtimeMode: runtime.runtimeMode,
+      minimalModeWarning: runtime.minimalModeWarning,
+      modelPreferences: models.modelPreferences,
+      modelPreferencesUpdatedAt: models.modelPreferencesUpdatedAt,
+      sessionStoragePersistent: !!this.sessionFile
+    };
+  }
+  _compactLifecycleView() {
+    const lifecycle = this._lastLifecycle;
+    if (!lifecycle) {
+      return { adapterPid: process.pid, status: null, lifecycleMode: null, persistent: null, degradedReason: null };
+    }
+    if (lifecycle.degradedReason || lifecycle.spawnErrorCode || lifecycle.error || lifecycle.supervisorError || lifecycle.needsAction || lifecycle.nextStep || lifecycle.retryable || lifecycle.status === "failed") {
+      return lifecycle;
+    }
+    return {
+      adapterPid: lifecycle.adapterPid,
+      supervisorPid: lifecycle.supervisorPid,
+      status: lifecycle.status,
+      lifecycleMode: lifecycle.lifecycleMode,
+      persistent: lifecycle.persistent,
+      degradedReason: lifecycle.degradedReason,
+      cursorPid: lifecycle.cursorPid
+    };
+  }
   _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.");
@@ -26785,7 +27034,7 @@ var CursorBridge = class {
   _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.");
+      throw new Error('TASK_RETENTION_FULL: 50 tasks are active or have unread replies. Read each unreadResultTaskId with cursor_status(task_id, detail="full"), or wait for active tasks before submitting more work.');
     }
   }
   _trimTasks(limit = 50) {
@@ -26795,16 +27044,20 @@ var CursorBridge = class {
       if (this.tasks.size <= limit) break;
     }
   }
-  async status(taskId = "") {
+  async status(taskId = "", { detail = "compact" } = {}) {
+    const normalizedDetail = normalizeStatusDetail(detail);
     if (taskId) {
       const job = this.tasks.get(String(taskId));
-      if (!job) return { found: false, taskId: String(taskId), ...this.workspaceView(), ...this.delegationView(), ...this.runtimeModeView(), ...this.modelPreferencesView(), ...this.sessionRegistryView() };
-      return { found: true, ...this.workspaceView(), ...this.delegationView(), ...this.runtimeModeView(), ...this.modelPreferencesView(), ...this.sessionRegistryView(), ...this._taskView(job, true) };
+      if (normalizedDetail === "full") {
+        if (!job) return { found: false, taskId: String(taskId), ...this.workspaceView(), ...this.delegationView(), ...this.runtimeModeView(), ...this.modelPreferencesView(), ...this.sessionRegistryView() };
+        return { found: true, ...this.workspaceView(), ...this.delegationView(), ...this.runtimeModeView(), ...this.modelPreferencesView(), ...this.sessionRegistryView(), ...this._collectedTaskView(job) };
+      }
+      return { found: !!job, ...this._compactStatusCommon(), ...job ? this._compactTaskView(job) : { taskId: String(taskId) } };
     }
     const parallelRunning = this.activeParallel.size;
     const uiBusy = this.busy;
     const globalBlocked = this._hasGlobalReservation();
-    const common = {
+    const common = normalizedDetail === "full" ? {
       pluginVersion: PLUGIN_VERSION,
       statusPath: "json-list",
       ...this.workspaceView(),
@@ -26842,6 +27095,21 @@ var CursorBridge = class {
         runtimeMode: this.runtimeMode,
         presentation: null
       }
+    } : {
+      ...this._compactStatusCommon(),
+      busy: uiBusy || parallelRunning > 0 || this.queue.length > 0,
+      uiBusy,
+      parallelRunning,
+      idle: !uiBusy && parallelRunning === 0 && this.queue.length === 0,
+      queued: this.queue.length,
+      blockingTaskIds: [...this.activeParallel.values()].filter((job) => !isTerminalTask(job)).map((job) => job.id),
+      globallyBlocked: globalBlocked,
+      blockedQueuedCount: this.activeParallel.size > 0 ? this.queue.filter((job) => globalBlocked || job.effectiveExecution !== "parallel_agent").length : 0,
+      activeParallel: [...this.activeParallel.values()].map((job) => this._compactTaskView(job, { summary: true })),
+      recentTasks: [...this.tasks.values()].filter((job) => !this.activeParallel.has(job.id)).slice(-10).map((job) => this._compactTaskView(job, { summary: true })),
+      unreadResultTaskIds: [...this.tasks.values()].filter((job) => isTerminalTask(job) && job.result != null && !job.resultCollectedAt).map((job) => job.id),
+      taskRetentionLimit: 50,
+      lifecycle: this._compactLifecycleView()
     };
     try {
       const ver = await httpJson("/json/version");
@@ -26862,6 +27130,13 @@ function buildSearchInputSchema() {
     required: ["query"]
   };
 }
+function normalizeStatusDetail(detail) {
+  if (detail === void 0) return "compact";
+  if (typeof detail !== "string" || !["compact", "full"].includes(detail)) {
+    throw new Error("detail must be compact or full");
+  }
+  return detail;
+}
 var REQUEST_CONTEXT_SCHEMA = {
   type: "object",
   additionalProperties: false,
@@ -26875,7 +27150,7 @@ function buildToolDefinitions(bridgeInstance) {
   return [
     {
       name: "cursor_init",
-      description: "Initialize or reinitialize CCE for one local workspace. Give only the project path: Bridge saves it, finds Cursor, ensures the required connection, and opens or verifies the matching project. If Cursor was opened too early without CCE access, initialization safely keeps the binding and tells the user to save, close Cursor once, and repeat the same initialization sentence; it never force-closes Cursor. Cursor login and the user's old/new UI preference are preserved. When both UIs are open, Bridge selects the new Agents Window and creates work in the matching repository instead of Home.",
+      description: "Initialize or reinitialize CCE for one local workspace. Give only the project path: Bridge saves it, finds Cursor, ensures the required connection, and opens or verifies the matching project. In Agents Window, initialization registers a missing local workspace through Cursor's project service and verifies its exact path before reporting ready. If Cursor was opened too early without CCE access, initialization safely keeps the binding and tells the user to save, close Cursor once, and repeat the same initialization sentence; it never force-closes Cursor. Cursor login and the user's old/new UI preference are preserved. When both UIs are open, Bridge selects the new Agents Window and creates work in the matching repository instead of Home.",
       inputSchema: {
         type: "object",
         properties: {
@@ -26891,7 +27166,7 @@ function buildToolDefinitions(bridgeInstance) {
     },
     bridgeInstance.environmentDelegationMode !== "off" ? {
       name: "cursor_do",
-      description: "Give Cursor a clearly bounded task and get back a task ID. fifo means first in, first out: Bridge runs one queued task at a time, starting it in a clean chat. parallel_agent creates a separate top-level Cursor Agent. Persistent continuity is explicit: session_mode=create starts one durable top-level Agent association, and session_mode=continue requires its exact session_id. Omission keeps the existing isolated behavior. Parallel write tasks must declare non-overlapping allowed_paths; mark read-only work with read_only=true. Collect the result with cursor_status(task_id). Cursor can do the work, but the main agent still owns review and final verification. A direct user opt-out always wins.",
+      description: 'Give Cursor a clearly bounded task and get back a task ID. fifo means first in, first out: Bridge runs one queued task at a time, starting it in a clean chat. parallel_agent creates a separate top-level Cursor Agent. Persistent continuity is explicit: session_mode=create starts one durable top-level Agent association, and session_mode=continue requires its exact session_id. Omission keeps the existing isolated behavior. Parallel write tasks must declare non-overlapping allowed_paths; mark read-only work with read_only=true. Collect the result with cursor_status(task_id, detail="full"); ordinary status calls are compact and do not acknowledge the reply. Cursor can do the work, but the main agent still owns review and final verification. A direct user opt-out always wins.',
       inputSchema: {
         type: "object",
         properties: {
@@ -26900,7 +27175,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: "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." },
+          timeout_ms: { type: "integer", minimum: 3e4, maximum: 9e5, default: 6e5, description: "One monitoring budget after submission, shared by FIFO and automatic Agent recovery. Default 10 minutes, maximum 15 minutes; task status reports requested and effective budgets. Expiry probes the bound Agent once for completion; it does not cancel or resend work. Explicit reap may start a new budget for a still-running bound Agent, including FIFO." },
           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." },
@@ -26912,7 +27187,7 @@ function buildToolDefinitions(bridgeInstance) {
     } : null,
     {
       name: "cursor_task_control",
-      description: "Recover or terminate one exact in-memory Cursor task without resubmitting it; task records do not survive this MCP server process. Use reap for needs_attention/orphaned work only when it has a bound agentId; it explicitly rechecks that Agent and collects a stable terminal result when possible. Use cancel with confirm=true and the exact expected_agent_id to target Stop safely. FIFO or unbound orphans globally block delegation and require manual verification before abandon. Use abandon only with an explicit reason and acknowledge_may_still_write=true; it releases reservations without proving the Cursor Agent stopped.",
+      description: 'Recover or terminate one exact in-memory Cursor task without resubmitting it; task records do not survive this MCP server process. Use reap for needs_attention/orphaned work only when it has a bound agentId; it explicitly rechecks that Agent and stores a stable terminal result when possible. Responses stay compact and never acknowledge the result; collect it later with cursor_status(task_id, detail="full"). Use cancel with confirm=true and the exact expected_agent_id to target Stop safely. FIFO or unbound orphans globally block delegation and require manual verification before abandon. Use abandon only with an explicit reason and acknowledge_may_still_write=true; it releases reservations without proving the Cursor Agent stopped.',
       inputSchema: {
         type: "object",
         properties: {
@@ -26968,12 +27243,14 @@ function buildToolDefinitions(bridgeInstance) {
     },
     {
       name: "cursor_status",
-      description: "Read-only snapshot of Cursor connectivity, queued/running work, reservations, execution availability, persistent model/effort defaults, sessions, and normal/minimal runtime presentation. Pass task_id for its configured and effective model selection, or session_id for the durable association; never pass both. This tool never switches Agents, reconciles, or stops work.",
+      description: 'Read-only snapshot of Cursor connectivity, queued/running work, reservations, execution availability, persistent model/effort defaults, sessions, and normal/minimal runtime presentation. Compact is the default and never includes or acknowledges a task result. Use detail="full" with task_id to receive the complete legacy task details and result; this marks the result collected while keeping repeat full reads available. Pass task_id for its configured and effective model selection or session_id for the durable association; never pass both. This tool never switches Agents, reconciles, or stops work.',
       inputSchema: {
         type: "object",
+        additionalProperties: false,
         properties: {
           task_id: { type: "string", description: "A task ID returned by cursor_do." },
-          session_id: { type: "string", description: "A persistent session ID returned by cursor_do(session_mode=create)." }
+          session_id: { type: "string", description: "A persistent session ID returned by cursor_do(session_mode=create)." },
+          detail: { type: "string", enum: ["compact", "full"], default: "compact", description: "compact returns status and safety metadata without the result body or receipt side effect. full returns legacy complete details and explicitly collects a task result." }
         }
       }
     }
@@ -27090,15 +27367,16 @@ server.setRequestHandler(CallToolRequestSchema, async (request2) => {
       if (args && args.task_id && args.session_id) {
         throw cursorSessionError("STATUS_SELECTOR_AMBIGUOUS", "pass task_id or session_id, not both");
       }
+      const detail = normalizeStatusDetail(args && args.detail);
       const statusMs = Math.max(1e3, Number(process.env.CURSOR_BRIDGE_STATUS_TIMEOUT || 8e3));
       let result;
       try {
         result = await Promise.race([
-          args && args.session_id ? Promise.resolve(bridge.sessionStatus(args.session_id)) : bridge.status(args && args.task_id),
+          args && args.session_id ? Promise.resolve(bridge.sessionStatus(args.session_id)) : bridge.status(args && args.task_id, { detail }),
           new Promise((_, reject) => setTimeout(() => reject(new Error(`cursor_status_timeout_${statusMs}`)), statusMs))
         ]);
       } catch (error2) {
-        result = {
+        result = detail === "full" ? {
           connected: false,
           pluginVersion: PLUGIN_VERSION,
           statusPath: "json-list",
@@ -27106,7 +27384,14 @@ server.setRequestHandler(CallToolRequestSchema, async (request2) => {
           ...bridge.workspaceView(),
           ...bridge.delegationView(),
           ...bridge.runtimeModeView(),
+          ...bridge.modelPreferencesView(),
           ...bridge.sessionRegistryView()
+        } : {
+          connected: false,
+          ...bridge._compactStatusCommon(),
+          ...args && args.task_id ? { found: false, taskId: String(args.task_id) } : {},
+          ...args && args.session_id ? { found: false, sessionId: String(args.session_id) } : {},
+          error: error2 instanceof Error ? error2.message : String(error2)
         };
       }
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
@@ -27177,6 +27462,7 @@ export {
   exprInspectAgentWorkspace,
   exprInspectWorkspaceRepository,
   exprOpenAgent,
+  exprRegisterAgentsWorkspace,
   isConfirmedCompletedReply,
   isCursorEffortOptionText,
   isDurablyRegisteredParallelEntry,

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.16",
+  packageVersion: "0.2.0",
   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.16",
+  "version": "0.2.0",
   "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.10.0"
+    "embeddedProductVersion": "6.0.0"
   }
 }

package/skills/cursor-delegate/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: cursor-delegate
-description: "Delegate bounded light-to-medium implementation, investigation, documentation, configuration, testing, and tooling work to Cursor Bridge after the primary agent owns direction and risk boundaries. Also use when the user explicitly asks to create, keep, continue, inspect, or close the same Cursor execution session, including phrases such as '持续会话', '同一个 Cursor 会话', or 'continue the Cursor session'. Generic '继续' is not enough to reuse a session. Collect each turn by task_id and verify it in the primary agent. Do not use when the user opts out, cursor_do is unavailable or administrator-disabled, or for product direction, architecture decisions, exclusive GUI operations, formal verification verdicts, governance state decisions, or unbounded investigation."
+description: "Delegate bounded light-to-medium implementation, investigation, documentation, configuration, testing, and tooling work to Cursor Bridge after the primary agent owns direction and risk boundaries. Also use when the user explicitly asks to create, keep, continue, inspect, or close the same Cursor execution session, including phrases such as '持续会话', '同一个 Cursor 会话', or 'continue the Cursor session'. Generic '继续' is not enough to reuse a session. Poll each turn compactly by task_id, then explicitly retrieve a terminal result by task_id and verify it in the primary agent. Do not use when the user opts out, cursor_do is unavailable or administrator-disabled, or for product direction, architecture decisions, exclusive GUI operations, formal verification verdicts, governance state decisions, or unbounded investigation."
 ---
 
 # Cursor Delegate
@@ -21,11 +21,11 @@ Declare `request_context` for each call: an AI caller uses `sender="model"`; set
 
 Use this responsibility chain:
 
-`primary agent defines purpose, invariants, and risk boundaries -> form a bounded task envelope -> Cursor investigates locally and executes within the envelope -> collect by task_id -> primary agent inspects the real changes and verifies them`
+`primary agent defines purpose, invariants, and risk boundaries -> form a bounded task envelope -> Cursor investigates locally and executes within the envelope -> poll compactly and retrieve the terminal result by task_id -> primary agent inspects the real changes and verifies them`
 
 - Decide what should be achieved, why it matters, what must not change, where Cursor may work, and what evidence makes the result acceptable. Do not delegate product direction, architecture boundaries, or state verdicts.
 - Allow Cursor to locate relevant implementation, compare local approaches, and complete code, documentation, configuration, scripts, tests, and tooling inside those boundaries. Do not require the primary agent to pre-solve the task line by line.
-- Once a task has been selected for delegation, normally call `cursor_do` once with `background=true`, then continue non-conflicting primary-agent work. Bridge starts FIFO work in a clean chat automatically.
+- Once a task has been selected for delegation, normally call `cursor_do` once with `background=true`, receive its compact submission receipt, then continue non-conflicting primary-agent work. Bridge starts FIFO work in a clean chat automatically.
 - Prefer `execution=fifo` unless the parallel contract is clearly satisfied.
 - Do not inject a unique completion marker or impose a minimum response length. Rely on task state, stable `task_id` or `agent_id`, and the actual result.
 
@@ -75,7 +75,7 @@ Do not choose parallel execution merely because there are many tasks. When depen
 
 1. Record the relevant pre-dispatch workspace state so later review can distinguish existing user changes.
 2. Form one independent task envelope per task using [delegation-contract.md](references/delegation-contract.md). Write its narrative instructions in the language of the user's current substantive task unless the user explicitly requests another language. Do not persist an inferred language or replace a clear conversational signal with the host/OS locale.
-3. Call `cursor_do` with `background=true`. Use only the documented `session_mode` and `session_id` fields when continuity is explicit; never infer continuity from the visible chat.
+3. Call `cursor_do` with `background=true` and save its compact submission receipt. Use `background=false` only when an immediate synchronous full result is required. Use only the documented `session_mode` and `session_id` fields when continuity is explicit; never infer continuity from the visible chat.
 4. Save each returned `task_id`; for persistent work also save `session_id`. Treat `agent_id` as verification evidence, not the continuation handle.
 5. If a parallel submission does not return a usable `agent_id`, stop expanding the parallel batch and use `fifo` or report the ambiguous state.
 
@@ -83,12 +83,13 @@ The envelope may contain a small number of local implementation `open_questions`
 
 ## Collect and verify
 
-1. Always query `cursor_status(task_id)` for the exact task. Do not treat the currently visible Cursor chat as task identity.
+1. Always query `cursor_status(task_id)` for the exact task. Its default compact view is for normal polling; use `detail="full"` during progress only when detailed diagnostics are needed. Do not treat the currently visible Cursor chat as task identity.
 2. Treat `submitting`, `running`, and `collecting` as normal in-progress states. More than two minutes is not itself a failure; wait for an explicit terminal state.
-3. Compare Cursor's claimed work with the real diff, `allowed_paths`, and acceptance contract.
-4. When `cursor_status` reports a configured model default, confirm `modelSelection.applied=true` and preserve its configured/effective model and effort fields in any failure report.
-5. Run risk-proportionate verification in the primary agent. Cursor's response alone cannot support a formal pass, verified state, or governance transition.
-6. Record each task as complete, partial, failed, timed out, or ambiguous before summarizing the batch.
+3. After a terminal state, call `cursor_status(task_id, detail="full")`. It returns the complete retained result and records explicit receipt; repeat full reads remain allowed while the task is retained.
+4. Compare Cursor's claimed work with the real diff, `allowed_paths`, and acceptance contract.
+5. When `cursor_status` reports a configured model default, confirm `modelSelection.applied=true` and preserve its configured/effective model and effort fields in any failure report.
+6. Run risk-proportionate verification in the primary agent. Cursor's response alone cannot support a formal pass, verified state, or governance transition.
+7. Record each task as complete, partial, failed, timed out, or ambiguous before summarizing the batch.
 
 Report the accepted result in the language of the user's current task. Keep `task_id`, `agent_id`, tool names, states, enum values, paths, commands, hashes, exact permission options, and error/status codes verbatim. If Cursor returned an artifact or report in another language, preserve it and summarize the relevant facts in the current task language.
 
@@ -97,14 +98,14 @@ Read [delegation-contract.md](references/delegation-contract.md) for state inter
 ## Handle abnormal states
 
 - For `needs_attention`, `orphaned`, ambiguous state, or an unbound session, assume the real Cursor Agent may still be running. Preserve path ownership and never resubmit automatically.
-- For a parallel orphan with a bound `agent_id`, first call `cursor_task_control(action=reap)`. This explicitly rechecks and, when possible, resumes monitoring or collects that exact Agent. `cursor_status` is read-only and does not reap automatically.
+- For a parallel orphan with a bound `agent_id`, first call `cursor_task_control(action=reap)`. This explicitly rechecks and, when possible, resumes monitoring or recovers that task's terminal state. It returns only an action/state summary; after a terminal state, retrieve any result with `cursor_status(task_id, detail="full")`.
 - For an unbound FIFO or any orphan without an `agent_id`, do not call `reap` as if an identity existed. It globally blocks delegation; manually verify Cursor has stopped, then use the explicitly acknowledged `abandon` path.
 - To stop a bound task, use `cursor_task_control(action=cancel, confirm=true, expected_agent_id=<exact id>)`. This includes FIFO tasks that have published an Agent ID. If Stop cannot be confirmed, the reservation remains held.
 - Use `action=abandon` only after manual verification and an explicit user decision to accept the risk. It requires `confirm=true`, a non-empty reason, `acknowledge_may_still_write=true`, and the exact `expected_agent_id` when one is already bound; report that the underlying Agent may still run or write.
-- If Cursor shows a final UI response but Bridge has not collected it, use explicit `reap` against the original bound task. A `terminal_uncollected` result keeps the reservation for retry. Do not add a completion marker, increase a response-length requirement, or submit the same task again.
+- If Cursor shows a final UI response but Bridge has not collected it, use explicit `reap` against the original bound task. A `terminal_uncollected` result keeps the reservation for retry; after recovery reaches a terminal state, retrieve the result through explicit full task status. Do not add a completion marker, increase a response-length requirement, or submit the same task again.
 - Task identity and reservations are process-local. After an MCP/Codex restart, do not claim the old `task_id` is recoverable; inspect Cursor Agent History and workspace changes manually before overlapping work.
 - A ready persistent `session_id` is stored outside the versioned plugin cache and may survive MCP/Codex restart or plugin update. Query `cursor_status(session_id)` before continuing. If it reports `needs_attention`, an expired sender lease, or a missing exact Agent binding, do not resubmit or silently create a replacement session.
-- Use `cursor_session_control(action=reconcile)` to check the exact Agent twice after an interrupted adapter. It may return the session to `ready` only from stable terminal evidence; an interrupted completed reply remains explicitly uncollected.
+- Use `cursor_session_control(action=reconcile)` to check the exact Agent twice after an interrupted adapter. It may return the session to `ready` only from stable terminal evidence; an interrupted completed reply remains explicitly uncollected and `cursor_session_control(action=collect_result)` returns that session reply in full.
 - `cursor_session_control(action=abandon)` is the last resort for an uncertain session and requires `confirm=true`, a non-empty reason, and `acknowledge_may_still_write=true`. It closes only the Bridge mapping and does not prove that Cursor stopped.
 - If a timed-out task changed files, inspect the changes before deciding whether to continue, retry, or revert.
 - If changes exceed `allowed_paths`, stop accepting the result and report the scope violation.

package/skills/cursor-delegate/references/delegation-contract.md

@@ -21,7 +21,7 @@ Provide every task independently:
 | `read_only` | Use `true` for lookup and analysis; use `false` for any file modification. |
 | `allowed_paths` | Required when `read_only=false`. Provide the smallest workspace-relative path set, with no glob, absolute path, or workspace-escaping `..`. Omit it when `read_only=true`. This is not a filesystem sandbox. |
 | `completion_contract` | State the deliverables, validation commands, permitted incomplete items, final report format, and that narrative output should follow the task language. Preserve paths, commands, identifiers, and machine tokens verbatim. |
-| `background` | Default to `true` so the primary agent may continue independent work. |
+| `background` | Default to `true` so the primary agent may continue independent work; it returns a compact submission receipt. Set `false` only to wait synchronously for the full result body. |
 
 ## Routing contract
 
@@ -65,12 +65,20 @@ Bounded write task:
 
 For dependent or path-overlapping work, change `execution` to `fifo` and submit the next task only after accepting its predecessor.
 
+Compact collection flow:
+
+1. After `cursor_do(background=true)`, save the compact receipt's `task_id`.
+2. Poll `cursor_status(task_id)` with its default compact view while the task is active.
+3. Once terminal, call `cursor_status(task_id, detail="full")` to retrieve the full retained result and record receipt. Repeat explicit full reads are allowed while the task record remains retained.
+
 ## Identity and collection contract
 
 - `task_id` is the stable identity used by the primary agent to query and summarize a task. Save it immediately after dispatch.
 - `agent_id` binds a task to one specific Agents Window session when Bridge publishes it. `parallel_agent` always needs this identity. FIFO may also publish one; if it does not, do not assume a safe Stop target.
-- Determine task state only through `cursor_status(task_id)`, not the currently selected chat or latest visible response.
-- A collected result should include at least task state, summary, changed files, validation performed, failures or blockers, and the raw Cursor response.
+- Determine task state only through `cursor_status(task_id)`, not the currently selected chat or latest visible response. Its default compact view never returns a result body or records receipt.
+- After a terminal state, use `cursor_status(task_id, detail="full")` to retrieve the complete retained result and record explicit receipt. A collected result should include at least task state, summary, changed files, validation performed, failures or blockers, and the raw Cursor response.
+- `cursor_task_control` returns an action and compact task-state summary without a result body or implicit receipt. Retrieve a terminal result afterward through explicit full task status.
+- `cursor_session_control(action=collect_result)` always returns the full session reply.
 - Do not require a unique completion marker or minimum response length. Bridge determines completion from Agent state, stopped generation, and response stability.
 
 ### State table
@@ -78,15 +86,15 @@ For dependent or path-overlapping work, change `execution` to `fifo` and submit
 | State or phase | Primary-agent action |
 |---|---|
 | `queued/submitting/running/collecting` | Keep the original task and continue polling by `task_id`. More than two minutes is not a failure. |
-| `completed` | Read the raw response, then inspect the real diff, allowed paths, and completion contract. |
+| `completed` | Call `cursor_status(task_id, detail="full")` to read the raw response, then inspect the real diff, allowed paths, and completion contract. |
 | `failed` | Read the explicit error and determine whether the Cursor Agent actually failed before deciding to rework. |
 | `needs_attention/orphaned` with bound `agent_id` | Preserve path ownership and explicitly call `cursor_task_control(action=reap)` for the same in-memory task. Do not resubmit automatically. |
 | FIFO or unbound orphan | A global reservation blocks all new delegation. If an `agent_id` was published, use targeted `cancel`. Otherwise manually verify Cursor has stopped, then use explicitly acknowledged `abandon`; there is no safe `reap` target. |
-| `terminal_uncollected` | Agent History is stably terminal but the final response extraction failed. Keep the reservation and retry explicit `reap`; do not release on one DOM failure. |
+| `terminal_uncollected` | Agent History is stably terminal but the final response extraction failed. Keep the reservation and retry explicit `reap`; after recovery, use full task status to retrieve the result. Do not release on one DOM failure. |
 | `cancelled` | The exact Agent Stop action or an unsent queued cancellation was confirmed; the reservation is released. |
 | `abandoned` | The reservation was explicitly released without proof that the underlying Agent stopped. Treat the warning as live risk and inspect workspace changes before any overlapping write. |
 
-For an R6-style false negative, continue querying the original `task_id` when Agent History already contains a complete final response but automatic collection has not finished. Bridge should retry extraction against the original `agent_id`. Do not work around collection by requiring a longer reply, injecting a completion marker, or submitting the same task again.
+For an R6-style false negative, continue compact polling of the original `task_id` when Agent History already contains a complete final response but automatic collection has not finished. Bridge should retry extraction against the original `agent_id`; once terminal, use explicit full task status. Do not work around collection by requiring a longer reply, injecting a completion marker, or submitting the same task again.
 
 ## Primary-agent acceptance contract
 
@@ -106,5 +114,5 @@ Cursor's completion statement means only that delegated execution ended; it is n
 - Stop automatic integration when parallel tasks conflict and return the batch to primary-agent review.
 - If Agent History or the response DOM is temporarily unreadable, let Bridge wait and retry against the same `agent_id`. Enter `needs_attention` after persistent failure; do not incorrectly mark the task complete or create a duplicate Agent.
 - For a bound orphan, use `reap` before `cancel`. `cancel` requires the exact `expected_agent_id` and only releases after stable Stop evidence. `abandon` requires explicit confirmation, a reason, acknowledgement that the Agent may still write, and the exact `expected_agent_id` when one is bound.
-- `cursor_status` is a pure snapshot. Reconciliation happens only through explicit `cursor_task_control`.
+- Default compact `cursor_status` is a pure snapshot. `cursor_status(task_id, detail="full")` is the explicit result-receipt operation; reconciliation still happens only through explicit `cursor_task_control`.
 - Task records and reservations live only for the current Bridge MCP process. After restart, inspect Cursor Agent History and the workspace manually; persistent cross-process task leases are outside the current contract.