@runfusion/fusion 0.77.0-beta.0 → 0.77.0-beta.2

package/dist/pi-claude-cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fusion/pi-claude-cli",
-  "version": "0.77.0-beta.0",
+  "version": "0.77.0-beta.2",
   "type": "module",
   "private": true,
   "main": "index.ts",

package/dist/plugin-sdk/index.js

@@ -16105,6 +16105,7 @@ function applyPromptOverridesToIr(ir, overrides) {
 function defaultCodingWorkflowIr() {
   return resolveDefaultWorkflowIr();
 }
+var inflightSelectionReads = /* @__PURE__ */ new WeakMap();
 async function resolveWorkflowIrById(store, workflowId, irCache) {
   let projectId;
   try {
@@ -16148,8 +16149,34 @@ function didFallBackToDefault(ir) {
 async function resolveWorkflowIrForTaskWithProvenance(store, taskId, irCache, selectionCache) {
   let workflowId;
   try {
-    const selection = selectionCache?.has(taskId) ? selectionCache.get(taskId) : store.getTaskWorkflowSelectionAsync ? await store.getTaskWorkflowSelectionAsync(taskId) : store.getTaskWorkflowSelection(taskId);
-    if (!selectionCache?.has(taskId)) selectionCache?.set(taskId, selection);
+    const isSelectionCached = selectionCache?.has(taskId) ?? false;
+    let selection = isSelectionCached && selectionCache ? selectionCache.get(taskId) : void 0;
+    if (!isSelectionCached) {
+      let inflight;
+      let coalesced = false;
+      if (selectionCache) {
+        inflight = inflightSelectionReads.get(selectionCache);
+        if (!inflight) {
+          inflight = /* @__PURE__ */ new Map();
+          inflightSelectionReads.set(selectionCache, inflight);
+        }
+        const pending = inflight.get(taskId);
+        if (pending) {
+          selection = await pending;
+          coalesced = true;
+        }
+      }
+      if (!coalesced) {
+        const readPromise = store.getTaskWorkflowSelectionAsync ? store.getTaskWorkflowSelectionAsync(taskId) : Promise.resolve(store.getTaskWorkflowSelection(taskId));
+        if (inflight) inflight.set(taskId, readPromise);
+        try {
+          selection = await readPromise;
+        } finally {
+          inflight?.delete(taskId);
+        }
+      }
+      selectionCache?.set(taskId, selection);
+    }
     workflowId = selection?.workflowId;
   } catch {
     return { ir: defaultCodingWorkflowIr(), source: "default" };

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

@@ -1074,7 +1074,7 @@ function sql(strings, ...params) {
     return new SQL([new StringChunk(str)]);
   }
   sql2.raw = raw;
-  function join4(chunks, separator) {
+  function join5(chunks, separator) {
     const result = [];
     for (const [i, chunk] of chunks.entries()) {
       if (i > 0 && separator !== void 0) {
@@ -1084,7 +1084,7 @@ function sql(strings, ...params) {
     }
     return new SQL(result);
   }
-  sql2.join = join4;
+  sql2.join = join5;
   function identifier(value) {
     return new Name(value);
   }
@@ -4535,7 +4535,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((join4) => join4.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) {
@@ -10713,26 +10713,26 @@ function validateParallelism(nodes2, outgoing, nodesById) {
     }
     const joinsReached = /* @__PURE__ */ new Set();
     for (const edge of branchEdges) {
-      const join5 = walkBranchToJoin(edge.to, split.id, outgoing, nodesById);
-      if (!join5) {
+      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(join5);
+      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 join4 = nodesById.get(joinId);
-    const mode = join4.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 '${join4.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 '${join4.id}' quorum(${n}) exceeds the split's ${branchEdges.length} branches`
+          `join '${join5.id}' quorum(${n}) exceeds the split's ${branchEdges.length} branches`
         );
       }
     }
@@ -16113,6 +16113,7 @@ function applyPromptOverridesToIr(ir, overrides) {
 function defaultCodingWorkflowIr() {
   return resolveDefaultWorkflowIr();
 }
+var inflightSelectionReads = /* @__PURE__ */ new WeakMap();
 async function resolveWorkflowIrById(store, workflowId, irCache) {
   let projectId;
   try {
@@ -16156,8 +16157,34 @@ function didFallBackToDefault(ir) {
 async function resolveWorkflowIrForTaskWithProvenance(store, taskId, irCache, selectionCache) {
   let workflowId;
   try {
-    const selection = selectionCache?.has(taskId) ? selectionCache.get(taskId) : store.getTaskWorkflowSelectionAsync ? await store.getTaskWorkflowSelectionAsync(taskId) : store.getTaskWorkflowSelection(taskId);
-    if (!selectionCache?.has(taskId)) selectionCache?.set(taskId, selection);
+    const isSelectionCached = selectionCache?.has(taskId) ?? false;
+    let selection = isSelectionCached && selectionCache ? selectionCache.get(taskId) : void 0;
+    if (!isSelectionCached) {
+      let inflight;
+      let coalesced = false;
+      if (selectionCache) {
+        inflight = inflightSelectionReads.get(selectionCache);
+        if (!inflight) {
+          inflight = /* @__PURE__ */ new Map();
+          inflightSelectionReads.set(selectionCache, inflight);
+        }
+        const pending = inflight.get(taskId);
+        if (pending) {
+          selection = await pending;
+          coalesced = true;
+        }
+      }
+      if (!coalesced) {
+        const readPromise = store.getTaskWorkflowSelectionAsync ? store.getTaskWorkflowSelectionAsync(taskId) : Promise.resolve(store.getTaskWorkflowSelection(taskId));
+        if (inflight) inflight.set(taskId, readPromise);
+        try {
+          selection = await readPromise;
+        } finally {
+          inflight?.delete(taskId);
+        }
+      }
+      selectionCache?.set(taskId, selection);
+    }
     workflowId = selection?.workflowId;
   } catch {
     return { ir: defaultCodingWorkflowIr(), source: "default" };
@@ -37619,6 +37646,207 @@ function buildPromptBlocks(prompt, opts) {
   return blocks;
 }
 
+// ../../plugins/fusion-plugin-acp-runtime/src/tool-bridge.ts
+import { createServer } from "node:http";
+import { existsSync as existsSync2, unlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname as dirname4, join as join4 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { randomBytes as randomBytes2, randomUUID as randomUUID2 } from "node:crypto";
+var BUILT_IN_TOOL_NAMES = /* @__PURE__ */ new Set(["read", "write", "edit", "bash", "grep", "find"]);
+var TOOL_DRAIN_TIMEOUT_MS = 5e3;
+function toolsToMcpToolDefs(tools) {
+  if (!Array.isArray(tools)) return [];
+  return tools.filter((tool) => tool && typeof tool.name === "string" && tool.name.trim().length > 0 && !BUILT_IN_TOOL_NAMES.has(tool.name) && typeof tool.execute === "function").map((tool) => ({
+    name: tool.name,
+    description: typeof tool.description === "string" ? tool.description : "",
+    inputSchema: tool.parameters ?? { type: "object", properties: {} }
+  }));
+}
+function fusionToolsMcpServerPath() {
+  return join4(dirname4(fileURLToPath2(import.meta.url)), "mcp-schema-server.cjs");
+}
+function missingMcpSchemaServerError(serverPath) {
+  const error51 = new Error(`Fusion MCP schema server is missing: ${serverPath}`);
+  error51.code = "mcp-schema-server-missing";
+  return error51;
+}
+function resultToText(result) {
+  if (result == null) return "";
+  if (typeof result === "string") return result;
+  if (typeof result === "object") {
+    const obj = result;
+    if (typeof obj.text === "string") return obj.text;
+    if (Array.isArray(obj.content)) {
+      return obj.content.map((block) => {
+        if (block && typeof block === "object" && "text" in block && typeof block.text === "string") {
+          return block.text;
+        }
+        return JSON.stringify(block);
+      }).join("\n");
+    }
+  }
+  try {
+    return JSON.stringify(result);
+  } catch {
+    return String(result);
+  }
+}
+async function startFusionToolBridge(tools) {
+  const defs = toolsToMcpToolDefs(tools);
+  if (defs.length === 0) return null;
+  const serverPath = fusionToolsMcpServerPath();
+  if (!existsSync2(serverPath)) {
+    throw missingMcpSchemaServerError(serverPath);
+  }
+  const byName = /* @__PURE__ */ new Map();
+  for (const tool of tools ?? []) {
+    if (tool && typeof tool.name === "string" && !BUILT_IN_TOOL_NAMES.has(tool.name) && typeof tool.execute === "function") {
+      byName.set(tool.name, tool);
+    }
+  }
+  const token = randomBytes2(24).toString("hex");
+  const schemaPath = join4(tmpdir(), `fusion-acp-mcp-schemas-${process.pid}-${randomUUID2()}.json`);
+  writeFileSync(schemaPath, JSON.stringify(defs));
+  const activeExecutions = /* @__PURE__ */ new Set();
+  const activeControllers = /* @__PURE__ */ new Set();
+  const server = createServer((req, res) => {
+    void (async () => {
+      if (req.method !== "POST" || req.url !== "/tool-call") {
+        res.statusCode = 404;
+        res.end(JSON.stringify({ isError: true, text: "not found" }));
+        return;
+      }
+      const auth = req.headers.authorization;
+      if (auth !== `Bearer ${token}`) {
+        res.statusCode = 401;
+        res.end(JSON.stringify({ isError: true, text: "unauthorized" }));
+        return;
+      }
+      let body = "";
+      for await (const chunk of req) body += chunk;
+      if (disposed) {
+        res.statusCode = 503;
+        res.end(JSON.stringify({ isError: true, text: "tool bridge disposed" }));
+        return;
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(body || "{}");
+      } catch {
+        res.statusCode = 400;
+        res.end(JSON.stringify({ isError: true, text: "invalid JSON body" }));
+        return;
+      }
+      const name = typeof parsed.name === "string" ? parsed.name : "";
+      const tool = byName.get(name);
+      if (!tool?.execute) {
+        res.statusCode = 404;
+        res.end(JSON.stringify({ isError: true, text: `Unknown Fusion tool: ${name}` }));
+        return;
+      }
+      const execute = tool.execute;
+      const controller = new AbortController();
+      activeControllers.add(controller);
+      const execution = (async () => {
+        try {
+          const result = await execute(
+            (typeof parsed.toolCallId === "string" || typeof parsed.toolCallId === "number") && String(parsed.toolCallId) ? String(parsed.toolCallId) : `acp-mcp-${randomUUID2()}`,
+            parsed.arguments ?? {},
+            controller.signal,
+            void 0,
+            void 0
+          );
+          res.statusCode = 200;
+          res.setHeader("content-type", "application/json");
+          res.end(
+            JSON.stringify({
+              isError: typeof result === "object" && result !== null && "isError" in result && result.isError === true,
+              content: [{ type: "text", text: resultToText(result) }]
+            })
+          );
+        } catch (err) {
+          res.statusCode = 200;
+          res.setHeader("content-type", "application/json");
+          res.end(
+            JSON.stringify({
+              isError: true,
+              content: [{ type: "text", text: err instanceof Error ? err.message : String(err) }]
+            })
+          );
+        }
+      })();
+      activeExecutions.add(execution);
+      try {
+        await execution;
+      } finally {
+        activeExecutions.delete(execution);
+        activeControllers.delete(controller);
+      }
+    })().catch(() => {
+    });
+  });
+  let address;
+  try {
+    address = await new Promise((resolve5, reject) => {
+      server.once("error", reject);
+      server.listen(0, "127.0.0.1", () => {
+        const addr = server.address();
+        if (!addr || typeof addr === "string") {
+          reject(new Error("tool bridge failed to bind"));
+          return;
+        }
+        resolve5({ port: addr.port });
+      });
+    });
+  } catch (error51) {
+    server.close();
+    try {
+      unlinkSync(schemaPath);
+    } catch {
+    }
+    throw error51;
+  }
+  const bridgeUrl = `http://127.0.0.1:${address.port}`;
+  let disposed = false;
+  return {
+    toolCount: defs.length,
+    mcpServer: {
+      name: "fusion-custom-tools",
+      command: process.execPath,
+      args: [serverPath, schemaPath],
+      env: [
+        { name: "FUSION_ACP_TOOL_BRIDGE_URL", value: bridgeUrl },
+        { name: "FUSION_ACP_TOOL_BRIDGE_TOKEN", value: token }
+      ]
+    },
+    dispose: async () => {
+      if (disposed) return;
+      disposed = true;
+      for (const controller of activeControllers) controller.abort();
+      server.close(() => void 0);
+      if (typeof server.closeAllConnections === "function") {
+        server.closeAllConnections();
+      }
+      await Promise.allSettled(
+        [...activeExecutions].map(
+          (execution) => Promise.race([
+            execution,
+            new Promise((resolve5) => {
+              const timer = setTimeout(resolve5, TOOL_DRAIN_TIMEOUT_MS);
+              timer.unref?.();
+            })
+          ])
+        )
+      );
+      try {
+        unlinkSync(schemaPath);
+      } catch {
+      }
+    }
+  };
+}
+
 // ../../plugins/fusion-plugin-acp-runtime/src/runtime-adapter.ts
 var AcpRuntimeAdapter = class {
   id = "acp";
@@ -37658,20 +37886,38 @@ var AcpRuntimeAdapter = class {
       clientHandler,
       ...this.settings.authenticate ? { authenticate: this.settings.authenticate } : {}
     });
+    let toolBridge = null;
+    let toolBridgeFailure;
     let sessionId;
+    const customTools = Array.isArray(options.customTools) ? options.customTools : [];
     try {
+      if (customTools.length > 0) {
+        try {
+          toolBridge = await startFusionToolBridge(customTools);
+        } catch (error51) {
+          toolBridgeFailure = error51.code === "mcp-schema-server-missing" ? "mcp-schema-server-missing" : "bridge-start-failed";
+          options.onText?.(`FUSION_TOOL_BRIDGE_FAILED: ${toolBridgeFailure}`);
+        }
+      }
       const sessionMeta = options && typeof options === "object" && "sessionMeta" in options ? options.sessionMeta : void 0;
       const opened = await newAcpSession(connection, {
         cwd: options.cwd,
-        mcpServers: options.mcpServers,
+        mcpServers: [...options.mcpServers ?? [], ...toolBridge ? [toolBridge.mcpServer] : []],
         meta: sessionMeta
       });
       sessionId = opened.sessionId;
     } catch (err) {
+      await toolBridge?.dispose();
       connection.dispose();
       throw err;
     }
     let disposed = false;
+    let bridgeDisposePromise;
+    let disposePromise = Promise.resolve();
+    const disposeBridge = () => {
+      bridgeDisposePromise ??= toolBridge?.dispose() ?? Promise.resolve();
+      return bridgeDisposePromise;
+    };
     const session = {
       model,
       systemPrompt: options.systemPrompt,
@@ -37679,6 +37925,7 @@ var AcpRuntimeAdapter = class {
       cwd: options.cwd,
       lastModelDescription: `acp/${model}`,
       callbacks,
+      fusionToolBridgeError: toolBridgeFailure ? { reasonCode: toolBridgeFailure } : void 0,
       // Persist the per-run gate (KTD3) so U5/U7 can reach the live action gate.
       gate: options.actionGateContext,
       connection,
@@ -37686,10 +37933,15 @@ var AcpRuntimeAdapter = class {
       // turn that trips the per-turn output cap can't latch and suppress every
       // subsequent turn (FIX 1).
       resetTurn,
+      disposeBridge,
+      get disposePromise() {
+        return disposePromise;
+      },
       dispose: () => {
         if (disposed) return;
         disposed = true;
         cancelPending();
+        disposePromise = disposeBridge();
         connection.dispose();
       }
     };
@@ -37714,13 +37966,14 @@ var AcpRuntimeAdapter = class {
     if (acp.connection && acp.sessionId) {
       await cancelAcpSession(acp.connection, acp.sessionId);
     }
+    await acp.disposeBridge?.();
     session.dispose();
   }
 };
 
 // ../../plugins/fusion-plugin-acp-runtime/src/setup.ts
-import { dirname as dirname4, relative, resolve as resolve4, sep as sep2 } from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { dirname as dirname5, relative, resolve as resolve4, sep as sep2 } from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // ../../plugins/fusion-plugin-acp-runtime/src/probe.ts
 function isMissingBinary(err) {
@@ -37789,7 +38042,7 @@ function isInside(parent, child) {
   return rel === "" || !rel.startsWith("..") && !rel.includes(`..${sep2}`);
 }
 function defaultPluginRoot() {
-  return resolve4(dirname4(fileURLToPath2(import.meta.url)), "..");
+  return resolve4(dirname5(fileURLToPath3(import.meta.url)), "..");
 }
 function validateBundledBridgeIdentity(binaryPath, pluginRoot = defaultPluginRoot()) {
   const expectedBin = resolve4(bundledClaudeBridgeBinPath(pluginRoot));

package/dist/plugins/fusion-plugin-acp-runtime/mcp-schema-server.cjs

@@ -0,0 +1,171 @@
+#!/usr/bin/env node
+/*
+FNXC:AcpCustomTools 2026-08-16-00:30:
+Executable MCP bridge for Fusion custom tools (fn_*) on generic ACP paths
+(Hermes ACP, Prime, ...). tools/list is served from a schema file; tools/call
+POSTs to a localhost bridge owned by AcpRuntimeAdapter so ToolDefinition.execute
+runs in-process with the engine's closures. The bridge authenticates the POST
+with a per-session bearer token passed via FUSION_ACP_TOOL_BRIDGE_TOKEN.
+*/
+"use strict";
+
+const fs = require("fs");
+const http = require("http");
+const readline = require("readline");
+// FNXC:AcpCustomTools 2026-08-16-00:30: CJS has no global URL under eslint no-undef; use node:url.
+const { URL } = require("node:url");
+
+const schemaPath = process.argv[2];
+const bridgeUrl = process.env.FUSION_ACP_TOOL_BRIDGE_URL;
+const bridgeToken = process.env.FUSION_ACP_TOOL_BRIDGE_TOKEN;
+if (!schemaPath || !bridgeUrl) {
+  process.stderr.write("fusion-custom-tools-mcp: missing schema path or FUSION_ACP_TOOL_BRIDGE_URL\n");
+  process.exit(1);
+}
+
+let tools = [];
+try {
+  tools = JSON.parse(fs.readFileSync(schemaPath, "utf-8"));
+  if (!Array.isArray(tools)) tools = [];
+} catch {
+  process.exit(1);
+}
+
+function write(msg) {
+  process.stdout.write(JSON.stringify(msg) + "\n");
+}
+
+function callBridge(toolName, toolCallId, args) {
+  return new Promise((resolve, reject) => {
+    const body = JSON.stringify({ name: toolName, toolCallId, arguments: args ?? {} });
+    const url = new URL("/tool-call", bridgeUrl);
+    const req = http.request(
+      {
+        hostname: url.hostname,
+        port: url.port,
+        path: url.pathname,
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          "content-length": Buffer.byteLength(body),
+          ...(bridgeToken ? { authorization: `Bearer ${bridgeToken}` } : {}),
+        },
+        timeout: 120_000,
+      },
+      (res) => {
+        let data = "";
+        res.on("data", (chunk) => {
+          data += chunk;
+        });
+        res.on("end", () => {
+          // A non-2xx bridge response is a transport failure, not a tool result:
+          // surface it as an error instead of fabricating an empty "success".
+          if (res.statusCode < 200 || res.statusCode >= 300) {
+            reject(new Error(`tool bridge responded ${res.statusCode}: ${data.slice(0, 200)}`));
+            return;
+          }
+          try {
+            resolve(JSON.parse(data || "{}"));
+          } catch (err) {
+            reject(err);
+          }
+        });
+      },
+    );
+    req.on("error", reject);
+    req.on("timeout", () => {
+      req.destroy(new Error("tool bridge timeout"));
+    });
+    req.write(body);
+    req.end();
+  });
+}
+
+const rl = readline.createInterface({ input: process.stdin });
+rl.on("line", (line) => {
+  let msg;
+  try {
+    msg = JSON.parse(line);
+  } catch {
+    return;
+  }
+
+  if (msg.method === "initialize") {
+    write({
+      jsonrpc: "2.0",
+      id: msg.id,
+      result: {
+        protocolVersion: "2024-11-05",
+        capabilities: { tools: {} },
+        serverInfo: { name: "fusion-custom-tools", version: "1.0.0" },
+      },
+    });
+    return;
+  }
+
+  // Ping must answer: some clients (Hermes ACP) treat a missing handler as a
+  // method-not-found and back off.
+  if (msg.method === "ping") {
+    write({ jsonrpc: "2.0", id: msg.id, result: {} });
+    return;
+  }
+
+  if (msg.method === "notifications/initialized" || msg.method === "initialized") {
+    return;
+  }
+
+  if (msg.method === "tools/list") {
+    write({
+      jsonrpc: "2.0",
+      id: msg.id,
+      result: {
+        tools: tools.map((tool) => ({
+          name: tool.name,
+          description: tool.description ?? "",
+          inputSchema: tool.inputSchema ?? { type: "object", properties: {} },
+        })),
+      },
+    });
+    return;
+  }
+
+  if (msg.method === "tools/call") {
+    const toolName = msg.params?.name;
+    const args = msg.params?.arguments ?? {};
+    // JSON-RPC ids are commonly numbers; coerce so the bridge threads the real
+    // request id as the toolCallId instead of falling back to a fabricated id.
+    const toolCallId = typeof msg.id === "string" ? msg.id : String(msg.id);
+    callBridge(toolName, toolCallId, args)
+      .then((result) => {
+        write({
+          jsonrpc: "2.0",
+          id: msg.id,
+          result: {
+            content: Array.isArray(result.content)
+              ? result.content
+              : [{ type: "text", text: typeof result.text === "string" ? result.text : JSON.stringify(result) }],
+            isError: result.isError === true,
+          },
+        });
+      })
+      .catch((err) => {
+        write({
+          jsonrpc: "2.0",
+          id: msg.id,
+          result: {
+            content: [{ type: "text", text: err instanceof Error ? err.message : String(err) }],
+            isError: true,
+          },
+        });
+      });
+    return;
+  }
+
+  if (msg.id !== undefined) {
+    write({
+      jsonrpc: "2.0",
+      id: msg.id,
+      error: { code: -32601, message: `Method not found: ${msg.method}` },
+    });
+  }
+});

package/dist/plugins/fusion-plugin-acp-runtime/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/acp-runtime",
-  "version": "0.1.36-beta.0",
+  "version": "0.1.36-beta.2",
   "type": "module",
   "exports": {
     ".": {

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

@@ -16113,6 +16113,7 @@ function applyPromptOverridesToIr(ir, overrides) {
 function defaultCodingWorkflowIr() {
   return resolveDefaultWorkflowIr();
 }
+var inflightSelectionReads = /* @__PURE__ */ new WeakMap();
 async function resolveWorkflowIrById(store, workflowId, irCache) {
   let projectId;
   try {
@@ -16156,8 +16157,34 @@ function didFallBackToDefault(ir) {
 async function resolveWorkflowIrForTaskWithProvenance(store, taskId, irCache, selectionCache) {
   let workflowId;
   try {
-    const selection = selectionCache?.has(taskId) ? selectionCache.get(taskId) : store.getTaskWorkflowSelectionAsync ? await store.getTaskWorkflowSelectionAsync(taskId) : store.getTaskWorkflowSelection(taskId);
-    if (!selectionCache?.has(taskId)) selectionCache?.set(taskId, selection);
+    const isSelectionCached = selectionCache?.has(taskId) ?? false;
+    let selection = isSelectionCached && selectionCache ? selectionCache.get(taskId) : void 0;
+    if (!isSelectionCached) {
+      let inflight;
+      let coalesced = false;
+      if (selectionCache) {
+        inflight = inflightSelectionReads.get(selectionCache);
+        if (!inflight) {
+          inflight = /* @__PURE__ */ new Map();
+          inflightSelectionReads.set(selectionCache, inflight);
+        }
+        const pending = inflight.get(taskId);
+        if (pending) {
+          selection = await pending;
+          coalesced = true;
+        }
+      }
+      if (!coalesced) {
+        const readPromise = store.getTaskWorkflowSelectionAsync ? store.getTaskWorkflowSelectionAsync(taskId) : Promise.resolve(store.getTaskWorkflowSelection(taskId));
+        if (inflight) inflight.set(taskId, readPromise);
+        try {
+          selection = await readPromise;
+        } finally {
+          inflight?.delete(taskId);
+        }
+      }
+      selectionCache?.set(taskId, selection);
+    }
     workflowId = selection?.workflowId;
   } catch {
     return { ir: defaultCodingWorkflowIr(), source: "default" };

package/dist/plugins/fusion-plugin-claude-runtime/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/claude-runtime",
-  "version": "0.1.11-beta.0",
+  "version": "0.1.11-beta.2",
   "type": "module",
   "exports": {
     ".": {