@runfusion/fusion 0.9.4 → 0.11.0

package/dist/pi-claude-cli/index.ts

@@ -9,8 +9,8 @@ import { getModels } from "@mariozechner/pi-ai";
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { streamViaCli } from "./src/provider.js";
 import {
-  validateCliPresence,
-  validateCliAuth,
+  validateCliPresenceAsync,
+  validateCliAuthAsync,
   killAllProcesses,
 } from "./src/process-manager.js";
 import { createHash } from "node:crypto";
@@ -26,6 +26,31 @@ process.on("exit", killAllProcesses);
 
 const PROVIDER_ID = "pi-claude-cli";
 
+/**
+ * Run CLI presence + auth probes at most once per process, asynchronously.
+ *
+ * The factory below is invoked on every `createFnAgent` call (the dashboard
+ * does this per chat message). Doing the probes synchronously with execSync
+ * froze the entire Node event loop for a few seconds while `claude` cold-
+ * started. Memoizing as a Promise + spawning the probes async means the
+ * factory returns immediately and other requests keep flowing; the result
+ * is logged once on first run and reused thereafter.
+ */
+let cliValidationPromise: Promise<void> | undefined;
+
+function runCliValidationOnce(): Promise<void> {
+  if (cliValidationPromise) return cliValidationPromise;
+  cliValidationPromise = (async () => {
+    const presence = await validateCliPresenceAsync();
+    if (!presence.ok) {
+      console.warn(`[pi-claude-cli] ${presence.error.message}`);
+      return;
+    }
+    await validateCliAuthAsync();
+  })();
+  return cliValidationPromise;
+}
+
 let cachedMcpConfig: { hash: string; configPath: string } | undefined;
 const DEBUG_MCP = process.env.PI_CLAUDE_CLI_DEBUG === "1";
 
