@runfusion/fusion 0.76.0-beta.3 → 0.77.0-beta.0

package/dist/plugins/fusion-plugin-cursor-runtime/bundled.js

@@ -5,6 +5,9 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/plugin-sdk-core-runtime-shim.mjs
+import { spawn } from "node:child_process";
+
 // ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.0_better-sqlite3@12.9.0_pg@8.22.0_postgres@3.4.9/node_modules/drizzle-orm/entity.js
 var entityKind = Symbol.for("drizzle:entityKind");
 var hasOwnEntityKind = Symbol.for("drizzle:hasOwnEntityKind");
@@ -1074,7 +1077,7 @@ function sql(strings, ...params) {
     return new SQL([new StringChunk(str)]);
   }
   sql2.raw = raw;
-  function join2(chunks, separator) {
+  function join5(chunks, separator) {
     const result = [];
     for (const [i, chunk] of chunks.entries()) {
       if (i > 0 && separator !== void 0) {
@@ -1084,7 +1087,7 @@ function sql(strings, ...params) {
     }
     return new SQL(result);
   }
-  sql2.join = join2;
+  sql2.join = join5;
   function identifier(value) {
     return new Name(value);
   }
@@ -4535,7 +4538,7 @@ var PgSelectQueryBuilderBase = class extends TypedQueryBuilder {
       const baseTableName = this.tableName;
       const tableName = getTableLikeName(table);
       for (const item of extractUsedTable(table)) this.usedTables.add(item);
-      if (typeof tableName === "string" && this.config.joins?.some((join2) => join2.alias === tableName)) {
+      if (typeof tableName === "string" && this.config.joins?.some((join5) => join5.alias === tableName)) {
         throw new Error(`Alias "${tableName}" is already used in this query`);
       }
       if (!this.isPartialSelect) {
@@ -5776,7 +5779,9 @@ __export(project_exports, {
   workflowSettings: () => workflowSettings,
   workflowSteps: () => workflowSteps,
   workflowWorkItems: () => workflowWorkItems,
-  workflows: () => workflows
+  workflows: () => workflows,
+  workspaceCoordinationLeases: () => workspaceCoordinationLeases,
+  workspaceLandIntents: () => workspaceLandIntents
 });
 var projectSchema = pgSchema(PROJECT_SCHEMA);
 var tasks = projectSchema.table("tasks", {
@@ -6043,6 +6048,9 @@ var tasks = projectSchema.table("tasks", {
   the gate is a full tasks-table scan. Sparse: most rows have NULL parent.
   */
   index("idxTasksSourceParentTaskId").on(t.sourceParentTaskId),
+  /* FNXC:TaskRecommendations 2026-08-13-22:23: duplicate intake filters source
+   * lineage on recommendation/agent creates; this sparse index avoids a task-table scan. */
+  index("idxTasksProjectSourceAgentId").on(t.projectId, t.sourceAgentId).where(sql`${t.sourceAgentId} IS NOT NULL`),
   // FNXC:EphemeralAgentTaskCreation 2026-07-30-12:00: proposal retries share one stable key, so the database—not a read-before-create race—enforces at-most-once materialization.
   uniqueIndex("uqTasksProjectProposalClaimId").on(t.projectId, t.proposalClaimId).where(sql`${t.proposalClaimId} IS NOT NULL`),
   /*
@@ -6277,6 +6285,52 @@ var distributedTaskIdReservations = projectSchema.table("distributed_task_id_res
   index("idxDistributedTaskIdReservationsPrefixStatus").on(t.prefix, t.status),
   index("idxDistributedTaskIdReservationsExpiry").on(t.status, t.expiresAt)
 ]);
+var workspaceCoordinationLeases = projectSchema.table("workspace_coordination_leases", {
+  projectId: text("project_id").notNull().default(sql`current_setting('fusion.project_id', true)`),
+  leaseKey: text("lease_key").notNull(),
+  kind: text("kind").notNull(),
+  ownerTaskId: text("owner_task_id").notNull(),
+  ownerNodeId: text("owner_node_id").notNull(),
+  ownerIncarnationId: text("owner_incarnation_id").notNull(),
+  ownerRunId: text("owner_run_id"),
+  fenceToken: bigint("fence_token", { mode: "bigint" }).notNull().default(sql`0`),
+  fenceRefName: text("fence_ref_name"),
+  fenceRefSha: text("fence_ref_sha"),
+  status: text("status").notNull(),
+  acquiredAt: text("acquired_at").notNull(),
+  renewedAt: text("renewed_at").notNull(),
+  expiresAt: text("expires_at").notNull(),
+  createdAt: text("created_at").notNull(),
+  updatedAt: text("updated_at").notNull()
+}, (t) => [
+  primaryKey({ columns: [t.projectId, t.leaseKey] }),
+  check("workspace_coordination_leases_kind_check", sql`${t.kind} IN ('acquire', 'land', 'merge-dispatch')`),
+  check("workspace_coordination_leases_status_check", sql`${t.status} IN ('held', 'released', 'expired')`),
+  index("idxWorkspaceCoordinationLeasesOwnerTask").on(t.projectId, t.ownerTaskId),
+  index("idxWorkspaceCoordinationLeasesOwnerNode").on(t.projectId, t.ownerNodeId),
+  index("idxWorkspaceCoordinationLeasesExpiry").on(t.status, t.expiresAt)
+]);
+var workspaceLandIntents = projectSchema.table("workspace_land_intents", {
+  projectId: text("project_id").notNull().default(sql`current_setting('fusion.project_id', true)`),
+  taskId: text("task_id").notNull(),
+  repoRelPath: text("repo_rel_path").notNull(),
+  remoteUrl: text("remote_url").notNull(),
+  integrationRef: text("integration_ref").notNull(),
+  intendedSha: text("intended_sha").notNull(),
+  expectedTip: text("expected_tip").notNull(),
+  fenceRefName: text("fence_ref_name").notNull(),
+  fenceRefSha: text("fence_ref_sha").notNull(),
+  ownerTaskId: text("owner_task_id").notNull(),
+  ownerNodeId: text("owner_node_id").notNull(),
+  ownerIncarnationId: text("owner_incarnation_id").notNull(),
+  fenceToken: bigint("fence_token", { mode: "bigint" }).notNull(),
+  status: text("status").notNull(),
+  resolvedSha: text("resolved_sha"),
+  resolution: text("resolution"),
+  createdAt: text("created_at").notNull(),
+  updatedAt: text("updated_at").notNull(),
+  resolvedAt: text("resolved_at")
+}, (t) => [primaryKey({ columns: [t.projectId, t.taskId, t.repoRelPath] }), check("workspace_land_intents_status_check", sql`${t.status} IN ('pending', 'recorded', 'abandoned')`), check("workspace_land_intents_resolution_check", sql`${t.resolution} IS NULL OR ${t.resolution} IN ('landed', 'not-landed')`), index("idxWorkspaceLandIntentsStatus").on(t.projectId, t.status)]);
 var symbolLocks = projectSchema.table("symbol_locks", {
   projectId: text("project_id").notNull().default(sql`current_setting('fusion.project_id', true)`),
   symbolKey: text("symbol_key").notNull(),
@@ -8851,6 +8905,11 @@ var DEFAULT_GLOBAL_SETTINGS = {
   Critical-action confirmation dialogs stay enabled by default. This global-only preference may opt an operator into primary/default auto-approval, but project settings cannot enable it for collaborators.
   */
   skipConfirmationDialogs: false,
+  /*
+  FNXC:QuickEntry 2026-08-16-03:15:
+  Quick Add keeps its historical Enter-to-submit behavior by default; only an operator's global preference may opt into newline-first entry.
+  */
+  quickAddSubmitOnEnter: true,
   language: void 0,
   defaultProvider: void 0,
   defaultCredentialInstanceId: void 0,
@@ -9313,9 +9372,6 @@ var DEFAULT_PROJECT_SETTINGS = {
    * New and unconfigured projects default AI merge to sync a dirty checked-out integration branch, restoring the legacy stash → fast-forward → restore landing behavior. Explicit persisted merger.allowDirtyLocalCheckoutSync values still win, and no existing-project migration stamps this default into storage.
    */
   merger: { mode: "ai", maxReviewPasses: 3, allowDirtyLocalCheckoutSync: true },
-  mergeDiffVolumeMinLines: void 0,
-  mergeDiffVolumeThreshold: void 0,
-  mergeDiffVolumeAllowlist: void 0,
   requiredChecks: void 0,
   mergeStrategyOverlapBehavior: "flip-to-prefer-branch",
   postMergeAuditMode: "warn",
@@ -10652,26 +10708,26 @@ function validateParallelism(nodes2, outgoing, nodesById) {
     }
     const joinsReached = /* @__PURE__ */ new Set();
     for (const edge of branchEdges) {
-      const join3 = walkBranchToJoin(edge.to, split.id, outgoing, nodesById);
-      if (!join3) {
+      const join6 = walkBranchToJoin(edge.to, split.id, outgoing, nodesById);
+      if (!join6) {
         throw new WorkflowIrError(`split '${split.id}' has a branch with no reachable matching join`);
       }
-      joinsReached.add(join3);
+      joinsReached.add(join6);
     }
     if (joinsReached.size !== 1) {
       throw new WorkflowIrError(`split '${split.id}' branches converge on more than one join`);
     }
     const joinId = [...joinsReached][0];
-    const join2 = nodesById.get(joinId);
-    const mode = join2.config?.mode;
+    const join5 = nodesById.get(joinId);
+    const mode = join5.config?.mode;
     if (mode && typeof mode === "object" && "quorum" in mode) {
       const n = mode.quorum;
       if (typeof n !== "number" || !Number.isInteger(n) || n < 1) {
-        throw new WorkflowIrError(`join '${join2.id}' quorum must be a positive integer`);
+        throw new WorkflowIrError(`join '${join5.id}' quorum must be a positive integer`);
       }
       if (n > branchEdges.length) {
         throw new WorkflowIrError(
-          `join '${join2.id}' quorum(${n}) exceeds the split's ${branchEdges.length} branches`
+          `join '${join5.id}' quorum(${n}) exceeds the split's ${branchEdges.length} branches`
         );
       }
     }
@@ -16243,18 +16299,18 @@ function canAgentTakeImplementationTaskForBacklogPickup(agent, task, options = {
 function canAgentTakeImplementationTask(agent, task, options) {
   return canAgentTakeImplementationTaskForBacklogPickup(agent, task, options);
 }
-function evaluateImplementationTaskBind(agent, task, context = {}) {
+function evaluateImplementationTaskBind(agent, task, context2 = {}) {
   if (!isImplementationTask(task)) {
     return { allowed: true };
   }
   if (!canAgentReceiveImplementationTasks(agent)) {
     return { allowed: false, reason: formatRoleMismatchReason(agent, task) };
   }
-  if (context.executorRoleOverride === true) {
+  if (context2.executorRoleOverride === true) {
     return { allowed: true };
   }
-  const explicit = context.explicitRouting === true;
-  const roleAllowed = explicit ? canAgentTakeImplementationTaskForExplicitRouting(agent, task) : canAgentTakeImplementationTask(agent, task, { allowEngineer: context.allowEngineer });
+  const explicit = context2.explicitRouting === true;
+  const roleAllowed = explicit ? canAgentTakeImplementationTaskForExplicitRouting(agent, task) : canAgentTakeImplementationTask(agent, task, { allowEngineer: context2.allowEngineer });
   return roleAllowed ? { allowed: true } : { allowed: false, reason: formatRoleMismatchReason(agent, task) };
 }
 var AgentTaskRoutingPolicyError = class extends Error {
@@ -16266,8 +16322,8 @@ var AgentTaskRoutingPolicyError = class extends Error {
   }
   code = "agent-task-routing-policy";
 };
-function assertImplementationTaskBindAllowed(agent, task, context = {}) {
-  const verdict = evaluateImplementationTaskBind(agent, task, context);
+function assertImplementationTaskBindAllowed(agent, task, context2 = {}) {
+  const verdict = evaluateImplementationTaskBind(agent, task, context2);
   if (!verdict.allowed) {
     throw new AgentTaskRoutingPolicyError(agent.id, task.id, verdict.reason);
   }
@@ -17966,10 +18022,6 @@ var AgentStore = class _AgentStore extends EventEmitter {
       };
       await this.writeAgent(updated);
       this.emit("agent:stateChanged", agentId, currentState, newState);
-      if (this.asyncLayer) try {
-        await appendAgentActivityEvent(this.asyncLayer, { type: "agent:state-changed", attributionClaim: resolveAgentActivityAttribution([{ id: agentId, provenance: "roster" }], "executor"), taskId: updated.taskId, occurredAt: updated.updatedAt, discriminator: updated.updatedAt, metadata: { fromState: currentState, toState: newState, source: "update" } });
-      } catch {
-      }
       this.emit("agent:updated", updated, currentState);
       return updated;
     });
@@ -18461,10 +18513,10 @@ var AgentStore = class _AgentStore extends EventEmitter {
     return agents2;
   }
   /*
-  FNXC:MemoryAgent 2026-08-11-09:41:
-  Memory Keeper is custom because it is not a workflow-stage principal. Unlike the four routed
-  owners its heartbeat is enabled, while auto-claim remains off because it only maintains memory.
-  This runs during init, where createAgent name collisions would abort startup; preflight probes,
+  FNXC:MemoryAgent 2026-08-16-02:31:
+  Memory Keeper is custom because it is not a workflow-stage principal. Its heartbeat defaults off
+  until an operator opts in, while auto-claim remains off because it only maintains memory. This
+  runs during init, where createAgent name collisions would abort startup; preflight probes,
   a fallback name, a null degraded result, and the init-side catch keep an operator's same-named
   agent untouched and the project runnable.
   */
@@ -18490,7 +18542,13 @@ var AgentStore = class _AgentStore extends EventEmitter {
             roles: [...BUILTIN_MEMORY_AGENT_DEFAULT.roles],
             title: BUILTIN_MEMORY_AGENT_DEFAULT.title,
             metadata: { [BUILTIN_MEMORY_AGENT_PROVENANCE_KEY]: true },
-            runtimeConfig: { enabled: true, autoClaimRelevantTasks: false, heartbeatIntervalMs: 36e5 },
+            /*
+            FNXC:MemoryAgent 2026-08-16-02:31:
+            Memory consolidation is opt-in: newly provisioned Memory Keepers must not begin
+            hourly autonomous heartbeats until an operator enables the existing heartbeat toggle.
+            Keep auto-claim off and the one-hour interval ready for that later opt-in.
+            */
+            runtimeConfig: { enabled: false, autoClaimRelevantTasks: false, heartbeatIntervalMs: 36e5 },
             instructionsText: BUILTIN_MEMORY_AGENT_DEFAULT.instructionsText,
             soul: BUILTIN_MEMORY_AGENT_DEFAULT.soul,
             bundleConfig: { ...BUILTIN_MEMORY_AGENT_DEFAULT.bundleConfig, files: [...BUILTIN_MEMORY_AGENT_DEFAULT.bundleConfig.files] }
@@ -18505,7 +18563,9 @@ var AgentStore = class _AgentStore extends EventEmitter {
         return owner;
       }
       const metadata = { ...owner.metadata ?? {}, [BUILTIN_MEMORY_AGENT_PROVENANCE_KEY]: true };
-      const runtimeConfig = { ...owner.runtimeConfig ?? {}, enabled: true, autoClaimRelevantTasks: false, heartbeatIntervalMs: 36e5 };
+      const currentRuntimeConfig = owner.runtimeConfig ?? {};
+      const enabled = typeof currentRuntimeConfig.enabled === "boolean" ? currentRuntimeConfig.enabled : false;
+      const runtimeConfig = currentRuntimeConfig.enabled === enabled && currentRuntimeConfig.autoClaimRelevantTasks === false && currentRuntimeConfig.heartbeatIntervalMs === DEFAULT_AGENT_HEARTBEAT_INTERVAL_MS ? currentRuntimeConfig : { ...currentRuntimeConfig, enabled, autoClaimRelevantTasks: false, heartbeatIntervalMs: DEFAULT_AGENT_HEARTBEAT_INTERVAL_MS };
       const updates = {
         roles: [...BUILTIN_MEMORY_AGENT_DEFAULT.roles],
         role: "custom",
@@ -18515,7 +18575,9 @@ var AgentStore = class _AgentStore extends EventEmitter {
         instructionsText: owner.instructionsText?.trim() ? owner.instructionsText : BUILTIN_MEMORY_AGENT_DEFAULT.instructionsText,
         soul: owner.soul?.trim() ? owner.soul : BUILTIN_MEMORY_AGENT_DEFAULT.soul
       };
-      owner = { ...owner, ...updates, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+      const nextOwner = { ...owner, ...updates };
+      if (JSON.stringify(nextOwner) === JSON.stringify(owner)) return owner;
+      owner = { ...nextOwner, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
       await this.writeAgent(owner, executor);
       return owner;
     };
@@ -19103,14 +19165,14 @@ var AgentStore = class _AgentStore extends EventEmitter {
       const bundleDir = await this.resolveCompatibleBundleDir(agent.id, true);
       await mkdir(bundleDir, { recursive: true });
       for (const [file, content] of [["AGENTS.md", definition.instructionsText], ["soul.md", definition.soul]]) {
-        const path = join(bundleDir, file);
+        const path3 = join(bundleDir, file);
         let current = "";
         try {
-          current = await readFile(path, "utf-8");
+          current = await readFile(path3, "utf-8");
         } catch (error) {
           if (error.code !== "ENOENT") throw error;
         }
-        if (!current.trim()) await writeFile(path, content, "utf-8");
+        if (!current.trim()) await writeFile(path3, content, "utf-8");
       }
     });
   }
@@ -19188,9 +19250,9 @@ var AgentStore = class _AgentStore extends EventEmitter {
     }
     return canonicalPath;
   }
-  async pathExists(path) {
+  async pathExists(path3) {
     try {
-      await access(path, fsConstants.F_OK);
+      await access(path3, fsConstants.F_OK);
       return true;
     } catch {
       return false;
@@ -19387,19 +19449,6 @@ var AgentStore = class _AgentStore extends EventEmitter {
         this.agentSnapshotCache.set(agent.id, this.watchSnapshotOf(agent));
         if (stateChanged) {
           this.emit("agent:stateChanged", agent.id, previousState, agent.state);
-          if (this.asyncLayer) {
-            try {
-              await appendAgentActivityEvent(this.asyncLayer, {
-                type: "agent:state-changed",
-                attributionClaim: resolveAgentActivityAttribution([{ id: agent.id, provenance: "roster" }], "executor"),
-                taskId: agent.taskId,
-                occurredAt: agent.updatedAt,
-                discriminator: agent.updatedAt,
-                metadata: { fromState: previousState, toState: agent.state, source: "reconciliation" }
-              });
-            } catch {
-            }
-          }
           this.emit("agent:updated", agent, previousState);
         } else {
           this.emit("agent:updated", agent);
@@ -19458,13 +19507,80 @@ var AgentStore = class _AgentStore extends EventEmitter {
   }
 };
 
+// src/plugin-sdk-core-runtime-shim.mjs
+function superviseSpawn(command, args = [], options = {}) {
+  const killGraceMs = options.killGraceMs ?? 2e3;
+  const maxLifetimeMs = options.maxLifetimeMs;
+  const spawnOptions = { ...options };
+  delete spawnOptions.killGraceMs;
+  delete spawnOptions.maxLifetimeMs;
+  const processGroup = globalThis.process.platform !== "win32";
+  const child = spawn(command, [...args], { ...spawnOptions, detached: processGroup });
+  const pgid = processGroup && typeof child.pid === "number" ? child.pid : null;
+  let settled = false;
+  let resolveExit;
+  const waitExit = new Promise((resolve2) => {
+    resolveExit = resolve2;
+  });
+  const killProcess = (signal = "SIGTERM") => {
+    if (typeof child.pid !== "number") return;
+    try {
+      if (pgid != null) globalThis.process.kill(-pgid, signal);
+      else child.kill(signal);
+    } catch {
+      try {
+        child.kill(signal);
+      } catch {
+      }
+    }
+  };
+  let lifetimeTimer = null;
+  if (typeof maxLifetimeMs === "number" && Number.isFinite(maxLifetimeMs) && maxLifetimeMs > 0) {
+    lifetimeTimer = globalThis.setTimeout(() => {
+      if (settled) return;
+      killProcess("SIGTERM");
+      const escalationTimer = globalThis.setTimeout(() => {
+        if (!settled) killProcess("SIGKILL");
+      }, killGraceMs);
+      escalationTimer.unref?.();
+    }, maxLifetimeMs);
+    lifetimeTimer.unref?.();
+  }
+  child.once("close", (code, signal) => {
+    settled = true;
+    if (lifetimeTimer) globalThis.clearTimeout(lifetimeTimer);
+    resolveExit?.({ code, signal });
+  });
+  child.on("error", () => {
+  });
+  return {
+    pid: child.pid,
+    pgid,
+    child,
+    kill(signal = "SIGTERM") {
+      if (settled) return;
+      killProcess(signal);
+      if (signal === "SIGTERM") {
+        const escalationTimer = globalThis.setTimeout(() => {
+          if (!settled) killProcess("SIGKILL");
+        }, killGraceMs);
+        escalationTimer.unref?.();
+      }
+    },
+    waitExit() {
+      return waitExit;
+    }
+  };
+}
+
 // ../plugin-sdk/src/index.ts
 function definePlugin(plugin2) {
   return plugin2;
 }
 
 // ../../plugins/fusion-plugin-cursor-runtime/src/cli-spawn.ts
-import { spawn } from "node:child_process";
+import { spawn as spawn2, spawnSync } from "node:child_process";
+import path, { sep as PATH_SEP } from "node:path";
 function formatSpawnError(error) {
   const code = typeof error.code === "string" ? `${error.code}: ` : "";
   return `spawn error: ${code}${error.message}`.trim();
@@ -19481,7 +19597,7 @@ async function runCursorCommand(binary, args, timeoutMs) {
       if (timer) clearTimeout(timer);
       resolve2(result);
     };
-    const child = spawn(binary, args, {
+    const child = spawn2(binary, args, {
       stdio: ["ignore", "pipe", "pipe"],
       shell: process.platform === "win32"
     });
@@ -19509,6 +19625,56 @@ ${diagnostic}` : diagnostic;
     });
   });
 }
+var resolvedSpawnBinaries = /* @__PURE__ */ new Map();
+function resolveCursorBinaryForSpawn(binary) {
+  if (process.platform !== "win32") return binary;
+  if (binary.includes(PATH_SEP) || binary.includes("/") || /\.[^.\\/]+$/i.test(binary)) return binary;
+  const cached = resolvedSpawnBinaries.get(binary);
+  if (cached) return cached;
+  let result;
+  try {
+    result = spawnSync("where.exe", [binary], { encoding: "utf-8", windowsHide: true, shell: false, timeout: 2e3 });
+  } catch {
+    return binary;
+  }
+  const lines = String(result.stdout ?? "").split(/\r?\n/).map((line2) => line2.trim()).filter(Boolean);
+  if (!lines.length) return binary;
+  const first = lines[0];
+  const firstDirectory = path.dirname(first).toLowerCase();
+  const extensions = (process.env.PATHEXT || ".COM;.EXE;.BAT;.CMD").split(";").map((extension) => extension.toLowerCase());
+  const candidate = extensions.map((extension) => lines.find((line2) => path.dirname(line2).toLowerCase() === firstDirectory && path.extname(line2).toLowerCase() === extension)).find(Boolean) ?? first;
+  resolvedSpawnBinaries.set(binary, candidate);
+  return candidate;
+}
+function classifyWindowsLaunchTarget(target) {
+  const extension = path.extname(target).toLowerCase();
+  if (!extension || extension === ".exe" || extension === ".com") return "direct";
+  if (extension === ".cmd" || extension === ".bat") return "cmd-shim";
+  if (extension === ".ps1") return "powershell-shim";
+  return "unsupported";
+}
+var CMD_UNSAFE = /["%!^&|<>()\r\n\0]/;
+function assertCmdBoundarySafe(token) {
+  const offending = token.match(CMD_UNSAFE)?.[0];
+  if (offending) throw new Error(`Cursor cmd boundary rejected token ${JSON.stringify(token)} containing ${JSON.stringify(offending)}; relocate the worktree or use a direct cursor-agent executable.`);
+}
+function quoteCmdArgument(value) {
+  assertCmdBoundarySafe(value);
+  return `"${value}"`;
+}
+function resolvePowerShellExecutable() {
+  try {
+    const result = spawnSync("where.exe", ["pwsh.exe"], {
+      encoding: "utf-8",
+      windowsHide: true,
+      shell: false,
+      timeout: 2e3
+    });
+    if (result.status === 0 && String(result.stdout ?? "").split(/\r?\n/).some((line2) => line2.trim())) return "pwsh.exe";
+  } catch {
+  }
+  return "powershell.exe";
+}
 
 // ../../plugins/fusion-plugin-cursor-runtime/src/probe.ts
 var CANDIDATES = ["cursor-agent", "cursor"];
@@ -19526,12 +19692,12 @@ function summarizeFailure(binary, stdout, stderr) {
 }
 async function probeCursorAuthStatus(binary, timeoutMs) {
   const status = await runCursorCommand(binary, ["status", "--format", "json"], timeoutMs);
-  const output = (status.stdout || "").trim();
-  if (status.code !== 0 || !output) {
+  const output2 = (status.stdout || "").trim();
+  if (status.code !== 0 || !output2) {
     return { authenticated: false, reason: "cursor-agent status --format json did not return output" };
   }
   try {
-    const parsed = JSON.parse(output);
+    const parsed = JSON.parse(output2);
     if (typeof parsed?.isAuthenticated === "boolean") {
       return {
         authenticated: parsed.isAuthenticated,
@@ -19615,15 +19781,15 @@ async function discoverCursorModels(binary, timeoutMs = 5e3) {
   if (res.code !== 0) {
     return { models: [], source: "none", fallbackUsed: true, reason: "model discovery command unavailable" };
   }
-  const output = (res.stdout || "").trim();
-  if (!output) {
+  const output2 = (res.stdout || "").trim();
+  if (!output2) {
     return { models: [], source: "none", fallbackUsed: true, reason: "model discovery command returned no output" };
   }
-  if (output.toLowerCase() === EMPTY_ACCOUNT_MESSAGE) {
+  if (output2.toLowerCase() === EMPTY_ACCOUNT_MESSAGE) {
     return { models: [], source: "models-text", fallbackUsed: false, reason: "no models available for this account" };
   }
   try {
-    const parsed = JSON.parse(output);
+    const parsed = JSON.parse(output2);
     if (Array.isArray(parsed)) {
       const ids2 = [];
       const modelMeta = {};
@@ -19646,7 +19812,7 @@ async function discoverCursorModels(binary, timeoutMs = 5e3) {
     }
   } catch {
   }
-  const ids = parseModelLines(output);
+  const ids = parseModelLines(output2);
   if (ids.length > 0) {
     return { models: ids, source: "models-text", fallbackUsed: false };
   }
@@ -19685,24 +19851,881 @@ async function discoverCursorProviderModels(options) {
 }
 
 // ../../plugins/fusion-plugin-cursor-runtime/src/runtime-adapter.ts
+import { randomUUID as randomUUID4 } from "node:crypto";
+
+// ../../plugins/fusion-plugin-cursor-runtime/src/prompt-transport.ts
+import { existsSync } from "node:fs";
+import { spawn as spawn3 } from "node:child_process";
+import readline from "node:readline";
+import path2 from "node:path";
+
+// ../../plugins/fusion-plugin-cursor-runtime/src/stream-parser.ts
+function parseCursorStreamLine(line2) {
+  if (!line2.trim()) return { kind: "unknown" };
+  let value;
+  try {
+    const parsed = JSON.parse(line2);
+    if (!parsed || typeof parsed !== "object") return { kind: "unknown" };
+    value = parsed;
+  } catch {
+    return { kind: "unknown" };
+  }
+  const type = value.type;
+  const sessionId = typeof value.session_id === "string" ? value.session_id : void 0;
+  if (type === "system" && value.subtype === "init") return { kind: "system-init", sessionId, cwd: typeof value.cwd === "string" ? value.cwd : void 0, model: typeof value.model === "string" ? value.model : void 0 };
+  if (type === "thinking" && value.subtype === "delta" && typeof value.text === "string") return { kind: "thinking-delta", text: value.text };
+  if (type === "assistant") {
+    const message = value.message;
+    const content = Array.isArray(message?.content) ? message.content : [];
+    const text3 = content.filter((item) => Boolean(item) && typeof item === "object" && typeof item.text === "string").map((item) => item.text).join("");
+    return text3 ? { kind: "assistant-text", text: text3 } : { kind: "unknown" };
+  }
+  if (type === "tool_call" && (value.subtype === "started" || value.subtype === "completed")) {
+    const call = value.tool_call;
+    const key = call && Object.keys(call).find((name2) => name2.endsWith("ToolCall"));
+    if (!key) return { kind: "unknown" };
+    const details = call[key];
+    const name = key.slice(0, -"ToolCall".length) || "unknown";
+    return { kind: value.subtype === "started" ? "tool-call-started" : "tool-call-completed", callId: typeof value.call_id === "string" ? value.call_id : void 0, name, args: details?.args && typeof details.args === "object" ? details.args : void 0, result: details?.result };
+  }
+  if (type === "result") return { kind: "result", sessionId, text: typeof value.result === "string" ? value.result : void 0, isError: value.is_error === true, usage: value.usage };
+  return { kind: "unknown" };
+}
+
+// ../../plugins/fusion-plugin-cursor-runtime/src/prompt-transport.ts
+var FIRST_LINE_DEFAULT_MS = 3e4;
+var INACTIVITY_DEFAULT_MS = 12e4;
+var STDERR_MAX = 16384;
+function timeout(name, fallback) {
+  const value = Number(process.env[name]);
+  return Number.isFinite(value) && value > 0 ? value : fallback;
+}
+async function launchCursorPrompt(input, deps = {}) {
+  if (!input.cwd || !existsSync(input.cwd)) throw new Error(`Cursor CLI requires an existing session cwd: ${input.cwd || "(missing)"}`);
+  const platform = deps.platform ?? process.platform;
+  const configuredBinary = input.binary?.trim();
+  const target = resolveCursorBinaryForSpawn(configuredBinary || "cursor-agent");
+  const fallbackBinary = configuredBinary ? void 0 : target === "cursor-agent" ? "cursor" : void 0;
+  const model = (input.model || "auto").replace(/^cursor-cli\//, "");
+  const args = ["--print", "--output-format", "stream-json", "--model", model, "--trust"];
+  if (input.workspaceFlagRequired) args.push("--workspace", input.cwd);
+  if (input.tools === "coding") args.push("--force");
+  else args.push("--mode", "plan");
+  if (input.approveMcps) args.push("--approve-mcps");
+  if (input.resumeId) args.push("--resume", input.resumeId);
+  const options = { shell: false, windowsHide: true, stdio: ["pipe", "pipe", "pipe"], cwd: input.cwd, maxLifetimeMs: Number.POSITIVE_INFINITY };
+  const supervise = deps.supervise ?? superviseSpawn;
+  let command = target;
+  let launchArgs = args;
+  let launchOptions = options;
+  if (platform === "win32") {
+    const classification = classifyWindowsLaunchTarget(target);
+    if (classification === "unsupported") throw new Error(`Cursor CLI resolved target ${target} has unsupported ${path2.extname(target)} extension; point cursorCliBinaryPath at the cursor-agent executable.`);
+    if (classification === "cmd-shim") {
+      [target, ...args].forEach(assertCmdBoundarySafe);
+      const commandLine = [quoteCmdArgument(target), ...args.map(quoteCmdArgument)].join(" ");
+      const configured = process.env.ComSpec;
+      const comspec = configured && path2.isAbsolute(configured) && path2.basename(configured).toLowerCase() === "cmd.exe" && !configured.includes('"') ? configured : "cmd.exe";
+      if (comspec.length + commandLine.length > 8e3) throw new Error(`Cursor cmd command line length ${comspec.length + commandLine.length} exceeds 8000 characters for ${target}.`);
+      command = comspec;
+      launchArgs = ["/d", "/s", "/c", `"${commandLine}"`];
+      launchOptions = { ...options, windowsVerbatimArguments: true };
+    } else if (classification === "powershell-shim") {
+      command = (deps.resolvePowerShell ?? resolvePowerShellExecutable)();
+      launchArgs = ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-File", target, ...args];
+    }
+  }
+  let supervised;
+  try {
+    supervised = supervise(command, launchArgs, launchOptions);
+  } catch (error) {
+    if (fallbackBinary && error.code === "ENOENT") {
+      return launchCursorPrompt({ ...input, binary: fallbackBinary }, deps);
+    }
+    throw new Error(`Cursor CLI spawn failed for ${target} (${platform === "win32" ? classifyWindowsLaunchTarget(target) : "direct"}): ${error instanceof Error ? error.message : String(error)}`);
+  }
+  const child = supervised.child;
+  let settled = false, sawResult = false, output2 = "", sessionId, usage, stderr = "", teardownReason;
+  let firstTimer;
+  let inactivityTimer;
+  const teardown = (reason) => {
+    if (teardownReason || child.exitCode !== null || child.signalCode !== null) return;
+    teardownReason = reason;
+    if (platform === "win32" && typeof supervised.pid === "number") {
+      try {
+        (deps.taskkill ?? spawn3)("taskkill", ["/pid", String(supervised.pid), "/T", "/F"], { stdio: "ignore", windowsHide: true }).on("error", () => void 0);
+      } catch {
+      }
+      supervised.kill();
+    } else supervised.kill("SIGKILL");
+  };
+  return new Promise((resolve2, reject) => {
+    const finish = (error) => {
+      if (settled) return;
+      settled = true;
+      if (firstTimer) clearTimeout(firstTimer);
+      if (inactivityTimer) clearTimeout(inactivityTimer);
+      if (input.signal) input.signal.removeEventListener("abort", abort);
+      if (error) reject(error);
+      else resolve2({ sessionId, text: output2, usage });
+    };
+    const retryWithFallback = (error) => {
+      if (!fallbackBinary || error.code !== "ENOENT" || settled) return false;
+      settled = true;
+      if (firstTimer) clearTimeout(firstTimer);
+      if (inactivityTimer) clearTimeout(inactivityTimer);
+      if (input.signal) input.signal.removeEventListener("abort", abort);
+      void launchCursorPrompt({ ...input, binary: fallbackBinary }, deps).then(resolve2, reject);
+      return true;
+    };
+    const resetInactivity = () => {
+      if (inactivityTimer) clearTimeout(inactivityTimer);
+      inactivityTimer = setTimeout(() => {
+        teardown("Cursor CLI inactivity timeout");
+        finish(new Error("Cursor CLI inactivity timeout"));
+      }, timeout("PI_CURSOR_CLI_TIMEOUT_MS", INACTIVITY_DEFAULT_MS));
+    };
+    const abort = () => {
+      teardown("Cursor CLI aborted");
+      finish(new Error("Cursor CLI aborted"));
+    };
+    firstTimer = setTimeout(() => {
+      teardown("Cursor CLI first-line timeout");
+      finish(new Error("Cursor CLI first-line timeout"));
+    }, timeout("PI_CURSOR_CLI_FIRST_LINE_TIMEOUT_MS", FIRST_LINE_DEFAULT_MS));
+    input.signal?.addEventListener("abort", abort, { once: true });
+    child.stderr?.on("data", (chunk) => {
+      stderr = (stderr + String(chunk)).slice(-STDERR_MAX);
+    });
+    child.stdin?.on("error", (error) => {
+      if (error.code !== "EPIPE" && error.code !== "ERR_STREAM_DESTROYED") finish(error);
+    });
+    const lines = readline.createInterface({ input: child.stdout });
+    lines.on("line", (line2) => {
+      if (firstTimer) {
+        clearTimeout(firstTimer);
+        firstTimer = void 0;
+      }
+      resetInactivity();
+      const event = parseCursorStreamLine(line2);
+      if (event.kind === "system-init") sessionId = event.sessionId ?? sessionId;
+      if (event.kind === "thinking-delta") input.onThinking?.(event.text);
+      if (event.kind === "assistant-text") {
+        output2 += event.text;
+        input.onText?.(event.text);
+      }
+      if (event.kind === "tool-call-started") input.onToolStart?.(event.name, event.args);
+      if (event.kind === "tool-call-completed") input.onToolEnd?.(event.name, false, event.result);
+      if (event.kind === "result") {
+        sawResult = true;
+        sessionId = event.sessionId ?? sessionId;
+        usage = event.usage;
+        if (event.isError) finish(new Error(`Cursor CLI reported an error: ${event.text ?? "unknown error"}`));
+      }
+    });
+    child.once("error", (error) => {
+      if (!retryWithFallback(error)) finish(new Error(`Cursor CLI spawn failed for ${target}: ${error.message}`));
+    });
+    child.once("close", (code) => {
+      if (teardownReason) return finish(new Error(teardownReason));
+      if (code !== 0) return finish(new Error(`Cursor CLI exited ${code}: ${stderr}`));
+      if (!sawResult) return finish(new Error("Cursor CLI stream ended without a result event."));
+      finish();
+    });
+    try {
+      child.stdin?.end(input.prompt);
+    } catch (error) {
+      finish(error instanceof Error ? error : new Error(String(error)));
+    }
+  });
+}
+
+// ../../plugins/fusion-plugin-cursor-runtime/src/worktree-hygiene.ts
+import { existsSync as existsSync2, mkdirSync, readFileSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { hostname } from "node:os";
+import { dirname as dirname2, isAbsolute, join as join2, relative, sep } from "node:path";
+import { spawnSync as spawnSync2 } from "node:child_process";
+var START = "# >>> fusion cursor-runtime >>>";
+var END = "# <<< fusion cursor-runtime <<<";
+var git = (cwd, ...args) => spawnSync2("git", args, { cwd, encoding: "utf8" });
+var output = (cwd, ...args) => {
+  const result = git(cwd, ...args);
+  return result.status === 0 ? result.stdout.trim() : void 0;
+};
+var atomic = (file, raw) => {
+  mkdirSync(dirname2(file), { recursive: true });
+  const tmp = `${file}.${process.pid}.tmp`;
+  writeFileSync(tmp, raw, { mode: 384 });
+  renameSync(tmp, file);
+};
+function resolveGitShape(worktreePath) {
+  const topLevel = output(worktreePath, "rev-parse", "--show-toplevel");
+  const excludePath = output(worktreePath, "rev-parse", "--git-path", "info/exclude");
+  const gitDir = output(worktreePath, "rev-parse", "--git-path", ".");
+  if (!topLevel || !excludePath || !gitDir) return void 0;
+  const rel = relative(topLevel, worktreePath).split(sep).filter(Boolean).join("/");
+  const fromGitPath = (value) => isAbsolute(value) ? value : join2(worktreePath, value);
+  return { topLevel, excludePath: fromGitPath(excludePath), gitDir: fromGitPath(gitDir), relativeWorktree: rel };
+}
+function classifyCursorConfigTracking(worktreePath) {
+  const shape = resolveGitShape(worktreePath);
+  if (!shape) return "non-git";
+  const path3 = `${shape.relativeWorktree ? `${shape.relativeWorktree}/` : ""}.cursor/mcp.json`;
+  return git(shape.topLevel, "ls-files", "--error-unmatch", "--", path3).status === 0 ? "tracked" : "untracked";
+}
+var block = (shape) => {
+  const prefix = shape.relativeWorktree ? `/${shape.relativeWorktree}/` : "/";
+  return `${START}
+${prefix}.cursor/mcp.json
+${prefix}.cursor/.fusion-mcp-state.json
+${prefix}.cursor/.fusion-mcp.lock/
+${END}
+`;
+};
+var withoutBlock = (raw) => raw.replace(new RegExp(`${START.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\n[\\s\\S]*?${END.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\n?`, "g"), "");
+var BOOTSTRAP_LOCK_TTL_MS = 1e4;
+var BOOTSTRAP_LOCK_ATTEMPTS = 5;
+var BOOTSTRAP_LOCK_RETRY_MS = 10;
+var bootstrapLock = (shape) => join2(shape.gitDir, "fusion-cursor-exclude.lock");
+var sleepSync = (milliseconds) => Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, milliseconds);
+var lockAgeMs = (lock) => {
+  try {
+    return Date.now() - statSync(lock).mtimeMs;
+  } catch {
+    return Number.POSITIVE_INFINITY;
+  }
+};
+function withBootstrapLock(shape, fn) {
+  const lock = bootstrapLock(shape);
+  const mine = { pid: process.pid, hostname: hostname(), acquiredAt: Date.now() };
+  let acquired = false;
+  for (let attempt = 0; attempt < BOOTSTRAP_LOCK_ATTEMPTS; attempt++) {
+    try {
+      mkdirSync(lock);
+      writeFileSync(join2(lock, "owner.json"), JSON.stringify(mine), { mode: 384 });
+      acquired = true;
+      break;
+    } catch {
+      let owner;
+      try {
+        owner = JSON.parse(readFileSync(join2(lock, "owner.json"), "utf8"));
+      } catch {
+      }
+      const deadLocalOwner = owner?.hostname === mine.hostname && typeof owner.pid === "number" && (() => {
+        try {
+          process.kill(owner.pid, 0);
+          return false;
+        } catch {
+          return true;
+        }
+      })();
+      const stale2 = lockAgeMs(lock) > BOOTSTRAP_LOCK_TTL_MS || deadLocalOwner || owner !== void 0 && Date.now() - (owner.acquiredAt ?? 0) > BOOTSTRAP_LOCK_TTL_MS;
+      if (stale2) {
+        try {
+          rmSync(lock, { recursive: true, force: true });
+        } catch {
+        }
+      }
+      if (attempt < BOOTSTRAP_LOCK_ATTEMPTS - 1) sleepSync(BOOTSTRAP_LOCK_RETRY_MS);
+    }
+  }
+  if (!acquired) throw Object.assign(new Error("Cursor MCP exclude lock unavailable"), { code: "bridge-start-failed" });
+  try {
+    return fn();
+  } finally {
+    try {
+      const owner = JSON.parse(readFileSync(join2(lock, "owner.json"), "utf8"));
+      if (owner.pid === mine.pid && owner.hostname === mine.hostname) rmSync(lock, { recursive: true, force: true });
+    } catch {
+    }
+  }
+}
+function ensureCursorConfigExcluded(worktreePath, options = {}) {
+  const shape = resolveGitShape(worktreePath);
+  if (!shape) return { present: false, fusionAuthored: false, created: false };
+  const ensure = () => {
+    const raw = existsSync2(shape.excludePath) ? readFileSync(shape.excludePath, "utf8") : "";
+    if (raw.includes(START) && raw.includes(END)) return { present: true, fusionAuthored: true, created: false };
+    atomic(shape.excludePath, `${raw}${raw && !raw.endsWith("\n") ? "\n" : ""}${block(shape)}`);
+    return { present: true, fusionAuthored: true, created: true };
+  };
+  return options.lockHeld ? ensure() : withBootstrapLock(shape, ensure);
+}
+function removeCursorConfigExclusion(worktreePath) {
+  const shape = resolveGitShape(worktreePath);
+  if (!shape || !existsSync2(shape.excludePath)) return;
+  const raw = readFileSync(shape.excludePath, "utf8");
+  if (!raw.includes(START) || !raw.includes(END)) return;
+  const next = withoutBlock(raw);
+  if (next) atomic(shape.excludePath, next);
+  else unlinkSync(shape.excludePath);
+}
+
+// ../../plugins/fusion-plugin-cursor-runtime/src/cursor-mcp-config.ts
+import { closeSync, existsSync as existsSync3, fsyncSync, mkdirSync as mkdirSync2, openSync, readFileSync as readFileSync2, renameSync as renameSync2, rmSync as rmSync2, rmdirSync, statSync as statSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { hostname as hostname2 } from "node:os";
+import { dirname as dirname3, join as join3 } from "node:path";
+import { randomUUID as randomUUID2 } from "node:crypto";
+var TTL = 15 * 6e4;
+var LOCK_TTL_MS = 3e4;
+var LOCK_ATTEMPTS = 5;
+var held = /* @__PURE__ */ new Map();
+var paths = (worktreePath) => {
+  const dir = join3(worktreePath, ".cursor");
+  return { dir, config: join3(dir, "mcp.json"), state: join3(dir, ".fusion-mcp-state.json"), lock: join3(dir, ".fusion-mcp.lock") };
+};
+var rawFile = (file) => existsSync3(file) ? readFileSync2(file, "utf8") : null;
+var atomic2 = (file, raw, durable = false) => {
+  const temp = `${file}.${process.pid}.${randomUUID2()}.tmp`;
+  writeFileSync2(temp, raw, { mode: 384 });
+  if (durable) {
+    const fileDescriptor = openSync(temp, "r");
+    try {
+      fsyncSync(fileDescriptor);
+    } finally {
+      closeSync(fileDescriptor);
+    }
+  }
+  renameSync2(temp, file);
+  if (durable) {
+    try {
+      const directoryDescriptor = openSync(dirname3(file), "r");
+      try {
+        fsyncSync(directoryDescriptor);
+      } finally {
+        closeSync(directoryDescriptor);
+      }
+    } catch {
+    }
+  }
+};
+var writeState = (file, state, durable = false) => atomic2(file, JSON.stringify(state), durable);
+var same = (raw, expected) => raw === expected;
+var own = (key) => /^fusion-custom-tools-/.test(key);
+var parseCursorMcpConfig = (raw) => JSON.parse(raw);
+var detectFusionKeysInRaw = (raw) => {
+  try {
+    return Object.keys(parseCursorMcpConfig(raw ?? "{}").mcpServers ?? {}).filter(own);
+  } catch {
+    return [];
+  }
+};
+function stripFusionKeys(parsed) {
+  const copy = { ...parsed, mcpServers: { ...parsed.mcpServers ?? {} } };
+  for (const key of Object.keys(copy.mcpServers)) if (own(key)) delete copy.mcpServers[key];
+  return copy;
+}
+function composeMcpConfig({ currentRaw, leases }) {
+  let parsed;
+  try {
+    parsed = currentRaw ? parseCursorMcpConfig(currentRaw) : {};
+  } catch {
+    parsed = {};
+  }
+  const next = stripFusionKeys(parsed);
+  next.mcpServers ??= {};
+  for (const [key, lease] of Object.entries(leases)) next.mcpServers[key] = lease.serverEntry;
+  return `${JSON.stringify(next, null, 2)}
+`;
+}
+function detectOperatorEdit({ currentRaw, lastWrittenRaw, pending, baseline, stateExists }) {
+  if (!stateExists) return false;
+  return !same(currentRaw, lastWrittenRaw ?? baseline.raw) && !same(currentRaw, pending?.raw ?? "__no_pending__");
+}
+function resolvePendingJournal({ currentRaw, lastWrittenRaw, pending, baseline }) {
+  if (!pending) return "discard";
+  if (pending.kind === "quarantine" || same(currentRaw, pending.raw)) return "promote";
+  return same(currentRaw, lastWrittenRaw ?? baseline.raw) ? "discard" : "discard-edited";
+}
+function evaluateQuarantine({ currentRaw, quarantine }) {
+  if (!quarantine) return "unknown";
+  if (currentRaw === null) return "clear";
+  if (currentRaw === quarantine.raw) return "hold";
+  try {
+    return Object.keys(parseCursorMcpConfig(currentRaw).mcpServers ?? {}).some(own) ? "hold" : "clear";
+  } catch {
+    return "repin";
+  }
+}
+var lockOwnerPath = (lock) => join3(lock, "owner.json");
+var currentHost = () => hostname2();
+var pidAlive = (pid) => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var readLockOwner = (lock) => {
+  try {
+    return JSON.parse(readFileSync2(lockOwnerPath(lock), "utf8"));
+  } catch {
+    return void 0;
+  }
+};
+var lockAgeMs2 = (lock) => {
+  try {
+    return Date.now() - statSync2(lock).mtimeMs;
+  } catch {
+    return Number.POSITIVE_INFINITY;
+  }
+};
+var lockIsStale = (lock, owner) => lockAgeMs2(lock) > LOCK_TTL_MS || owner !== void 0 && (Date.now() - owner.acquiredAt > LOCK_TTL_MS || owner.hostname === currentHost() && !pidAlive(owner.pid));
+var pause = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
+async function withLock(worktreePath, create, fn) {
+  const p = paths(worktreePath);
+  if (!existsSync3(p.dir)) {
+    if (!create) return void 0;
+    mkdirSync2(p.dir, { recursive: true });
+  }
+  const mine = { pid: process.pid, hostname: currentHost(), acquiredAt: Date.now() };
+  for (let attempt = 0; attempt < LOCK_ATTEMPTS; attempt++) {
+    try {
+      mkdirSync2(p.lock);
+      writeFileSync2(lockOwnerPath(p.lock), JSON.stringify(mine), { mode: 384 });
+      break;
+    } catch {
+      if (existsSync3(p.lock) && lockIsStale(p.lock, readLockOwner(p.lock))) {
+        try {
+          rmSync2(p.lock, { recursive: true, force: true });
+        } catch {
+        }
+      }
+      if (attempt === LOCK_ATTEMPTS - 1) throw Object.assign(new Error("Cursor MCP config lock unavailable"), { code: "bridge-start-failed" });
+      await pause(8 + Math.floor(Math.random() * 12));
+    }
+  }
+  try {
+    return await fn();
+  } finally {
+    const owner = readLockOwner(p.lock);
+    if (owner?.pid === mine.pid && owner.hostname === mine.hostname) {
+      try {
+        rmSync2(p.lock, { recursive: true, force: true });
+      } catch {
+      }
+    }
+  }
+}
+function withLockSync(worktreePath, fn) {
+  const p = paths(worktreePath);
+  if (!existsSync3(p.dir)) return void 0;
+  const mine = { pid: process.pid, hostname: currentHost(), acquiredAt: Date.now() };
+  try {
+    mkdirSync2(p.lock);
+    writeFileSync2(lockOwnerPath(p.lock), JSON.stringify(mine), { mode: 384 });
+  } catch {
+    return void 0;
+  }
+  try {
+    return fn();
+  } catch {
+    return void 0;
+  } finally {
+    const owner = readLockOwner(p.lock);
+    if (owner?.pid === mine.pid && owner.hostname === mine.hostname) {
+      try {
+        rmSync2(p.lock, { recursive: true, force: true });
+      } catch {
+      }
+    }
+  }
+}
+function readState(p) {
+  try {
+    const state = JSON.parse(readFileSync2(p.state, "utf8"));
+    return state.version === 1 && state.baseline ? state : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function recoverJournal(p, state, current) {
+  if (!state.pending) return;
+  const resolution = resolvePendingJournal({ currentRaw: current, lastWrittenRaw: state.lastWrittenRaw, pending: state.pending, baseline: state.baseline });
+  if (resolution === "promote") state.lastWrittenRaw = state.pending.raw;
+  if (resolution === "discard-edited") {
+    state.operatorEditObserved = true;
+    try {
+      if (current !== null) parseCursorMcpConfig(current);
+    } catch {
+      state.configUnwritable = true;
+    }
+  }
+  state.pending = null;
+  writeState(p.state, state);
+}
+function journalWrite(p, state, kind, raw) {
+  state.pending = { kind, raw, seq: (state.pending?.seq ?? 0) + 1 };
+  writeState(p.state, state, true);
+  if (kind === "delete") {
+    if (existsSync3(p.config)) unlinkSync2(p.config);
+  } else if (kind !== "quarantine") atomic2(p.config, raw ?? "");
+  state.lastWrittenRaw = raw;
+  state.pending = null;
+  writeState(p.state, state);
+}
+function stale(state) {
+  for (const [key, lease] of Object.entries(state.leases)) {
+    if (Date.now() - lease.heartbeatAt > TTL || lease.hostname === currentHost() && !pidAlive(lease.pid)) delete state.leases[key];
+  }
+}
+function terminal(worktreePath, p, state) {
+  const current = rawFile(p.config);
+  if (state.configUnwritable) {
+    state.leases = {};
+    state.quarantine = { raw: current, fusionKeys: detectFusionKeysInRaw(current), observedAt: (/* @__PURE__ */ new Date()).toISOString() };
+    state.pending = { kind: "quarantine", raw: current, seq: 1 };
+    writeState(p.state, state, true);
+    state.pending = null;
+    state.lastWrittenRaw = null;
+    writeState(p.state, state, true);
+    return false;
+  }
+  if (!state.operatorEditObserved) journalWrite(p, state, state.baseline.existed ? "restore" : "delete", state.baseline.raw);
+  else if (current !== null) journalWrite(p, state, "write", composeMcpConfig({ currentRaw: current, leases: {} }));
+  unlinkSync2(p.state);
+  if (state.exclusionOwnedByFusion) removeCursorConfigExclusion(worktreePath);
+  return state.baseline.createdDir;
+}
+function removeCursorDirectoryAfterLock(dir, shouldRemove) {
+  if (!shouldRemove) return;
+  try {
+    rmdirSync(dir);
+  } catch {
+  }
+}
+function detectAndLatch(p, state, current) {
+  recoverJournal(p, state, current);
+  const observed = rawFile(p.config);
+  if (detectOperatorEdit({ currentRaw: observed, lastWrittenRaw: state.lastWrittenRaw, pending: state.pending, baseline: state.baseline, stateExists: true })) {
+    state.operatorEditObserved = true;
+    try {
+      if (observed) parseCursorMcpConfig(observed);
+    } catch {
+      state.configUnwritable = true;
+    }
+    writeState(p.state, state);
+  }
+}
+function bootstrapCursorWorktree(worktreePath) {
+  if (classifyCursorConfigTracking(worktreePath) === "tracked") throw Object.assign(new Error("Cursor MCP config is git-tracked"), { code: "bridge-start-failed" });
+  const exclusion = ensureCursorConfigExcluded(worktreePath);
+  const p = paths(worktreePath);
+  const existed = existsSync3(p.dir);
+  mkdirSync2(p.dir, { recursive: true });
+  return { exclusion, createdDirObserved: !existed };
+}
+async function stageCursorMcpLease({ worktreePath, serverKey, serverEntry }) {
+  const boot = bootstrapCursorWorktree(worktreePath);
+  const p = paths(worktreePath);
+  let clearedQuarantine = false;
+  await withLock(worktreePath, true, () => {
+    const current = rawFile(p.config);
+    let state = readState(p);
+    if (state?.quarantine) {
+      const verdict = evaluateQuarantine({ currentRaw: current, quarantine: state.quarantine });
+      if (verdict !== "clear") {
+        if (verdict === "repin") {
+          state.quarantine = { raw: current, fusionKeys: detectFusionKeysInRaw(current), observedAt: (/* @__PURE__ */ new Date()).toISOString() };
+          writeState(p.state, state, true);
+        }
+        throw Object.assign(new Error("Cursor MCP worktree is quarantined"), { code: "bridge-start-failed" });
+      }
+      unlinkSync2(p.state);
+      if (state.exclusionOwnedByFusion) removeCursorConfigExclusion(worktreePath);
+      clearedQuarantine = true;
+      return;
+    }
+    if (!state) {
+      let parsable = true;
+      try {
+        if (current) parseCursorMcpConfig(current);
+      } catch {
+        parsable = false;
+      }
+      state = { version: 1, baseline: { existed: current !== null, raw: current, mode: current === null ? null : statSync2(p.config).mode, parsable, createdDir: boot.createdDirObserved }, exclusionOwnedByFusion: boot.exclusion.fusionAuthored, lastWrittenRaw: null, pending: null, operatorEditObserved: false, configUnwritable: !parsable, quarantine: parsable ? null : { raw: current, fusionKeys: detectFusionKeysInRaw(current), observedAt: (/* @__PURE__ */ new Date()).toISOString() }, leases: {} };
+      writeState(p.state, state, true);
+      if (!parsable) throw Object.assign(new Error("Cursor MCP config is not safely writable"), { code: "bridge-start-failed" });
+    }
+    detectAndLatch(p, state, current);
+    if (state.configUnwritable) throw Object.assign(new Error("Cursor MCP config is not safely writable"), { code: "bridge-start-failed" });
+    const exclusion = ensureCursorConfigExcluded(worktreePath, { lockHeld: true });
+    state.exclusionOwnedByFusion ||= exclusion.fusionAuthored;
+    stale(state);
+    state.leases[serverKey] = { pid: process.pid, hostname: currentHost(), heartbeatAt: Date.now(), serverEntry };
+    const composed = composeMcpConfig({ currentRaw: rawFile(p.config), leases: state.leases });
+    journalWrite(p, state, "write", composed);
+    const worktreeLeases = held.get(worktreePath) ?? /* @__PURE__ */ new Set();
+    worktreeLeases.add(serverKey);
+    held.set(worktreePath, worktreeLeases);
+  });
+  if (clearedQuarantine) return stageCursorMcpLease({ worktreePath, serverKey, serverEntry });
+  let released = false;
+  return { heartbeat: async () => await withLock(worktreePath, false, () => {
+    const state = readState(p);
+    if (state?.leases[serverKey]) {
+      detectAndLatch(p, state, rawFile(p.config));
+      if (!state.configUnwritable) {
+        state.leases[serverKey].heartbeatAt = Date.now();
+        writeState(p.state, state);
+      }
+    }
+  }), dispose: async () => {
+    if (released) return;
+    released = true;
+    let removeDir = false;
+    await withLock(worktreePath, false, () => {
+      const state = readState(p);
+      if (!state) return;
+      detectAndLatch(p, state, rawFile(p.config));
+      delete state.leases[serverKey];
+      stale(state);
+      if (Object.keys(state.leases).length) {
+        if (!state.configUnwritable) journalWrite(p, state, "write", composeMcpConfig({ currentRaw: rawFile(p.config), leases: state.leases }));
+        else writeState(p.state, state);
+      } else removeDir = terminal(worktreePath, p, state);
+      held.get(worktreePath)?.delete(serverKey);
+    });
+    removeCursorDirectoryAfterLock(p.dir, removeDir);
+  } };
+}
+async function reconcileCursorWorktree(worktreePath) {
+  const p = paths(worktreePath);
+  if (!existsSync3(p.dir)) return;
+  let removeDir = false;
+  try {
+    await withLock(worktreePath, false, () => {
+      const state = readState(p);
+      if (!state) return;
+      const current = rawFile(p.config);
+      if (state.quarantine) {
+        const verdict = evaluateQuarantine({ currentRaw: current, quarantine: state.quarantine });
+        if (verdict === "clear") {
+          unlinkSync2(p.state);
+          if (state.exclusionOwnedByFusion) removeCursorConfigExclusion(worktreePath);
+          removeDir = state.baseline.createdDir;
+        } else if (verdict === "repin") {
+          state.quarantine = { raw: current, fusionKeys: detectFusionKeysInRaw(current), observedAt: (/* @__PURE__ */ new Date()).toISOString() };
+          writeState(p.state, state, true);
+        }
+        return;
+      }
+      detectAndLatch(p, state, current);
+      const leaseCount = Object.keys(state.leases).length;
+      stale(state);
+      if (!Object.keys(state.leases).length) removeDir = terminal(worktreePath, p, state);
+      else if (!state.configUnwritable && Object.keys(state.leases).length !== leaseCount) {
+        journalWrite(p, state, "write", composeMcpConfig({ currentRaw: rawFile(p.config), leases: state.leases }));
+      } else if (Object.keys(state.leases).length !== leaseCount) writeState(p.state, state);
+    });
+  } catch {
+  }
+  removeCursorDirectoryAfterLock(p.dir, removeDir);
+}
+function releaseHeldLeasesSync(worktreePath) {
+  for (const [path3, keys] of held) {
+    if (worktreePath && path3 !== worktreePath) continue;
+    for (const key of [...keys]) {
+      const p = paths(path3);
+      let removeDir = false;
+      withLockSync(path3, () => {
+        const state = readState(p);
+        if (!state || state.quarantine) return;
+        detectAndLatch(p, state, rawFile(p.config));
+        delete state.leases[key];
+        if (!Object.keys(state.leases).length) removeDir = terminal(path3, p, state);
+        else if (!state.configUnwritable) journalWrite(p, state, "write", composeMcpConfig({ currentRaw: rawFile(p.config), leases: state.leases }));
+        else writeState(p.state, state);
+      });
+      removeCursorDirectoryAfterLock(p.dir, removeDir);
+    }
+  }
+}
+
+// ../../plugins/fusion-plugin-cursor-runtime/src/tool-mapping.ts
+function fromCursorToolName(observedName, serverKey) {
+  const exact = `${serverKey}-`;
+  if (observedName.startsWith(exact)) return observedName.slice(exact.length);
+  return observedName.replace(new RegExp(`^mcp[_-]*${serverKey.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}[_-]*`), "");
+}
+
+// ../../plugins/fusion-plugin-cursor-runtime/src/tool-bridge.ts
+import { timingSafeEqual, randomUUID as randomUUID3 } from "node:crypto";
+import { createServer } from "node:http";
+import { existsSync as existsSync4, unlinkSync as unlinkSync3, writeFileSync as writeFileSync3, chmodSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname as dirname4, join as join4 } from "node:path";
+import { fileURLToPath } from "node:url";
+var toolsToMcpToolDefs = (tools) => (tools ?? []).filter((tool) => tool?.name.startsWith("fn_") && typeof tool.execute === "function").map((tool) => ({ name: tool.name, description: tool.description ?? "", inputSchema: tool.parameters ?? { type: "object", properties: {} } }));
+var cursorMcpSchemaServerPath = () => join4(dirname4(fileURLToPath(import.meta.url)), "mcp-schema-server.cjs");
+var text2 = (value) => {
+  if (value == null) return "";
+  if (typeof value === "string") return value;
+  if (typeof value === "object" && value && "text" in value && typeof value.text === "string") return value.text;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+};
+var loopback = (address) => address === "127.0.0.1" || address === "::1" || address === "::ffff:127.0.0.1";
+async function startCursorToolBridge(tools) {
+  const defs = toolsToMcpToolDefs(tools);
+  if (!defs.length) return null;
+  const asset = cursorMcpSchemaServerPath();
+  if (!existsSync4(asset)) {
+    const error = Object.assign(new Error(`Fusion MCP schema server is missing: ${asset}`), { code: "mcp-schema-server-missing" });
+    throw error;
+  }
+  const token = randomUUID3();
+  const publishedNames = new Set(defs.map((tool) => tool.name));
+  const byName = new Map((tools ?? []).filter((tool) => publishedNames.has(tool.name) && typeof tool.execute === "function").map((tool) => [tool.name, tool]));
+  const schema = join4(tmpdir(), `fusion-cursor-mcp-schemas-${process.pid}-${randomUUID3()}.json`);
+  writeFileSync3(schema, JSON.stringify(defs), { mode: 384 });
+  chmodSync(schema, 384);
+  const server = createServer(async (req, res) => {
+    const host = req.headers.host;
+    const localHost = `127.0.0.1:${server.address()?.port ?? ""}`;
+    const auth = req.headers.authorization;
+    const provided = auth?.startsWith("Bearer ") ? auth.slice(7) : "";
+    const matches = provided.length === token.length && timingSafeEqual(Buffer.from(provided), Buffer.from(token));
+    if (!loopback(req.socket.remoteAddress) || host !== localHost || !matches) {
+      res.statusCode = 401;
+      res.end();
+      return;
+    }
+    if (req.method !== "POST" || req.url !== "/tool-call") {
+      res.statusCode = 404;
+      res.end();
+      return;
+    }
+    let raw = "";
+    for await (const chunk of req) raw += chunk;
+    let body;
+    try {
+      body = JSON.parse(raw || "{}");
+    } catch {
+      res.statusCode = 400;
+      res.end(JSON.stringify({ isError: true, text: "invalid JSON body" }));
+      return;
+    }
+    const tool = typeof body.name === "string" ? byName.get(body.name) : void 0;
+    res.setHeader("content-type", "application/json");
+    if (!tool?.execute) {
+      res.end(JSON.stringify({ isError: true, content: [{ type: "text", text: "Unknown Fusion tool" }] }));
+      return;
+    }
+    try {
+      const result = await tool.execute(`cursor-mcp-${randomUUID3()}`, body.arguments ?? {});
+      res.end(JSON.stringify({ isError: false, content: [{ type: "text", text: text2(result) }] }));
+    } catch (error) {
+      res.end(JSON.stringify({ isError: true, content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }] }));
+    }
+  });
+  const port = await new Promise((resolve2, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => resolve2(server.address().port));
+  });
+  return { token, toolCount: defs.length, serverEntry: { command: process.execPath, args: [asset, schema], env: { FUSION_CURSOR_TOOL_BRIDGE_URL: `http://127.0.0.1:${port}`, FUSION_CURSOR_TOOL_BRIDGE_TOKEN: token } }, dispose: async () => {
+    await new Promise((resolve2) => server.close(() => resolve2()));
+    try {
+      unlinkSync3(schema);
+    } catch {
+    }
+  } };
+}
+
+// ../../plugins/fusion-plugin-cursor-runtime/src/runtime-adapter.ts
+var MCP_HEARTBEAT_INTERVAL_MS = 5 * 6e4;
+var exitHookInstalled = false;
+function installExitHook() {
+  if (!exitHookInstalled) {
+    exitHookInstalled = true;
+    process.once("exit", () => {
+      try {
+        releaseHeldLeasesSync();
+      } catch {
+      }
+    });
+  }
+}
+function context(options, names = []) {
+  const skills = Array.isArray(options.skills) ? options.skills.filter((value) => typeof value === "string" && value.trim()) : [];
+  return ["Fusion runtime context:", `- Tool mode: ${options.tools ?? "readonly"}`, skills.length ? `- Requested skills: ${skills.join(", ")}` : "", names.length ? `- Fusion MCP tools: ${names.join(", ")}` : ""].filter(Boolean).join("\n");
+}
 var CursorRuntimeAdapter = class {
+  constructor(settings) {
+    this.settings = settings;
+  }
   id = "cursor";
   name = "Cursor Runtime";
   async createSession(options) {
-    return {
-      session: {
-        model: options.defaultModelId ?? "cursor/default",
-        systemPrompt: options.systemPrompt,
-        messages: []
-      },
-      sessionFile: void 0
-    };
-  }
-  async promptWithFallback() {
-    return;
+    await reconcileCursorWorktree(options.cwd);
+    installExitHook();
+    const messages2 = [];
+    const session = { model: options.defaultModelId?.replace(/^cursor-cli\//, "") ?? "auto", systemPrompt: options.systemPrompt, messages: messages2, state: { messages: messages2 }, sessionId: "", cwd: options.cwd, tools: options.tools, callbacks: { onText: options.onText, onThinking: options.onThinking, onToolStart: options.onToolStart, onToolEnd: options.onToolEnd }, fusedSystemPrompt: [options.systemPrompt?.trim(), context(options)].filter(Boolean).join("\n\n"), disposed: false, dispose: async () => {
+      if (session.disposed) return;
+      session.disposed = true;
+      session.activeAbortController?.abort();
+      if (session.mcpHeartbeatTimer) clearInterval(session.mcpHeartbeatTimer);
+      await session.mcpLease?.dispose().catch(() => void 0);
+      await session.toolBridge?.dispose().catch(() => void 0);
+    } };
+    let startingBridge = null;
+    if (options.fusionTools?.length && classifyCursorConfigTracking(options.cwd) !== "tracked") {
+      try {
+        startingBridge = await startCursorToolBridge(options.fusionTools);
+        if (startingBridge) {
+          const serverKey = `fusion-custom-tools-${randomUUID4()}`;
+          const lease = await stageCursorMcpLease({ worktreePath: options.cwd, serverKey, serverEntry: startingBridge.serverEntry });
+          session.toolBridge = startingBridge;
+          session.mcpLease = lease;
+          session.mcpServerKey = serverKey;
+          session.mcpHeartbeatTimer = setInterval(() => {
+            void lease.heartbeat().catch(() => void 0);
+          }, MCP_HEARTBEAT_INTERVAL_MS);
+          session.mcpHeartbeatTimer.unref?.();
+          session.fusedSystemPrompt = [options.systemPrompt?.trim(), context(options, options.fusionTools.map((tool) => `${serverKey}-${tool.name}`))].filter(Boolean).join("\n\n");
+          startingBridge = null;
+        }
+      } catch (error) {
+        await startingBridge?.dispose().catch(() => void 0);
+        session.fusionToolBridgeError = { reasonCode: error.code === "mcp-schema-server-missing" ? "mcp-schema-server-missing" : "bridge-start-failed" };
+      }
+    } else if (options.fusionTools?.length) session.fusionToolBridgeError = { reasonCode: "bridge-start-failed" };
+    return { session, sessionFile: void 0 };
+  }
+  async promptWithFallback(session, prompt, _options) {
+    if (session.disposed) throw new Error("Cursor session is disposed.");
+    const priorId = session.sessionId;
+    const first = !priorId;
+    const sent = first ? `${session.fusedSystemPrompt}
+
+User request:
+${prompt}` : prompt;
+    const emitted = /* @__PURE__ */ new Set();
+    const controller = new AbortController();
+    session.activeAbortController = controller;
+    const map2 = (name) => session.mcpServerKey ? fromCursorToolName(name, session.mcpServerKey) : name;
+    try {
+      const outcome = await launchCursorPrompt({ binary: typeof this.settings?.cursorCliBinaryPath === "string" ? this.settings.cursorCliBinaryPath : void 0, model: session.model, cwd: session.cwd, tools: session.tools, prompt: sent, resumeId: priorId || void 0, signal: controller.signal, approveMcps: Boolean(session.mcpLease), onThinking: session.callbacks.onThinking, onToolStart: (name, args) => session.callbacks.onToolStart?.(map2(name), args), onToolEnd: (name, isError, result) => session.callbacks.onToolEnd?.(map2(name), isError, result), onText: (text3) => {
+        if (!emitted.has(text3)) {
+          emitted.add(text3);
+          session.callbacks.onText?.(text3);
+        }
+      } });
+      session.sessionId = outcome.sessionId ?? session.sessionId;
+      session.messages.push({ role: "user", content: prompt }, { role: "assistant", content: outcome.text });
+    } catch (error) {
+      session.sessionId = priorId;
+      throw error;
+    } finally {
+      if (session.activeAbortController === controller) session.activeAbortController = void 0;
+    }
   }
   describeModel(session) {
-    return `cursor/${session.model ?? "default"}`;
+    return `cursor-cli/${(session.model || "auto").replace(/^cursor-cli\//, "")}`;
   }
 };
 
@@ -19727,7 +20750,7 @@ var plugin = definePlugin({
       name: "Cursor Runtime",
       version: "0.1.0"
     },
-    factory: async () => new CursorRuntimeAdapter()
+    factory: async (ctx) => new CursorRuntimeAdapter(ctx.settings)
   },
   cliProviders: [
     {
@@ -19756,7 +20779,7 @@ var plugin = definePlugin({
       discoverModels: discoverCursorProviderModels,
       runtime: {
         runtimeId: "cursor",
-        createAdapter: async () => new CursorRuntimeAdapter()
+        createAdapter: async (ctx) => new CursorRuntimeAdapter(ctx.settings)
       }
     }
   ]