@runfusion/fusion 0.43.1 → 0.45.0

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

@@ -15,6 +15,10 @@ function definePlugin(plugin2) {
 }
 
 // ../../plugins/fusion-plugin-acp-runtime/src/cli-spawn.ts
+import { existsSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+var CLAUDE_CODE_CLI_ACP_BINARY = "claude-code-cli-acp";
 function asTrimmedString(value) {
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
 }
@@ -26,15 +30,74 @@ function asStringArray(value) {
 function asBool(value) {
   return value === true;
 }
+function pluginRootDir() {
+  return resolve(dirname(fileURLToPath(import.meta.url)), "..");
+}
+function bundledClaudeBridgeBinPath(pluginRoot = pluginRootDir()) {
+  const extension = process.platform === "win32" ? ".cmd" : "";
+  return join(pluginRoot, "node_modules", ".bin", `${CLAUDE_CODE_CLI_ACP_BINARY}${extension}`);
+}
+function resolveBundledClaudeBridgeBinary(options = {}) {
+  const root = options.pluginRoot ?? pluginRootDir();
+  const exists = options.exists ?? existsSync;
+  const candidate = bundledClaudeBridgeBinPath(root);
+  if (!exists(candidate)) {
+    return {
+      kind: "not_resolved",
+      requested: CLAUDE_CODE_CLI_ACP_BINARY,
+      path: candidate,
+      reason: `Bundled ${CLAUDE_CODE_CLI_ACP_BINARY} binary was not found at ${candidate}`
+    };
+  }
+  if (!isAbsolute(candidate)) {
+    return {
+      kind: "not_resolved",
+      requested: CLAUDE_CODE_CLI_ACP_BINARY,
+      path: candidate,
+      reason: `Bundled ${CLAUDE_CODE_CLI_ACP_BINARY} path is not absolute`
+    };
+  }
+  return { kind: "resolved", requested: CLAUDE_CODE_CLI_ACP_BINARY, path: candidate };
+}
 function resolveCliSettings(settings) {
-  const binaryPath = asTrimmedString(settings?.acpBinaryPath) ?? "acp-agent";
+  const requestedBinaryPath = asTrimmedString(settings?.acpBinaryPath);
+  let binaryPath = requestedBinaryPath ?? "acp-agent";
+  let binaryResolution;
+  if (requestedBinaryPath === CLAUDE_CODE_CLI_ACP_BINARY) {
+    binaryResolution = resolveBundledClaudeBridgeBinary();
+    if (binaryResolution.kind === "resolved" && binaryResolution.path) {
+      binaryPath = binaryResolution.path;
+    }
+  }
   const args = asStringArray(settings?.acpArgs) ?? [];
   const model = asTrimmedString(settings?.acpModel);
   const fsRead = asBool(settings?.acpFsRead);
   const fsWrite = asBool(settings?.acpFsWrite);
   const envAllowList = asStringArray(settings?.acpEnvAllowList) ?? [];
   const allowUnrestricted = asBool(settings?.acpAllowUnrestricted);
-  return { binaryPath, args, model, fsRead, fsWrite, envAllowList, allowUnrestricted };
+  return {
+    binaryPath,
+    args,
+    model,
+    fsRead,
+    fsWrite,
+    envAllowList,
+    requiredEnv: [],
+    allowUnrestricted,
+    binaryResolution
+  };
+}
+function resolveClaudeBridgeAskSettings(settings) {
+  const resolved = resolveCliSettings({
+    ...settings,
+    acpBinaryPath: CLAUDE_CODE_CLI_ACP_BINARY,
+    acpArgs: [],
+    acpFsRead: false,
+    acpFsWrite: false,
+    acpEnvAllowList: ["HOME", "PATH"],
+    acpAllowUnrestricted: false
+  });
+  return { ...resolved, requiredEnv: ["HOME"] };
 }
 
 // ../../plugins/fusion-plugin-acp-runtime/src/provider.ts
@@ -15982,8 +16045,8 @@ var Connection = class {
     this.requestHandler = requestHandler;
     this.notificationHandler = notificationHandler;
     this.stream = stream;
-    this.closedPromise = new Promise((resolve2) => {
-      this.abortController.signal.addEventListener("abort", () => resolve2());
+    this.closedPromise = new Promise((resolve4) => {
+      this.abortController.signal.addEventListener("abort", () => resolve4());
     });
     void this.receive();
   }
@@ -16153,11 +16216,11 @@ var Connection = class {
       return rejectedPromise(this.closedReason());
     }
     const id = this.nextRequestId++;
-    const responsePromise = new Promise((resolve2, reject) => {
+    const responsePromise = new Promise((resolve4, reject) => {
       this.pendingResponses.set(id, {
         resolve: (response) => {
           try {
-            resolve2(mapResponse ? mapResponse(response) : response);
+            resolve4(mapResponse ? mapResponse(response) : response);
           } catch (error48) {
             reject(error48);
           }
@@ -16292,12 +16355,25 @@ function killAllProcesses() {
   }
   activeProcesses.clear();
 }
-function buildSpawnEnv(allowList) {
+var MissingAcpEnvError = class extends Error {
+  constructor(missingKeys) {
+    super(`Missing required ACP environment variable(s): ${missingKeys.join(", ")}`);
+    this.missingKeys = missingKeys;
+    this.name = "MissingAcpEnvError";
+  }
+  code = "ACP_MISSING_ENV";
+};
+function buildSpawnEnv(allowList, options = {}) {
+  const sourceEnv = options.sourceEnv ?? process.env;
   const env = {};
   for (const key of allowList) {
-    const value = process.env[key];
+    const value = sourceEnv[key];
     if (typeof value === "string") env[key] = value;
   }
+  const missing = (options.required ?? []).filter((key) => typeof env[key] !== "string");
+  if (missing.length > 0) {
+    throw new MissingAcpEnvError(missing);
+  }
   return env;
 }
 function spawnAgent(options) {
@@ -17001,13 +17077,13 @@ function createBridgingClientHandler(callbacks, gate, fsOpts, permissionOpts) {
     },
     async requestPermission(params) {
       if (cancelled) return cancelledResponse;
-      return await new Promise((resolve2) => {
+      return await new Promise((resolve4) => {
         let settled = false;
         const finish = (response) => {
           if (settled) return;
           settled = true;
           pending.delete(drain);
-          resolve2(response);
+          resolve4(response);
         };
         const drain = (response) => finish(response);
         pending.add(drain);
@@ -17024,13 +17100,13 @@ function createBridgingClientHandler(callbacks, gate, fsOpts, permissionOpts) {
   return { handler, cancelPending, resetTurn: () => bridge.reset() };
 }
 function withTimeout(promise2, ms, onTimeout) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve4, reject) => {
     const timer = setTimeout(() => reject(onTimeout()), ms);
     timer.unref?.();
     promise2.then(
       (value) => {
         clearTimeout(timer);
-        resolve2(value);
+        resolve4(value);
       },
       (err) => {
         clearTimeout(timer);
@@ -17107,7 +17183,10 @@ async function connect(opts) {
   };
 }
 async function newAcpSession(connection, opts) {
-  const res = await connection.conn.newSession({ cwd: opts.cwd, mcpServers: [] });
+  const res = await connection.conn.newSession({
+    cwd: opts.cwd,
+    mcpServers: opts.mcpServers ?? []
+  });
   return { sessionId: boundIdentifier(res.sessionId), modes: res.modes ?? void 0 };
 }
 async function promptAcpSession(connection, sessionId, blocks) {
@@ -17119,8 +17198,8 @@ async function cancelAcpSession(connection, sessionId) {
   try {
     await Promise.race([
       connection.conn.cancel({ sessionId }),
-      new Promise((resolve2) => {
-        const timer = setTimeout(resolve2, CANCEL_TIMEOUT_MS);
+      new Promise((resolve4) => {
+        const timer = setTimeout(resolve4, CANCEL_TIMEOUT_MS);
         timer.unref?.();
       })
     ]);
@@ -17179,13 +17258,16 @@ var AcpRuntimeAdapter = class {
       binaryPath: this.settings.binaryPath,
       args: this.settings.args,
       cwd: options.cwd,
-      env: buildSpawnEnv(this.settings.envAllowList),
+      env: buildSpawnEnv(this.settings.envAllowList, { required: this.settings.requiredEnv }),
       advertiseFs: { read: this.settings.fsRead, write: this.settings.fsWrite },
       clientHandler
     });
     let sessionId;
     try {
-      const opened = await newAcpSession(connection, { cwd: options.cwd });
+      const opened = await newAcpSession(connection, {
+        cwd: options.cwd,
+        mcpServers: options.mcpServers
+      });
       sessionId = opened.sessionId;
     } catch (err) {
       connection.dispose();
@@ -17222,7 +17304,8 @@ var AcpRuntimeAdapter = class {
     }
     acp.resetTurn?.();
     const blocks = buildPromptBlocks(prompt);
-    await promptAcpSession(acp.connection, acp.sessionId, blocks);
+    const stopReason = await promptAcpSession(acp.connection, acp.sessionId, blocks);
+    return { stopReason };
   }
   describeModel(session) {
     return session.lastModelDescription || "acp";
@@ -17236,6 +17319,144 @@ var AcpRuntimeAdapter = class {
   }
 };
 
+// ../../plugins/fusion-plugin-acp-runtime/src/setup.ts
+import { dirname as dirname3, relative, resolve as resolve3, sep as sep2 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+
+// ../../plugins/fusion-plugin-acp-runtime/src/probe.ts
+function isMissingBinary(err) {
+  const code = err?.code;
+  return code === "ENOENT";
+}
+async function probeAcpReadiness(opts) {
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_INITIALIZE_TIMEOUT_MS;
+  let connection;
+  try {
+    connection = await connect({
+      binaryPath: opts.binaryPath,
+      args: opts.args,
+      cwd: opts.cwd,
+      env: opts.env,
+      // Probe with fs capabilities OFF — readiness must not advertise anything
+      // the real session might not (KTD6).
+      advertiseFs: { read: false, write: false },
+      initializeTimeoutMs: timeoutMs
+    });
+    const authRequired = connection.authMethods.length > 0;
+    return {
+      ok: true,
+      reason: "ok",
+      authRequired
+    };
+  } catch (err) {
+    if (err instanceof HandshakeTimeoutError) {
+      return { ok: false, reason: "handshake_timeout", detail: err.message };
+    }
+    if (err instanceof IncompatibleProtocolError) {
+      return {
+        ok: false,
+        reason: "incompatible_protocol",
+        detail: err.message,
+        protocolVersion: err.agentProtocolVersion
+      };
+    }
+    if (isMissingBinary(err)) {
+      return {
+        ok: false,
+        reason: "missing_binary",
+        detail: `ACP agent binary not found: ${opts.binaryPath}`
+      };
+    }
+    return {
+      ok: false,
+      reason: "spawn_error",
+      detail: err instanceof Error ? err.message : String(err)
+    };
+  } finally {
+    connection?.dispose();
+  }
+}
+
+// ../../plugins/fusion-plugin-acp-runtime/src/setup.ts
+var setupManifest = {
+  binaryName: CLAUDE_CODE_CLI_ACP_BINARY,
+  description: "Claude Code ACP bridge used by Fusion's read-only ask path",
+  channel: "beta",
+  defaultTimeoutMs: 3e4
+};
+var MAX_PROBE_TIMEOUT_MS = 3e4;
+function isInside(parent, child) {
+  const rel = relative(resolve3(parent), resolve3(child));
+  return rel === "" || !rel.startsWith("..") && !rel.includes(`..${sep2}`);
+}
+function defaultPluginRoot() {
+  return resolve3(dirname3(fileURLToPath2(import.meta.url)), "..");
+}
+function validateBundledBridgeIdentity(binaryPath, pluginRoot = defaultPluginRoot()) {
+  const expectedBin = resolve3(bundledClaudeBridgeBinPath(pluginRoot));
+  const expectedNodeModules = resolve3(pluginRoot, "node_modules");
+  if (resolve3(binaryPath) !== expectedBin && !isInside(expectedNodeModules, binaryPath)) {
+    return `Resolved ${CLAUDE_CODE_CLI_ACP_BINARY} must come from this plugin's node_modules, got ${binaryPath}`;
+  }
+  return void 0;
+}
+function statusFromProbe(probe, binaryPath) {
+  if (probe.ok) {
+    if (probe.authRequired) {
+      return {
+        status: "error",
+        binaryPath,
+        error: "Claude authentication required: run `claude` once to authenticate before using the ACP bridge."
+      };
+    }
+    return { status: "installed", binaryPath };
+  }
+  if (probe.reason === "missing_binary") {
+    return {
+      status: "not-installed",
+      error: `Install bundled dependency ${CLAUDE_CODE_CLI_ACP_BINARY}@0.1.1 and run pnpm install for this plugin.`
+    };
+  }
+  if (probe.reason === "unauthenticated") {
+    return {
+      status: "error",
+      binaryPath,
+      error: "Claude authentication required: run `claude` once to authenticate before using the ACP bridge."
+    };
+  }
+  return { status: "error", binaryPath, error: probe.detail ?? `ACP readiness failed: ${probe.reason}` };
+}
+async function checkSetup(ctx, deps = {}) {
+  const settings = resolveClaudeBridgeAskSettings(ctx.settings);
+  if (settings.binaryResolution?.kind === "not_resolved") {
+    return {
+      status: "not-installed",
+      error: settings.binaryResolution.reason ?? `Install ${CLAUDE_CODE_CLI_ACP_BINARY}@0.1.1`
+    };
+  }
+  const identityError = validateBundledBridgeIdentity(settings.binaryPath, deps.pluginRoot);
+  if (identityError) {
+    return { status: "error", error: identityError, binaryPath: settings.binaryPath };
+  }
+  let env;
+  try {
+    env = buildSpawnEnv(settings.envAllowList, { required: settings.requiredEnv });
+  } catch (err) {
+    return { status: "error", binaryPath: settings.binaryPath, error: err instanceof Error ? err.message : String(err) };
+  }
+  const probe = await (deps.probe ?? probeAcpReadiness)({
+    binaryPath: settings.binaryPath,
+    args: settings.args,
+    cwd: process.cwd(),
+    env,
+    timeoutMs: MAX_PROBE_TIMEOUT_MS
+  });
+  return statusFromProbe(probe, settings.binaryPath);
+}
+var setupHooks = {
+  checkSetup
+};
+
 // ../../plugins/fusion-plugin-acp-runtime/src/index.ts
 process.on("exit", killAllProcesses);
 var ACP_RUNTIME_ID = "acp";
@@ -17268,19 +17489,42 @@ var plugin = definePlugin({
           "ACP Runtime: acpAllowUnrestricted is set \u2014 sensitive tool calls from the untrusted agent will be auto-approved under an allow-all policy. Prefer an approval-required policy."
         );
       }
+      if (!process.env.FUSION_CLAUDE_ACP_BRIDGE) {
+        const resolved = resolveBundledClaudeBridgeBinary();
+        if (resolved.kind === "resolved") {
+          process.env.FUSION_CLAUDE_ACP_BRIDGE = resolved.path;
+          ctx.logger.info(
+            "ACP Runtime: published bundled Claude bridge path for Route A (transport stays off until FUSION_CLAUDE_ACP=1)."
+          );
+        } else {
+          ctx.logger.info(`ACP Runtime: bundled Claude bridge not resolved (${resolved.reason}); Route A unavailable.`);
+        }
+      }
     }
   },
   runtime: {
     metadata: acpRuntimeMetadata,
     factory: acpRuntimeFactory
+  },
+  setup: {
+    manifest: setupManifest,
+    hooks: setupHooks
   }
 });
 var index_default = plugin;
 export {
   ACP_RUNTIME_ID,
   AcpRuntimeAdapter,
+  CLAUDE_CODE_CLI_ACP_BINARY,
   acpRuntimeFactory,
   acpRuntimeMetadata,
+  bundledClaudeBridgeBinPath,
+  checkSetup,
   index_default as default,
-  resolveCliSettings
+  resolveBundledClaudeBridgeBinary,
+  resolveClaudeBridgeAskSettings,
+  resolveCliSettings,
+  setupHooks,
+  setupManifest,
+  validateBundledBridgeIdentity
 };

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

@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/acp-runtime",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "type": "module",
   "exports": {
     ".": {

package/dist/plugins/fusion-plugin-cli-printing-press/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/cli-printing-press",
-  "version": "0.1.23",
+  "version": "0.1.25",
   "type": "module",
   "description": "CLI Printing Press plugin package for Fusion",
   "private": true,

package/dist/plugins/fusion-plugin-compound-engineering/bundled.js

@@ -58,6 +58,18 @@ var COMPOUND_ENGINEERING_SKILLS = [
     enabled: true,
     triggerPatterns: ["code review", "review this change", "review before PR"]
   },
+  {
+    /*
+     * FNXC:CompoundEngineering 2026-06-16-19:40:
+     * ce-debug is bundled beside the other pinned CE skills so bug-shaped investigation sessions install from the plugin-local snapshot and never depend on an operator's global skill cache.
+     */
+    skillId: "ce-debug",
+    name: "ce-debug",
+    description: "Investigate bug-shaped work by reproducing failures, testing hypotheses, isolating root cause, and producing findings before implementation.",
+    skillFiles: ["skills/ce-debug/SKILL.md"],
+    enabled: true,
+    triggerPatterns: ["debug", "investigate a bug", "root cause", "regression", "broken behavior", "error message"]
+  },
   {
     skillId: "ce-compound",
     name: "ce-compound",
@@ -546,6 +558,19 @@ var STAGE_DEFINITIONS = [
     icon: "Hammer",
     label: "Work",
     artifactGlob: "docs/work/**/*.md"
+  },
+  {
+    /*
+     * FNXC:CompoundEngineering 2026-06-16-19:40:
+     * debug is an operator-launchable investigation session appended after work so the existing strategy→ideate→brainstorm→plan→work auto-advance chain remains unchanged.
+     */
+    stageId: "debug",
+    order: 600,
+    skillId: "ce-debug",
+    artifactLocation: "docs/debug/",
+    icon: "Bug",
+    label: "Debug",
+    artifactGlob: "docs/debug/**/*.md"
   }
 ];
 var REGISTRY = new Map(STAGE_DEFINITIONS.map((s) => [s.stageId, s]));
@@ -562,7 +587,7 @@ function registerStage(def) {
 // ../../plugins/fusion-plugin-compound-engineering/src/settings.ts
 var DEFAULT_PROVIDER = "";
 var DEFAULT_MODEL_ID = "";
-var DEFAULT_ENABLED_STAGES = listStages().map((s) => s.stageId);
+var DEFAULT_DISABLED_STAGES = [];
 var DEFAULT_RECONCILE_ON_HOOKS = true;
 var DEFAULT_RECONCILE_INTERVAL_MINUTES = 15;
 var settingsSchema = {
@@ -580,13 +605,13 @@ var settingsSchema = {
     group: "Sessions",
     defaultValue: DEFAULT_MODEL_ID
   },
-  enabledStages: {
+  disabledStages: {
     type: "array",
     itemType: "string",
-    label: "Enabled Stages",
-    description: "Stage IDs that may be launched from the Compound Engineering view (for example strategy, ideate, brainstorm, plan, work).",
+    label: "Disabled Stages",
+    description: "Stage IDs hidden from launch in the Compound Engineering view. Empty means all registered stages are launchable.",
     group: "Sessions",
-    defaultValue: DEFAULT_ENABLED_STAGES
+    defaultValue: DEFAULT_DISABLED_STAGES
   },
   reconcileOnHooks: {
     type: "boolean",
@@ -627,8 +652,12 @@ function getDefaultProvider(settings) {
 function getDefaultModelId(settings) {
   return asString(settings, "defaultModelId");
 }
+function getDisabledStages(settings) {
+  return asStringArray(settings, "disabledStages", DEFAULT_DISABLED_STAGES);
+}
 function getEnabledStages(settings) {
-  return asStringArray(settings, "enabledStages", listStages().map((s) => s.stageId));
+  const disabled = new Set(getDisabledStages(settings));
+  return listStages().map((s) => s.stageId).filter((stageId) => !disabled.has(stageId));
 }
 function getReconcileOnHooks(settings) {
   return asBoolean(settings, "reconcileOnHooks", DEFAULT_RECONCILE_ON_HOOKS);
@@ -1046,7 +1075,7 @@ var CeOrchestrator = class {
   async start(stageId, opts) {
     const stage = getStage(stageId);
     if (!stage) throw new Error(`Unknown CE stage: ${stageId}`);
-    if (!getEnabledStages(this.ctx.settings).includes(stageId)) {
+    if (getDisabledStages(this.ctx.settings).includes(stageId)) {
       throw new Error(`CE stage is not enabled: ${stageId}`);
     }
     if (!this.factory) {
@@ -2175,6 +2204,7 @@ export {
   getCeSessionStore,
   getDefaultModelId,
   getDefaultProvider,
+  getDisabledStages,
   getEnabledStages,
   getReconcileIntervalMinutes,
   getReconcileOnHooks,

package/dist/plugins/fusion-plugin-compound-engineering/manifest.json

@@ -30,13 +30,13 @@
       "group": "Sessions",
       "defaultValue": ""
     },
-    "enabledStages": {
+    "disabledStages": {
       "type": "array",
       "itemType": "string",
-      "label": "Enabled Stages",
-      "description": "Stage IDs that may be launched from the Compound Engineering view (for example strategy, ideate, brainstorm, plan, work).",
+      "label": "Disabled Stages",
+      "description": "Stage IDs hidden from launch in the Compound Engineering view. Empty means all registered stages are launchable.",
       "group": "Sessions",
-      "defaultValue": ["strategy", "ideate", "brainstorm", "plan", "work"]
+      "defaultValue": []
     },
     "reconcileOnHooks": {
       "type": "boolean",

package/dist/plugins/fusion-plugin-compound-engineering/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/compound-engineering",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "type": "module",
   "exports": {
     ".": {

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

@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/cursor-runtime",
-  "version": "0.1.25",
+  "version": "0.1.27",
   "type": "module",
   "exports": {
     ".": {

package/dist/plugins/fusion-plugin-dependency-graph/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/dependency-graph",
-  "version": "0.1.37",
+  "version": "0.1.39",
   "type": "module",
   "exports": {
     ".": {