@@ -116,9 +141,10 @@ function ensureMcpConfig(
 
 export default function (pi: ExtensionAPI) {
   try {
-    // Startup validation
-    validateCliPresence(); // throws if CLI not on PATH
-    validateCliAuth(); // warns if not authenticated
+    // Startup validation: kick off async, memoized presence + auth probes
+    // without blocking the factory. Failures surface via warnings; the actual
+    // `claude` subprocess in streamViaCli still reports hard errors on send.
+    void runCliValidationOnce();
 
     const catalogModels = getModels("anthropic").map((model) => ({
       id: model.id,

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

@@ -1,6 +1,6 @@
 {
   "name": "@fusion/pi-claude-cli",
-  "version": "0.9.4",
+  "version": "0.11.0",
   "description": "Fusion vendored fork: pi coding-agent extension that routes LLM calls through the Claude Code CLI. Forked from rchern/pi-claude-cli (MIT). See UPSTREAM.md.",
   "license": "MIT",
   "private": true,

package/dist/pi-claude-cli/src/__tests__/process-manager.test.ts

@@ -47,6 +47,8 @@ import {
   captureStderr,
   validateCliPresence,
   validateCliAuth,
+  validateCliPresenceAsync,
+  validateCliAuthAsync,
   forceKillProcess,
   registerProcess,
   killAllProcesses,
@@ -407,6 +409,94 @@ describe("validateCliAuth", () => {
   });
 });
 
+describe("validateCliPresenceAsync", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("resolves ok=true when claude --version exits 0", async () => {
+    const EventEmitter = require("node:events");
+    (spawn as any).mockImplementationOnce(() => {
+      const proc = new EventEmitter();
+      proc.kill = vi.fn();
+      setImmediate(() => proc.emit("exit", 0));
+      return proc;
+    });
+
+    const result = await validateCliPresenceAsync();
+    expect(result).toEqual({ ok: true });
+    const args = (spawn as any).mock.calls[0][1] as string[];
+    expect(args).toEqual(["--version"]);
+  });
+
+  it("resolves ok=false with install message when spawn errors", async () => {
+    const EventEmitter = require("node:events");
+    (spawn as any).mockImplementationOnce(() => {
+      const proc = new EventEmitter();
+      proc.kill = vi.fn();
+      setImmediate(() => proc.emit("error", new Error("ENOENT")));
+      return proc;
+    });
+
+    const result = await validateCliPresenceAsync();
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error.message).toContain("Claude Code CLI not found");
+      expect(result.error.message).toContain("npm install");
+    }
+  });
+
+  it("resolves ok=false when claude --version exits non-zero", async () => {
+    const EventEmitter = require("node:events");
+    (spawn as any).mockImplementationOnce(() => {
+      const proc = new EventEmitter();
+      proc.kill = vi.fn();
+      setImmediate(() => proc.emit("exit", 1));
+      return proc;
+    });
+
+    const result = await validateCliPresenceAsync();
+    expect(result.ok).toBe(false);
+  });
+});
+
+describe("validateCliAuthAsync", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("resolves true when claude auth status exits 0", async () => {
+    const EventEmitter = require("node:events");
+    (spawn as any).mockImplementationOnce(() => {
+      const proc = new EventEmitter();
+      proc.kill = vi.fn();
+      setImmediate(() => proc.emit("exit", 0));
+      return proc;
+    });
+
+    expect(await validateCliAuthAsync()).toBe(true);
+    const args = (spawn as any).mock.calls[0][1] as string[];
+    expect(args).toEqual(["auth", "status"]);
+  });
+
+  it("resolves false and warns when claude auth status fails", async () => {
+    const EventEmitter = require("node:events");
+    (spawn as any).mockImplementationOnce(() => {
+      const proc = new EventEmitter();
+      proc.kill = vi.fn();
+      setImmediate(() => proc.emit("exit", 1));
+      return proc;
+    });
+    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+
+    expect(await validateCliAuthAsync()).toBe(false);
+    expect(warnSpy).toHaveBeenCalledWith(
+      expect.stringContaining("not authenticated"),
+    );
+    warnSpy.mockRestore();
+  });
+});
+
 describe("CLI flags", () => {
   beforeEach(() => {
     vi.clearAllMocks();

package/dist/pi-claude-cli/src/__tests__/provider.test.ts

@@ -168,10 +168,10 @@ describe("provider registration (default export)", () => {
   });
 });
 
-describe("streamViaCli", () => {
+describe("streamViaCli", { timeout: 90_000 }, () => {
   beforeEach(() => {
     vi.clearAllMocks();
-    vi.useFakeTimers();
+    vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout"] });
     vi.spyOn(console, "warn").mockImplementation(() => {});
     vi.spyOn(console, "error").mockImplementation(() => {});
     delete process.env.PI_CLAUDE_CLI_DEBUG;
@@ -183,7 +183,7 @@ describe("streamViaCli", () => {
     delete process.env.PI_CLAUDE_CLI_DEBUG;
   });
 
-  it("returns an AssistantMessageEventStream", () => {
+  it("returns an AssistantMessageEventStream", async () => {
     const model = mockModels[0] as any;
     const context = {
       messages: [{ role: "user", content: "Hello" }],
@@ -194,6 +194,16 @@ describe("streamViaCli", () => {
     expect(result).toBeDefined();
     expect(result.push).toBeDefined();
     expect(result.end).toBeDefined();
+
+    // Ensure the spawned process/readline lifecycle completes so fake timers
+    // don't leave the test hanging on the inactivity timeout.
+    await vi.advanceTimersByTimeAsync(0);
+    const proc = (spawn as any).mock.results[0].value;
+    proc.stdout.write(
+      `${JSON.stringify({ type: "result", subtype: "success", result: "ok" })}\n`,
+    );
+    proc.stdout.end();
+    await vi.advanceTimersByTimeAsync(0);
   });
 
   it("logs PID and spawn args when debug mode is enabled", async () => {

package/dist/pi-claude-cli/src/process-manager.ts

@@ -241,3 +241,68 @@ export function validateCliAuth(): boolean {
     return false;
   }
 }
+
+/**
+ * Run a one-shot `claude <args>` and resolve to the exit code.
+ *
+ * Why: the sync execSync variants block the Node event loop for the duration
+ * of a Claude CLI cold start (1–3s, occasionally longer). When pi-claude-cli's
+ * factory is invoked from a per-request createFnAgent path (Fusion dashboard
+ * does this on every chat send), those sync probes freeze every other request.
+ * This async variant uses spawn so the loop keeps turning while the subprocess
+ * starts up.
+ */
+function runClaudeProbe(args: string[], timeoutMs = 5000): Promise<number> {
+  return new Promise((resolve) => {
+    const proc = spawn("claude", args, { stdio: "ignore" });
+    const timer = setTimeout(() => {
+      try {
+        proc.kill("SIGKILL");
+      } catch {
+        // already dead
+      }
+      resolve(124);
+    }, timeoutMs);
+    proc.once("error", () => {
+      clearTimeout(timer);
+      resolve(127);
+    });
+    proc.once("exit", (code) => {
+      clearTimeout(timer);
+      resolve(code ?? 1);
+    });
+  });
+}
+
+/**
+ * Async, non-blocking variant of validateCliPresence.
+ * Resolves with `{ok: true}` on success, `{ok: false, error}` on failure —
+ * never rejects, so callers can fire-and-forget without unhandled rejections.
+ */
+export async function validateCliPresenceAsync(): Promise<
+  { ok: true } | { ok: false; error: Error }
+> {
+  const code = await runClaudeProbe(["--version"]);
+  if (code === 0) return { ok: true };
+  return {
+    ok: false,
+    error: new Error(
+      "Claude Code CLI not found. Install it: npm install -g @anthropic-ai/claude-code\n" +
+        "Then authenticate: claude auth login",
+    ),
+  };
+}
+
+/**
+ * Async, non-blocking variant of validateCliAuth.
+ * Returns true if authenticated. Logs a warning (does not throw) otherwise.
+ */
+export async function validateCliAuthAsync(): Promise<boolean> {
+  const code = await runClaudeProbe(["auth", "status"]);
+  if (code === 0) return true;
+  console.warn(
+    "[pi-claude-cli] Claude CLI is not authenticated. " +
+      "Run 'claude auth login' to authenticate.",
+  );
+  return false;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runfusion/fusion",
-  "version": "0.9.4",
+  "version": "0.11.0",
   "license": "MIT",
   "description": "Fusion CLI: HTTP API server, daemon, dashboard launcher, and task tooling for the Fusion AI coding agent.",
   "homepage": "https://github.com/Runfusion/Fusion#readme",

package/skill/fusion/SKILL.md

@@ -32,6 +32,8 @@ Mission → Milestone → Slice → Feature → Task
 - **Mission tools** — `fn_mission_create`, `fn_mission_list`, `fn_mission_show`, `fn_mission_delete`, `fn_milestone_add`, `fn_slice_add`, `fn_feature_add`, `fn_slice_activate`, `fn_feature_link_task`
 - **Agent tools** — `fn_agent_stop`, `fn_agent_start`
 - **Skills tools** — `fn_skills_search`, `fn_skills_install`
+- **Insight tools** — `fn_insight_list`, `fn_insight_show`, `fn_insight_run_list`, `fn_insight_run_show`
+- **Other tools** — `fn_research_run`, `fn_research_list`, `fn_research_get`, `fn_research_cancel`
 <!-- END: tool-categories -->
 - **Dashboard** — Use `/fn` command to start/stop the dashboard
 

package/skill/fusion/references/engine-tools.md

@@ -17,6 +17,10 @@ These tools are **not** part of the pi extension's user-invokable `extension.ts`
 | `fn_memory_search` | triage, executor, heartbeat | Search project/agent memory snippets | `query` (string), `limit?` (number) |
 | `fn_memory_get` | triage, executor, heartbeat | Read a bounded memory file window | `path` (string), `startLine?` (number), `lineCount?` (number) |
 | `fn_memory_append` | executor, heartbeat (when writable backend enabled) | Append long-term/daily memory notes | `scope?` (`project` \| `agent`), `layer` (`long-term` \| `daily`), `content` (string) |
+| `fn_research_run` | triage, executor | Start a bounded research run (optionally wait for completion) and return structured findings metadata | `query` (string), `wait_for_completion?` (boolean), `max_wait_ms?` (number) |
+| `fn_research_list` | triage, executor | List recent research runs with status/summary metadata | `status?` (`pending` \| `running` \| `completed` \| `failed` \| `cancelled`), `limit?` (number) |
+| `fn_research_get` | triage, executor | Read one research run's structured findings/citations payload | `id` (string) |
+| `fn_research_cancel` | triage, executor | Cancel an active research run via orchestrator cancellation path | `id` (string) |
 | `fn_reflect_on_performance` | executor | Generate reflection insights from prior runs | `focus_area?` (string) |
 | `fn_list_agents` | triage, executor, heartbeat | List agents (optionally filtered) | `role?` (string), `state?` (string), `includeEphemeral?` (boolean) |
 | `fn_delegate_task` | triage, executor, heartbeat | Create and assign a new task to a specific agent | `agent_id` (string), `description` (string), `dependencies?` (string[]) |

package/skill/fusion/references/extension-tools.md

@@ -283,6 +283,82 @@ Install an agent skill from skills.sh into the current project. Downloads skill
 | `source` | string | ✓ | GitHub source in owner/repo format (e.g., 'firebase/agent-skills') |
 | `skill` | string | — | Specific skill name to install (e.g., 'firebase-basics'). Omit to install all skills from the source. |
 
+## Insight Tools
+
+### fn_insight_list
+
+List persisted project insights with optional category/status filters.
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `category` | string(enum) | — | Filter by insight category |
+| `status` | string(enum) | — | Filter by insight status |
+| `runId` | string | — | Filter to insights linked to a specific run ID |
+| `limit` | number | — | Max insights to return |
+| `offset` | number | — | Number of rows to skip |
+
+### fn_insight_show
+
+Show a single persisted insight by ID.
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `id` | string | ✓ | Insight ID (e.g. INS-XXXXX) |
+
+### fn_insight_run_list
+
+List recent insight-generation runs with optional status/trigger filters.
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `status` | string(enum) | — | Filter by run status |
+| `trigger` | string(enum) | — | Filter by run trigger |
+| `limit` | number | — | Max runs to return |
+| `offset` | number | — | Number of runs to skip |
+
+### fn_insight_run_show
+
+Show a single insight-generation run by ID.
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `id` | string | ✓ | Insight run ID (e.g. INSR-XXXXX) |
+
+## Other Tools
+
+### fn_research_run
+
+Start a bounded research run and optionally wait for findings.
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `query` | string | ✓ | Research query or question |
+
+### fn_research_list
+
+List recent research runs.
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `status` | string(enum) | — |  |
+| `limit` | number | — | Max runs to return (default: 10) |
+
+### fn_research_get
+
+Get one research run and structured findings.
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `id` | string | ✓ | Research run ID |
+
+### fn_research_cancel
+
+Cancel a research run.
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `id` | string | ✓ | Research run ID |
+
 <!-- END: extension-tools -->
 ## Dashboard Command
 

package/skill/fusion/references/fusion-capabilities.md

@@ -29,6 +29,14 @@ All skill/extension tool invocations in this catalog use the public `fn_*` names
 | `fn_task_import_github_issue` | Import a specific GitHub issue as a Fusion task. Fetches the issue by number and creates a single task in the planning column with the issue title and body. |
 | `fn_task_browse_github_issues` | List open GitHub issues from a repository to browse before importing. Returns issue numbers, titles, and URLs for selection. Use with fn_task_import_github_issue to import specific issues by number. |
 | `fn_task_plan` | Create a task via AI-guided planning mode — interactive conversation to refine your idea into a well-specified task. |
+| `fn_research_run` | Start a bounded research run and optionally wait for findings. |
+| `fn_research_list` | List recent research runs. |
+| `fn_research_get` | Get one research run and structured findings. |
+| `fn_research_cancel` | Cancel a research run. |
+| `fn_insight_list` | List persisted project insights with optional category/status filters. |
+| `fn_insight_show` | Show a single persisted insight by ID. |
+| `fn_insight_run_list` | List recent insight-generation runs with optional status/trigger filters. |
+| `fn_insight_run_show` | Show a single insight-generation run by ID. |
 | `fn_mission_create` | Create a new mission — a high-level objective that can span multiple milestones. Missions contain milestones that break down work into phases. |
 | `fn_mission_list` | List all missions with their current status. |
 | `fn_mission_show` | Show mission details with full hierarchy: milestones → slices → features. |