pi-cursor-bridge 0.2.5 → 0.2.6

package/.codex-plugin/plugin.json

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

package/README.md

@@ -12,6 +12,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.
 
-Pi wrapper 0.2.5 embeds Cursor Bridge 6.0.5, including Cursor 3.21 model-provider alias matching and `reasoning_effort` verification for Grok 4.7/high. Its result contract returns a compact receipt for background `cursor_do` work: poll `cursor_status(task_id)` normally, retrieve the terminal raw reply with `cursor_status(task_id, detail="result")`, check `isError` before using its content, and use `detail="full"` only when diagnostics are needed. 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.6 embeds Cursor Bridge 6.0.6, including Cursor 3.21 model-provider alias matching and `reasoning_effort` verification for Grok 4.7/high. Its result contract returns a compact receipt for background `cursor_do` work: poll `cursor_status(task_id)` normally, retrieve the terminal raw reply with `cursor_status(task_id, detail="result")`, check `isError` before using its content, and use `detail="full"` only when diagnostics are needed. 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

@@ -12989,8 +12989,8 @@ function withLifecycle(result, mode, extra = {}) {
   };
 }
 async function ensureCursorRunning(options = {}) {
-  const bindingFile = options.workspaceFile || resolveWorkspaceBindingFile();
-  const bindingKey = options.workspaceKey || resolveWorkspaceBindingKey();
+  const bindingFile = Object.hasOwn(options, "workspaceFile") ? options.workspaceFile : resolveWorkspaceBindingFile();
+  const bindingKey = options.workspaceKey || resolveWorkspaceBindingKey(process.env, { cwd: options.adapterStartCwd ?? process.cwd() });
   const persistedBinding = readWorkspaceBinding(bindingFile, bindingKey);
   const hostProjectPath = resolveClaudeProjectPath();
   const projectPath = Object.hasOwn(options, "projectPath") ? options.projectPath : resolveProjectPath(persistedBinding && persistedBinding.projectPath || process.env.CURSOR_PROJECT_PATH, {
@@ -22985,7 +22985,7 @@ function updateCursorSessionRegistry(filePath, mutator, options = {}) {
 // server.mjs
 init_cursor_ensure_core();
 init_lifecycle_paths();
-var PLUGIN_VERSION = "6.0.5";
+var PLUGIN_VERSION = "6.0.6";
 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);
@@ -24282,12 +24282,12 @@ var CursorBridge = class {
     this.runtimeModeSource = options.runtimeMode !== void 0 ? "constructor" : persistedRuntimeMode ? "persistent" : process.env.CURSOR_BRIDGE_RUNTIME_MODE ? "environment" : "default";
     this.runtimeModeScope = persistedRuntimeMode ? "persistent" : options.runtimeMode !== void 0 ? "constructor" : process.env.CURSOR_BRIDGE_RUNTIME_MODE ? "environment" : "default";
     this.workspaceFile = options.workspaceFile === null ? null : resolve8(options.workspaceFile || resolveWorkspaceBindingFile());
-    this.workspaceKey = options.workspaceKey || resolveWorkspaceBindingKey();
+    this.workspaceKey = options.workspaceKey || resolveWorkspaceBindingKey(process.env, { cwd: this.adapterStartCwd });
     const persistedWorkspace = options.projectPath === void 0 ? readWorkspaceBinding(this.workspaceFile, this.workspaceKey) : null;
     this.projectPath = options.projectPath !== void 0 ? resolve8(String(options.projectPath)) : persistedWorkspace && persistedWorkspace.projectPath || null;
     this.workspaceSource = options.projectPath !== void 0 ? "constructor" : persistedWorkspace ? "persistent_init" : "auto_detect";
     this.workspaceUpdatedAt = persistedWorkspace && persistedWorkspace.updatedAt || null;
-    this.workspaceConfirmationRequired = this.workspaceKey === "default" && !!persistedWorkspace;
+    this.workspaceConfirmationRequired = this.workspaceKey === "default" && options.projectPath === void 0;
     this.modelPreferencesFile = options.modelPreferencesFile === null ? null : resolve8(options.modelPreferencesFile || resolveCursorModelPreferencesFile());
     this.modelPreferences = readCursorModelPreferences(this.modelPreferencesFile);
     this.sessionFile = options.sessionFile === null ? null : resolve8(options.sessionFile || resolveCursorSessionRegistryFile());
@@ -24303,6 +24303,8 @@ var CursorBridge = class {
     this.activeParallel = /* @__PURE__ */ new Map();
     this.currentJob = null;
     this._uiTail = Promise.resolve();
+    this._workspaceTail = Promise.resolve();
+    this._workspacePending = 0;
     this.parallelRestoreAgentId = null;
     this.parallelRestoreTargetId = null;
   }
@@ -24310,6 +24312,8 @@ var CursorBridge = class {
     const resolvedProjectPath = this.projectPath || this._lastLifecycle && this._lastLifecycle.projectPath || null;
     return {
       workspaceKey: this.workspaceKey,
+      workspaceIdentitySource: this.workspaceKey === "default" ? "unavailable" : this.workspaceKey.split(":")[0],
+      workspaceBusy: this._workspacePending > 0,
       workspaceConfirmationRequired: this.workspaceConfirmationRequired,
       workspaceBindingWarning: this.workspaceConfirmationRequired ? "This adapter has no host workspace identity. Run cursor_init with the intended project before using its shared saved binding." : null,
       projectPath: resolvedProjectPath,
@@ -24692,8 +24696,12 @@ var CursorBridge = class {
     if (!["reconcile", "collect_result", "close", "forget", "abandon"].includes(action)) {
       throw cursorSessionError("SESSION_ACTION_UNSUPPORTED", "expected reconcile, collect_result, close, forget, or abandon");
     }
-    if (action === "reconcile") return this._reconcileSession(id);
-    if (action === "collect_result") return this._reconcileSession(id, { collectResult: true });
+    if (action === "reconcile" || action === "collect_result") {
+      return this._withWorkspaceAdmission(() => {
+        this._assertWorkspaceConfirmed();
+        return this._reconcileSession(id, { collectResult: action === "collect_result" });
+      });
+    }
     let result;
     updateCursorSessionRegistry(this.sessionFile, (registry2) => {
       const session = registry2.sessions[id];
@@ -24746,6 +24754,10 @@ var CursorBridge = class {
     return result;
   }
   async initializeWorkspace(projectPath) {
+    const result = await this._withWorkspaceAdmission(() => this._initializeWorkspace(projectPath));
+    return { ...result, workspaceBusy: this._workspacePending > 0 };
+  }
+  async _initializeWorkspace(projectPath) {
     if (this._healing) await this._healing.catch(() => {
     });
     if (this.busy || this.activeParallel.size > 0 || this.queue.length > 0) {
@@ -24971,19 +24983,23 @@ var CursorBridge = class {
     if (!text) throw new Error("query must not be empty");
     if (text.length > 2e4) throw new Error("query exceeds the 20,000-character limit");
     const requestContext = normalizeRequestContext(options.requestContext);
-    this._assertWorkspaceConfirmed();
-    if (this._hasGlobalReservation()) {
-      throw new Error("A global Cursor reservation has an unconfirmed Stop state; resolve blockingTaskIds from cursor_status first");
-    }
-    await this._ensureCursor();
-    const job = this._enqueue("context_engine", buildContextEnginePrompt(text, requestContext), {
-      requestContext,
-      timeoutMs: QUERY_TIMEOUT,
-      newChat: true,
-      execution: "fifo",
-      readOnly: true,
-      allowedPaths: [],
-      modelPreference: this._modelPreferenceFor("cce")
+    const job = await this._withWorkspaceAdmission(async () => {
+      this._assertWorkspaceConfirmed(options.workspacePath);
+      if (this._hasGlobalReservation()) {
+        throw new Error("A global Cursor reservation has an unconfirmed Stop state; resolve blockingTaskIds from cursor_status first");
+      }
+      await this._ensureCursor();
+      this._assertWorkspaceConfirmed(options.workspacePath);
+      return this._enqueue("context_engine", buildContextEnginePrompt(text, requestContext), {
+        requestContext,
+        timeoutMs: QUERY_TIMEOUT,
+        newChat: true,
+        execution: "fifo",
+        readOnly: true,
+        allowedPaths: [],
+        modelPreference: this._modelPreferenceFor("cce"),
+        projectPath: this._lastLifecycle?.projectPath || this.projectPath || null
+      });
     });
     const result = normalizeCceSearchResult(await job.promise);
     this._markTaskResultCollected(job);
@@ -24997,6 +25013,14 @@ var CursorBridge = class {
     return this.contextEngine(query);
   }
   async doTask(prompt, options = {}) {
+    const admitted = await this._withWorkspaceAdmission(() => this._prepareTask(prompt, options));
+    if (admitted.duplicate) return admitted.response;
+    const job = admitted.job;
+    if (options.background !== false) return this._compactTaskView(job);
+    await job.promise;
+    return this._collectedTaskView(job);
+  }
+  async _prepareTask(prompt, options = {}) {
     if (!this.delegationEnabled) {
       throw new Error("cursor_do is disabled by CURSOR_BRIDGE_DELEGATION=off; restart the MCP server without that setting to enable delegation");
     }
@@ -25004,7 +25028,7 @@ var CursorBridge = class {
     if (!text) throw new Error("prompt must not be empty");
     if (text.length > 1e5) throw new Error("prompt exceeds the 100,000-character limit");
     const requestContext = normalizeRequestContext(options.requestContext);
-    this._assertWorkspaceConfirmed();
+    this._assertWorkspaceConfirmed(options.workspacePath);
     if (this._hasGlobalReservation()) {
       throw new Error("A global Cursor reservation has an unconfirmed Stop state; no new task may be submitted until it is explicitly recovered or released");
     }
@@ -25049,6 +25073,7 @@ var CursorBridge = class {
       throw cursorSessionError("SESSION_SCOPE_REQUIRED", "repeat read_only=true or an allowed_paths subset for every continued turn");
     }
     await this._ensureCursor();
+    this._assertWorkspaceConfirmed(options.workspacePath);
     const projectPath = this._lastLifecycle && this._lastLifecycle.projectPath || this.projectPath || null;
     if (sessionMode !== "isolated" && !projectPath) {
       throw cursorSessionError("SESSION_WORKSPACE_REQUIRED", "initialize one workspace before creating or continuing a session");
@@ -25089,7 +25114,8 @@ 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, ...options.background === false ? this._collectedTaskView(existing) : this._compactTaskView(existing) } : { duplicate: true, ...this._sessionView(session) };
+        const response = existing ? { duplicate: true, ...options.background === false ? this._collectedTaskView(existing) : this._compactTaskView(existing) } : { duplicate: true, ...this._sessionView(session) };
+        return { duplicate: true, response };
       }
     }
     const job = this._enqueue("do", fullPrompt, {
@@ -25113,9 +25139,7 @@ var CursorBridge = class {
       agentId: sessionMode === "continue" ? session && session.agentId : null,
       agentLabel: sessionMode === "continue" ? session && session.agentLabel : null
     });
-    if (options.background !== false) return this._compactTaskView(job);
-    await job.promise;
-    return this._collectedTaskView(job);
+    return { job };
   }
   _assertNoParallelPathConflict(allowedPaths) {
     if (this._hasGlobalReservation()) {
@@ -25305,6 +25329,17 @@ var CursorBridge = class {
     });
     return run;
   }
+  // Serialize target changes with preparation through enqueue, never with a running Agent.
+  // The UI lock cannot serve this purpose: initialization may acquire it to register a project.
+  _withWorkspaceAdmission(fn) {
+    this._workspacePending++;
+    const run = this._workspaceTail.then(fn, fn).finally(() => {
+      this._workspacePending--;
+    });
+    this._workspaceTail = run.catch(() => {
+    });
+    return run;
+  }
   _withJobLock(job, fn) {
     const previous = job.controlTail || Promise.resolve();
     const run = previous.then(fn, fn);
@@ -25336,6 +25371,8 @@ var CursorBridge = class {
           reason: "adapter-heal",
           runtimeMode: this.runtimeMode,
           adapterStartCwd: this.adapterStartCwd,
+          workspaceKey: this.workspaceKey,
+          workspaceFile: this.workspaceFile,
           ...this.projectPath ? { projectPath: this.projectPath } : {}
         });
         this._lastLifecycle = lifecycleFromEnsureResult(rr, this.runtimeMode);
@@ -27537,6 +27574,8 @@ var CursorBridge = class {
       pluginVersion: PLUGIN_VERSION,
       statusPath: "json-list",
       workspaceKey: workspace.workspaceKey,
+      workspaceIdentitySource: workspace.workspaceIdentitySource,
+      workspaceBusy: workspace.workspaceBusy,
       workspaceConfirmationRequired: workspace.workspaceConfirmationRequired,
       workspaceBindingWarning: workspace.workspaceBindingWarning,
       projectPath: workspace.projectPath,
@@ -27568,9 +27607,45 @@ var CursorBridge = class {
       cursorPid: lifecycle.cursorPid
     };
   }
-  _assertWorkspaceConfirmed() {
+  _workspaceRecoveryError(code, message, expectedProjectPath = null) {
+    const error2 = new Error(`${code}: ${message}`);
+    error2.code = code;
+    error2.workspaceRecovery = {
+      workspaceKey: this.workspaceKey,
+      currentProjectPath: this._lastLifecycle?.projectPath || this.projectPath || null,
+      expectedProjectPath,
+      tool: "cursor_init",
+      arguments: expectedProjectPath ? { path: expectedProjectPath } : null,
+      requiresIdle: true,
+      retrySafe: true,
+      submissionStarted: false,
+      nextStep: "Read cursor_status. When idle with no blocking tasks, run cursor_init with the caller's intended absolute project path, verify ready and the exact path, then retry this unsent request once. Never infer the target from a saved default binding or repository name."
+    };
+    return error2;
+  }
+  _assertWorkspaceConfirmed(workspacePath) {
+    let expected = null;
+    if (workspacePath !== void 0) {
+      if (typeof workspacePath !== "string" || !isAbsoluteWorkspacePath(workspacePath)) {
+        throw cursorSessionError("WORKSPACE_PATH_INVALID", "workspace_path must be an absolute project directory or .code-workspace path");
+      }
+      expected = normalizeWorkspacePath(workspacePath);
+    }
     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.");
+      throw this._workspaceRecoveryError("WORKSPACE_CONFIRMATION_REQUIRED", "this adapter has no host workspace identity. Run cursor_init with the intended project before submitting work; a saved default path is not confirmation.", expected);
+    }
+    if (expected) {
+      const current = this._lastLifecycle?.projectPath || this.projectPath;
+      if (!current) {
+        throw this._workspaceRecoveryError("WORKSPACE_INITIALIZATION_REQUIRED", "Run cursor_init with workspace_path before submitting work.", expected);
+      }
+      const canonical = (path) => {
+        const normalized = normalizeWorkspacePath(path);
+        return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+      };
+      if (canonical(current) !== canonical(expected)) {
+        throw this._workspaceRecoveryError("WORKSPACE_MISMATCH", "workspace_path does not match the current binding. Run cursor_init with the intended project when idle; no work was submitted.", expected);
+      }
     }
   }
   _ensureTaskCapacity() {
@@ -27618,10 +27693,10 @@ var CursorBridge = class {
       ...this.runtimeModeView(),
       ...this.modelPreferencesView(),
       ...this.sessionRegistryView(),
-      busy: uiBusy || parallelRunning > 0 || this.queue.length > 0,
+      busy: uiBusy || parallelRunning > 0 || this.queue.length > 0 || this._workspacePending > 0,
       uiBusy,
       parallelRunning,
-      idle: !uiBusy && parallelRunning === 0 && this.queue.length === 0,
+      idle: !uiBusy && parallelRunning === 0 && this.queue.length === 0 && this._workspacePending === 0,
       queued: this.queue.length,
       blockingTaskIds: [...this.activeParallel.values()].filter((job) => !isTerminalTask(job)).map((job) => job.id),
       globallyBlocked: globalBlocked,
@@ -27650,10 +27725,10 @@ var CursorBridge = class {
       }
     } : {
       ...this._compactStatusCommon(),
-      busy: uiBusy || parallelRunning > 0 || this.queue.length > 0,
+      busy: uiBusy || parallelRunning > 0 || this.queue.length > 0 || this._workspacePending > 0,
       uiBusy,
       parallelRunning,
-      idle: !uiBusy && parallelRunning === 0 && this.queue.length === 0,
+      idle: !uiBusy && parallelRunning === 0 && this.queue.length === 0 && this._workspacePending === 0,
       queued: this.queue.length,
       blockingTaskIds: [...this.activeParallel.values()].filter((job) => !isTerminalTask(job)).map((job) => job.id),
       globallyBlocked: globalBlocked,
@@ -27678,6 +27753,7 @@ function buildSearchInputSchema() {
     type: "object",
     properties: {
       query: { type: "string", description: "Describe the behavior, concept, symbol relationship, or ownership boundary to locate. State intent instead of guessing a directory." },
+      workspace_path: WORKSPACE_PATH_SCHEMA,
       request_context: REQUEST_CONTEXT_SCHEMA
     },
     required: ["query"]
@@ -27699,6 +27775,10 @@ var REQUEST_CONTEXT_SCHEMA = {
     source: { type: "string", enum: ["user", "model", "mixed", "unknown"], description: "user for explicitly supplied user requirements, model for model-authored tasks/inferences, mixed when the prompt clearly separates both; unknown when not established." }
   }
 };
+var WORKSPACE_PATH_SCHEMA = {
+  type: "string",
+  description: "The caller's intended absolute project directory or .code-workspace path. Supply it when known to reject stale or cross-task bindings before sending. This is a target assertion, not an automatic workspace switch. On a workspace confirmation, initialization, or mismatch error, check idle status, run cursor_init with this path, verify ready, and retry once."
+};
 function buildToolDefinitions(bridgeInstance) {
   return [
     {
@@ -27724,6 +27804,7 @@ function buildToolDefinitions(bridgeInstance) {
         type: "object",
         properties: {
           prompt: { type: "string", description: "The task Cursor should receive. State the goal, boundaries, and what a complete result looks like." },
+          workspace_path: WORKSPACE_PATH_SCHEMA,
           request_context: REQUEST_CONTEXT_SCHEMA,
           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." },
@@ -27816,29 +27897,35 @@ var server = new Server(
   { capabilities: { tools: { listChanged: true } } }
 );
 async function ensureBridgeCursor(targetBridge, reason) {
-  targetBridge._refreshPersistedRuntimeMode();
-  const { ensureCursorRunning: ensureCursorRunning2 } = await Promise.resolve().then(() => (init_launch_cursor(), launch_cursor_exports));
-  const r = await ensureCursorRunning2({
-    reason,
-    runtimeMode: targetBridge.runtimeMode,
-    adapterStartCwd: targetBridge.adapterStartCwd,
-    ...targetBridge.projectPath ? { projectPath: targetBridge.projectPath } : {}
+  return targetBridge._withWorkspaceAdmission(async () => {
+    targetBridge._refreshPersistedRuntimeMode();
+    const { ensureCursorRunning: ensureCursorRunning2 } = await Promise.resolve().then(() => (init_launch_cursor(), launch_cursor_exports));
+    const r = await ensureCursorRunning2({
+      reason,
+      runtimeMode: targetBridge.runtimeMode,
+      adapterStartCwd: targetBridge.adapterStartCwd,
+      workspaceKey: targetBridge.workspaceKey,
+      workspaceFile: targetBridge.workspaceFile,
+      // Prewarming Cursor is not permission to open another task's saved default project.
+      ...targetBridge.workspaceConfirmationRequired ? { projectPath: null } : targetBridge.projectPath ? { projectPath: targetBridge.projectPath } : {}
+    });
+    targetBridge._lastLifecycle = lifecycleFromEnsureResult(r, targetBridge.runtimeMode);
+    if (targetBridge.runtimeMode === "minimal") {
+      targetBridge._lastPresentation = r.presentation ? { ...r.presentation, at: (/* @__PURE__ */ new Date()).toISOString() } : await targetBridge.applyRuntimePresentation("hide");
+    }
+    return r;
   });
-  targetBridge._lastLifecycle = lifecycleFromEnsureResult(r, targetBridge.runtimeMode);
-  if (targetBridge.runtimeMode === "minimal") {
-    targetBridge._lastPresentation = r.presentation ? { ...r.presentation, at: (/* @__PURE__ */ new Date()).toISOString() } : await targetBridge.applyRuntimePresentation("hide");
-  }
-  return r;
 }
 function toolErrorResult(error2) {
   const message = error2 instanceof Error ? error2.message : String(error2);
-  if (error2 && (error2.uiDiagnostic || error2.modelSelection || error2.pickerRead || error2.cdp)) {
+  if (error2 && (error2.uiDiagnostic || error2.modelSelection || error2.pickerRead || error2.cdp || error2.workspaceRecovery)) {
     const payload = {
       error: { code: error2.code || error2.uiDiagnostic?.code || "CURSOR_BRIDGE_ERROR", message },
       ...error2.uiDiagnostic ? { uiDiagnostic: error2.uiDiagnostic } : {},
       ...error2.modelSelection ? { modelSelection: error2.modelSelection } : {},
       ...error2.pickerRead ? { pickerRead: error2.pickerRead } : {},
-      ...error2.cdp ? { cdp: error2.cdp } : {}
+      ...error2.cdp ? { cdp: error2.cdp } : {},
+      ...error2.workspaceRecovery ? { workspaceRecovery: error2.workspaceRecovery } : {}
     };
     return {
       content: [{ type: "text", text: JSON.stringify(payload, null, 2) }],
@@ -27859,11 +27946,12 @@ server.setRequestHandler(CallToolRequestSchema, async (request2) => {
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
     if (name === "cursor_context_engine" || name === "cursor_search" || name === "cursor_search_deep") {
-      const result = await bridge.contextEngine(String(args && args.query || ""), { requestContext: args && args.request_context });
+      const result = await bridge.contextEngine(String(args && args.query || ""), { requestContext: args && args.request_context, workspacePath: args && args.workspace_path });
       return { content: [{ type: "text", text: String(result) }] };
     }
     if (name === "cursor_do") {
       const result = await bridge.doTask(String(args && args.prompt || ""), {
+        workspacePath: args && args.workspace_path,
         requestContext: args && args.request_context,
         background: !args || args.background !== false,
         execution: args && args.execution,

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.2.5",
+  packageVersion: "0.2.6",
   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.2.5",
+  "version": "0.2.6",
   "description": "Windows only. 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": "6.0.5"
+    "embeddedProductVersion": "6.0.6"
   }
 }

package/skills/cce-routing/SKILL.md

@@ -20,7 +20,7 @@ Call `cursor_context_engine` when one or more of these are true:
 
 Prefer one CCE investigation over starting an Explore subagent merely to locate or understand project code. Let Cursor choose focused or extended depth from what it discovers.
 
-When these semantic conditions match, make CCE the first project-discovery surface. Do not establish the answer through generic context-mode, grep, or blind local exploration before trying CCE. If Claude Code denies an initial context-mode collection call with a CCE routing message, call `cursor_context_engine` once instead of retrying another `ctx_*` tool. A failed, denied, unavailable, or `NOT_FOUND` CCE attempt releases this priority and allows a bounded local fallback.
+When these semantic conditions match, make CCE the first project-discovery surface. Do not establish the answer through generic context-mode, grep, or blind local exploration before trying CCE. If Claude Code denies an initial context-mode collection call with a CCE routing message, call `cursor_context_engine` once instead of retrying another `ctx_*` tool. A failed, denied, unavailable, or `NOT_FOUND` CCE attempt releases this priority and allows a bounded local fallback. A pre-send workspace-confirmation error may be recoverable; handle it below before falling back.
 
 ## Keep deterministic work local
 
@@ -30,10 +30,28 @@ Do not call CCE when any of these apply:
 - The needed code is already present in the current context.
 - The work is a trivial single-file edit or only requires running tests, inspecting logs, checking a build, or examining Git state.
 - The question concerns external libraries, APIs, current documentation, or the public web.
-- The user opted out of Cursor, CCE is unavailable, or the workspace is not initialized.
+- The user opted out of Cursor or CCE is unavailable.
 
 Do not submit the same lookup to CCE and another semantic system in parallel. Use a second evidence surface only to close a specific gap or verify a consequential claim.
 
+## Bind a known workspace before sending
+
+Pass the intended absolute `workspace_path` to `cursor_context_engine` when the installed schema supports it. Use the host-provided workspace root/current-task cwd unless the request explicitly targets another project. The field asserts the target before sending; it never switches or registers a project. Do not infer the target from a repository basename or a saved default binding.
+
+For an older schema without `workspace_path`, use `cursor_status` to verify the exact ready project path before sending. `initialized=true` only shows that a binding exists; it does not prove the current request is confirmed for the intended workspace. `cursor_init` is the only explicit operation that may initialize, register, or switch a workspace.
+
+If no target is known, do not infer or add `workspace_path`, and never call `cursor_init` for a guessed path. Existing safe host bindings may still be used; a workspace-confirmation error without a known target cannot use this recovery and should be reported before any necessary local fallback.
+
+## Recover one known workspace
+
+For a pre-send `WORKSPACE_CONFIRMATION_REQUIRED`, `WORKSPACE_INITIALIZATION_REQUIRED`, or `WORKSPACE_MISMATCH` error with a known target:
+
+1. Call `cursor_status`. Continue only when it confirms idle, no queued or blocking work, and `workspaceBusy=false` when that field is exposed.
+2. Call `cursor_init` with that exact absolute path. Require `ready=true`, `workspaceConfirmationRequired=false`, and the exact `projectPath`; in Agents Window also check `workspaceBinding.ok`, the local file-URI identity and workspace ID.
+3. Retry the original CCE query once.
+
+Do not treat these errors as CCE unavailability before this recovery. Do not initialize when status is busy, identity is ambiguous, `needs_attention` is present, or send state is uncertain; explain the condition and use only the necessary local fallback. Do not cancel other work, change the model, or retry in a loop.
+
 ## Submit one natural-language intent
 
 Call `cursor_context_engine` once with the question's real intent. Include a known symbol, subsystem, or path only when it is a useful lead.

package/skills/cursor-delegate/SKILL.md

@@ -9,6 +9,14 @@ Use Cursor as an execution partner. Keep direction, scope decisions, risk owners
 
 Declare `request_context` for each call: an AI caller uses `sender="model"`; set `source="user"` for explicitly supplied user requirements, `"model"` for your own task/inference, or `"mixed"` when both appear. In mixed prompts, label user-confirmed requirements separately from your additions. Use `"unknown"` where provenance is unavailable; a user asking you to use Cursor does not make your authored message user-authored. These labels are declarations, not authentication or extra permission, and do not carry over to later session turns.
 
+## Bind a known workspace
+
+For CCE or `cursor_do`, pass the intended absolute `workspace_path` when the installed tool schema supports it. Use the host-provided workspace root/current-task cwd unless the request explicitly targets another project. The field is a pre-send assertion: it never selects, switches, or registers a workspace. Do not infer the target from a repository basename or a saved default binding.
+
+With an older schema, use `cursor_status` to verify the exact ready project path before sending. `initialized=true` only means a binding exists; it does not confirm the workspace for this request. `cursor_init` remains the only explicit initialization, registration, or switch operation.
+
+On pre-send `WORKSPACE_CONFIRMATION_REQUIRED`, `WORKSPACE_INITIALIZATION_REQUIRED`, or `WORKSPACE_MISMATCH` with a known target, first call `cursor_status`. Only if it confirms idle, no queued or blocking work, and `workspaceBusy=false` when exposed, call `cursor_init` for the exact path. Require `ready=true`, `workspaceConfirmationRequired=false`, and the exact `projectPath`; in Agents Window also check `workspaceBinding.ok`, the local file-URI identity and workspace ID. Retry the original CCE query or `cursor_do` submission once. Do not run this recovery for `needs_attention`, uncertain send state, busy status, or ambiguous identity; report the condition and use the necessary local fallback. Do not cancel other work, change model settings, or retry in a loop.
+
 ## Respect execution controls
 
 - Do not call `cursor_do` when the user explicitly says not to use Cursor or not to delegate. A direct user opt-out always wins.
@@ -75,7 +83,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` 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.
+3. Call `cursor_do` with `background=true` and save its compact submission receipt. Include `workspace_path` when the exact target is known and the schema supports it. 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.