@alexeiled/pi-fusion 0.2.1 → 0.2.3

package/docs/user-guide.md

@@ -110,7 +110,8 @@ Panel member:
 - `id`: stable machine name
 - `label`: human-readable report label
 - `agent`: subagent name
-- `model`: optional model override; often the main source of panel diversity
+- `model`: optional model override; often the main source of panel diversity. Supports normal Pi model ids, and if `pi-claude-alias` is configured, Claude alias shorthand like `claude-work/opus-4.8`
+- Claude alias handles must be unique across global and project alias files; duplicate handles are rejected.
 - `thinking`: optional `off`, `minimal`, `low`, `medium`, `high`, or `xhigh`
 - `role`: optional perspective hint layered on top of the model
 
@@ -162,7 +163,7 @@ Deliberate review:
           "id": "architect",
           "label": "Architect",
           "agent": "pi-fusion.fusion-panelist",
-          "model": "anthropic/claude-sonnet-4",
+          "model": "claude-work/sonnet-4.6",
           "thinking": "high",
           "role": "architecture and failure modes"
         },
@@ -177,7 +178,7 @@ Deliberate review:
       ],
       "judge": {
         "agent": "pi-fusion.fusion-judge",
-        "model": "anthropic/claude-sonnet-4",
+        "model": "claude-work/sonnet-4.6",
         "thinking": "high"
       },
       "concurrency": 2,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alexeiled/pi-fusion",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Stronger answers for hard Pi questions via a parallel model panel + judge, built on pi-subagents",
   "type": "module",
   "main": "./src/index.ts",

package/src/claude-aliases.ts

@@ -0,0 +1,255 @@
+import { CONFIG_DIR_NAME, getAgentDir } from "@earendil-works/pi-coding-agent";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import type { FusionConfig } from "./types.js";
+import { FusionConfigError } from "./errors.js";
+import { isNodeErrorCode, isNonEmptyString, isRecord } from "./utils.js";
+import type { FusionConfigLoadContext } from "./config.js";
+
+const CLAUDE_ALIAS_CONFIG_FILE = "claude-alias.json";
+
+interface ClaudeAliasDefinition {
+  slug: string;
+  providerId: string;
+  handle: string;
+}
+
+interface AliasFileDeps {
+  readTextFile?: (path: string) => Promise<string>;
+  agentDir?: string;
+}
+
+interface RawAliasConfig {
+  aliases?: unknown;
+}
+
+interface RawAliasEntry {
+  slug?: unknown;
+  handle?: unknown;
+}
+
+export async function applyClaudeAliasShorthand(
+  config: FusionConfig,
+  ctx: FusionConfigLoadContext,
+  deps: AliasFileDeps = {},
+): Promise<FusionConfig> {
+  const aliases = await loadClaudeAliases(ctx, deps);
+  if (aliases.length === 0) return config;
+
+  return {
+    ...config,
+    profiles: Object.fromEntries(
+      Object.entries(config.profiles).map(([name, profile]) => [
+        name,
+        {
+          ...profile,
+          panel: profile.panel.map((member) => ({
+            ...member,
+            ...(member.model
+              ? { model: resolveClaudeAliasModelSpec(member.model, aliases) }
+              : {}),
+          })),
+          judge: {
+            ...profile.judge,
+            ...(profile.judge.model
+              ? { model: resolveClaudeAliasModelSpec(profile.judge.model, aliases) }
+              : {}),
+          },
+        },
+      ]),
+    ),
+  };
+}
+
+export function resolveClaudeAliasModelSpec(
+  model: string,
+  aliases: readonly ClaudeAliasDefinition[],
+): string {
+  const trimmed = model.trim();
+  const slashIndex = trimmed.indexOf("/");
+  if (slashIndex <= 0 || slashIndex === trimmed.length - 1) return trimmed;
+
+  const handle = trimmed.slice(0, slashIndex).trim().toLowerCase();
+  const modelRef = trimmed.slice(slashIndex + 1).trim();
+  const alias = aliases.find((item) => item.handle === handle);
+  if (!alias) return trimmed;
+
+  return `${alias.providerId}/${normalizeAnthropicModelRef(modelRef)}`;
+}
+
+export function normalizeAnthropicModelRef(modelRef: string): string {
+  const normalized = modelRef
+    .trim()
+    .toLowerCase()
+    .replace(/[._\s]+/g, "-")
+    .replace(/-+/g, "-")
+    .replace(/^-+|-+$/g, "");
+
+  if (!normalized) return modelRef.trim();
+  return normalized.startsWith("claude-") ? normalized : `claude-${normalized}`;
+}
+
+async function loadClaudeAliases(
+  ctx: FusionConfigLoadContext,
+  deps: AliasFileDeps,
+): Promise<ClaudeAliasDefinition[]> {
+  const readTextFile = deps.readTextFile ?? readUtf8File;
+  const global = await readOptionalAliasFile(
+    getGlobalClaudeAliasConfigPath(deps.agentDir),
+    readTextFile,
+  );
+  const project = ctx.isProjectTrusted()
+    ? await readOptionalAliasFile(
+        getProjectClaudeAliasConfigPath(ctx.cwd),
+        readTextFile,
+      )
+    : undefined;
+
+  const merged = new Map<string, ClaudeAliasDefinition>();
+  for (const alias of global ?? []) {
+    merged.set(alias.slug, alias);
+  }
+  for (const alias of project ?? []) {
+    merged.set(alias.slug, alias);
+  }
+
+  const aliases = [...merged.values()];
+  validateUniqueHandles(aliases);
+  return aliases;
+}
+
+async function readOptionalAliasFile(
+  path: string,
+  readTextFile: (path: string) => Promise<string>,
+): Promise<ClaudeAliasDefinition[] | undefined> {
+  let raw: string;
+  try {
+    raw = await readTextFile(path);
+  } catch (error: unknown) {
+    if (isNodeErrorCode(error, "ENOENT")) return undefined;
+    const message = error instanceof Error ? error.message : String(error);
+    throw new FusionConfigError(
+      `Could not read Claude alias config at ${path}: ${message}`,
+    );
+  }
+
+  return parseAliasFile(raw, path);
+}
+
+function parseAliasFile(raw: string, source: string): ClaudeAliasDefinition[] {
+  let value: unknown;
+  try {
+    value = JSON.parse(raw);
+  } catch (error: unknown) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new FusionConfigError(
+      `Invalid JSON in Claude alias config at ${source}: ${message}`,
+    );
+  }
+
+  if (!isRecord(value) || !Array.isArray((value as RawAliasConfig).aliases)) {
+    throw new FusionConfigError(
+      `Invalid Claude alias config at ${source}. Expected aliases array.`,
+    );
+  }
+
+  const aliasValues = (value as { aliases: unknown[] }).aliases;
+  const aliases: ClaudeAliasDefinition[] = [];
+  for (const [index, entry] of aliasValues.entries()) {
+    const parsed = parseAliasEntry(entry);
+    if (!parsed) {
+      throw new FusionConfigError(
+        `Invalid Claude alias entry at ${source} aliases[${index}].`,
+      );
+    }
+    aliases.push(parsed);
+  }
+
+  return dedupeAliases(aliases, source);
+}
+
+function parseAliasEntry(value: unknown): ClaudeAliasDefinition | undefined {
+  if (!isRecord(value)) return undefined;
+  const entry = value as RawAliasEntry;
+
+  const slug = normalizeSlug(entry.slug);
+  if (!slug) return undefined;
+
+  const handle = normalizeHandle(entry.handle) ?? `claude-${slug}`;
+  if (!handle) return undefined;
+
+  return {
+    slug,
+    providerId: `anthropic-${slug}`,
+    handle,
+  };
+}
+
+function dedupeAliases(
+  aliases: readonly ClaudeAliasDefinition[],
+  source: string,
+): ClaudeAliasDefinition[] {
+  const byHandle = new Set<string>();
+  const deduped: ClaudeAliasDefinition[] = [];
+
+  for (const alias of aliases) {
+    if (byHandle.has(alias.handle)) {
+      throw new FusionConfigError(
+        `Duplicate Claude alias handle "${alias.handle}" in ${source}.`,
+      );
+    }
+    byHandle.add(alias.handle);
+    deduped.push(alias);
+  }
+
+  return deduped;
+}
+
+function validateUniqueHandles(
+  aliases: readonly ClaudeAliasDefinition[],
+): void {
+  const seen = new Map<string, string>();
+
+  for (const alias of aliases) {
+    const existingSlug = seen.get(alias.handle);
+    if (existingSlug && existingSlug !== alias.slug) {
+      throw new FusionConfigError(
+        `Duplicate Claude alias handle "${alias.handle}" across merged config. Use a unique handle for each alias.`,
+      );
+    }
+    seen.set(alias.handle, alias.slug);
+  }
+}
+
+function normalizeSlug(value: unknown): string | undefined {
+  if (!isNonEmptyString(value)) return undefined;
+  const slug = value
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+  return slug || undefined;
+}
+
+function normalizeHandle(value: unknown): string | undefined {
+  if (value === undefined) return undefined;
+  if (!isNonEmptyString(value)) return undefined;
+  const handle = value
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+  return handle || undefined;
+}
+
+function getGlobalClaudeAliasConfigPath(agentDir = getAgentDir()): string {
+  return join(agentDir, CLAUDE_ALIAS_CONFIG_FILE);
+}
+
+function getProjectClaudeAliasConfigPath(cwd: string): string {
+  return join(cwd, CONFIG_DIR_NAME, CLAUDE_ALIAS_CONFIG_FILE);
+}
+
+async function readUtf8File(path: string): Promise<string> {
+  return readFile(path, "utf8");
+}

package/src/commands.ts

@@ -7,10 +7,11 @@ import {
   getProjectFusionConfigPath,
   writeProjectFusionConfigTemplate,
 } from "./config.js";
-import { FusionArgsError, FusionConfigError } from "./errors.js";
+import { FusionConfigError } from "./errors.js";
+import { parseFusionInlineCommand } from "./fusion-args.js";
+import type { ParsedFusionArgs } from "./types.js";
+import { isNodeErrorCode } from "./utils.js";
 
-const FUSION_USAGE =
-  "Usage: /fusion <prompt> | /fusion --profile <name> <prompt> | /fusion status | /fusion stop | /fusion init.";
 const FUSION_HELP = [
   "Fusion commands",
   "/fusion <prompt>",
@@ -20,39 +21,11 @@ const FUSION_HELP = [
   "/fusion init",
 ].join("\n");
 
-export type FusionInlineCommand = "init" | "status" | "stop";
-
-export interface ParsedFusionArgs {
-  prompt: string;
-  profile?: string;
-}
-
-interface FusionInitContext {
-  cwd: string;
-  hasUI: boolean;
-  isProjectTrusted(): boolean;
-  ui: {
-    confirm(title: string, message: string): Promise<boolean>;
-    notify(message: string, type?: "info" | "warning" | "error"): void;
-  };
-}
-
-export interface FusionInitDeps {
-  readTextFile?: (path: string) => Promise<string>;
-  writeTextFile?: (path: string, content: string) => Promise<void>;
-  ensureDir?: (path: string) => Promise<void>;
-}
-
-export type FusionInitResult =
-  | { status: "written"; path: string }
-  | {
-      status: "skipped";
-      reason: "untrusted" | "exists" | "cancelled";
-      path?: string;
-    };
-
 export interface FusionRuntimeCommandHandler {
-  startRun(args: string, ctx: ExtensionCommandContext): Promise<unknown>;
+  startRun(
+    args: string | ParsedFusionArgs,
+    ctx: ExtensionCommandContext,
+  ): Promise<unknown>;
   showStatus(ctx: ExtensionCommandContext): Promise<unknown>;
   cancelActiveRun(ctx: ExtensionCommandContext): Promise<unknown>;
 }
@@ -124,124 +97,29 @@ export async function runFusionInit(
   return { status: "written", path: writtenPath };
 }
 
-export function parseFusionInlineCommand(
-  input: string | readonly string[],
-): FusionInlineCommand | undefined {
-  const tokens =
-    typeof input === "string" ? tokenizeCommandArgs(input) : [...input];
-  if (tokens.length !== 1) return undefined;
-  const command = tokens[0];
-  if (command === "init" || command === "status" || command === "stop") {
-    return command;
-  }
-  return undefined;
+interface FusionInitContext {
+  cwd: string;
+  hasUI: boolean;
+  isProjectTrusted(): boolean;
+  ui: {
+    confirm(title: string, message: string): Promise<boolean>;
+    notify(message: string, type?: "info" | "warning" | "error"): void;
+  };
 }
 
-export function parseFusionArgs(
-  input: string | readonly string[],
-): ParsedFusionArgs {
-  const tokens =
-    typeof input === "string" ? tokenizeCommandArgs(input) : [...input];
-  if (tokens[0] === "/fusion" || tokens[0] === "fusion") tokens.shift();
-
-  let profile: string | undefined;
-  const promptTokens: string[] = [];
-
-  for (let index = 0; index < tokens.length; index++) {
-    const token = tokens[index];
-    if (!token) continue;
-
-    if (
-      promptTokens.length === 0 &&
-      (token === "--profile" || token === "-p")
-    ) {
-      const value = tokens[index + 1];
-      if (!value || value.startsWith("-")) {
-        throw new FusionArgsError(
-          `Missing value for ${token}. ${FUSION_USAGE}`,
-        );
-      }
-      if (profile)
-        throw new FusionArgsError("Profile can only be provided once.");
-      profile = value;
-      index++;
-      continue;
-    }
-
-    if (promptTokens.length === 0 && token.startsWith("--profile=")) {
-      const value = token.slice("--profile=".length).trim();
-      if (!value)
-        throw new FusionArgsError(
-          `Missing value for --profile. ${FUSION_USAGE}`,
-        );
-      if (profile)
-        throw new FusionArgsError("Profile can only be provided once.");
-      profile = value;
-      continue;
-    }
-
-    if (promptTokens.length === 0 && token.startsWith("-")) {
-      throw new FusionArgsError(`Unknown option ${token}. ${FUSION_USAGE}`);
-    }
-
-    promptTokens.push(token, ...tokens.slice(index + 1));
-    break;
-  }
-
-  const prompt = promptTokens.join(" ").trim();
-  if (!prompt) throw new FusionArgsError(FUSION_USAGE);
-  return profile ? { prompt, profile } : { prompt };
+export interface FusionInitDeps {
+  readTextFile?: (path: string) => Promise<string>;
+  writeTextFile?: (path: string, content: string) => Promise<void>;
+  ensureDir?: (path: string) => Promise<void>;
 }
 
-export function tokenizeCommandArgs(input: string): string[] {
-  const tokens: string[] = [];
-  let current = "";
-  let quote: "'" | '"' | undefined;
-  let escaping = false;
-
-  for (const char of input.trim()) {
-    if (escaping) {
-      current += char;
-      escaping = false;
-      continue;
-    }
-
-    if (char === "\\") {
-      escaping = true;
-      continue;
-    }
-
-    if (quote) {
-      if (char === quote) {
-        quote = undefined;
-      } else {
-        current += char;
-      }
-      continue;
-    }
-
-    if (char === "'" || char === '"') {
-      quote = char;
-      continue;
-    }
-
-    if (/\s/.test(char)) {
-      if (current) {
-        tokens.push(current);
-        current = "";
-      }
-      continue;
-    }
-
-    current += char;
-  }
-
-  if (escaping) current += "\\";
-  if (quote)
-    throw new FusionArgsError(`Unclosed ${quote} quote in /fusion arguments.`);
-  if (current) tokens.push(current);
-  return tokens;
-}
+export type FusionInitResult =
+  | { status: "written"; path: string }
+  | {
+      status: "skipped";
+      reason: "untrusted" | "exists" | "cancelled";
+      path?: string;
+    };
 
 async function fileExists(
   path: string,
@@ -259,15 +137,6 @@ async function fileExists(
   }
 }
 
-function isNodeErrorCode(error: unknown, code: string): boolean {
-  return (
-    typeof error === "object" &&
-    error !== null &&
-    "code" in error &&
-    error.code === code
-  );
-}
-
 async function readUtf8File(path: string): Promise<string> {
   return readFile(path, "utf8");
 }

package/src/config.ts

@@ -1,6 +1,7 @@
 import { CONFIG_DIR_NAME, getAgentDir } from "@earendil-works/pi-coding-agent";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
+import { applyClaudeAliasShorthand } from "./claude-aliases.js";
 import { FusionConfigError } from "./errors.js";
 import {
   THINKING_LEVELS,
@@ -11,6 +12,12 @@ import {
   type PanelMemberConfig,
   type ThinkingLevel,
 } from "./types.js";
+import {
+  isNodeErrorCode,
+  isNonEmptyString,
+  isPositiveInteger,
+  isRecord,
+} from "./utils.js";
 
 export const FUSION_CONFIG_FILE = "fusion.json";
 export const DEFAULT_PROFILE_NAME = "quality";
@@ -98,12 +105,15 @@ export async function loadFusionConfig(
   if (ctx.isProjectTrusted()) {
     const projectPath = getProjectFusionConfigPath(ctx.cwd);
     const projectConfig = await readOptionalConfig(projectPath, readTextFile);
-    if (projectConfig) return projectConfig;
+    if (projectConfig) {
+      return applyClaudeAliasShorthand(projectConfig, ctx, deps);
+    }
   }
 
   const globalPath = getGlobalFusionConfigPath(deps.agentDir);
   const globalConfig = await readOptionalConfig(globalPath, readTextFile);
-  return globalConfig ?? createDefaultFusionConfig();
+  const config = globalConfig ?? createDefaultFusionConfig();
+  return applyClaudeAliasShorthand(config, ctx, deps);
 }
 
 export function resolveProfile(
@@ -227,22 +237,6 @@ function isFusionContextMode(value: unknown): value is FusionContextMode {
   return value === "fresh" || value === "fork";
 }
 
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function isNonEmptyString(value: unknown): value is string {
-  return typeof value === "string" && value.trim().length > 0;
-}
-
-function isPositiveInteger(value: unknown): value is number {
-  return typeof value === "number" && Number.isInteger(value) && value > 0;
-}
-
-function isNodeErrorCode(error: unknown, code: string): boolean {
-  return isRecord(error) && error.code === code;
-}
-
 async function readUtf8File(path: string): Promise<string> {
   return readFile(path, "utf8");
 }

package/src/fusion-args.ts

@@ -0,0 +1,126 @@
+import { FusionArgsError } from "./errors.js";
+import type { ParsedFusionArgs } from "./types.js";
+
+const FUSION_USAGE =
+  "Usage: /fusion <prompt> | /fusion --profile <name> <prompt> | /fusion status | /fusion stop | /fusion init.";
+
+export type FusionInlineCommand = "init" | "status" | "stop";
+
+export function parseFusionInlineCommand(
+  input: string | readonly string[],
+): FusionInlineCommand | undefined {
+  const tokens =
+    typeof input === "string" ? tokenizeCommandArgs(input) : [...input];
+  if (tokens.length !== 1) return undefined;
+  const command = tokens[0];
+  if (command === "init" || command === "status" || command === "stop") {
+    return command;
+  }
+  return undefined;
+}
+
+export function parseFusionArgs(
+  input: string | readonly string[],
+): ParsedFusionArgs {
+  const tokens =
+    typeof input === "string" ? tokenizeCommandArgs(input) : [...input];
+  if (tokens[0] === "/fusion" || tokens[0] === "fusion") tokens.shift();
+
+  let profile: string | undefined;
+  const promptTokens: string[] = [];
+
+  for (let index = 0; index < tokens.length; index++) {
+    const token = tokens[index];
+    if (!token) continue;
+
+    if (
+      promptTokens.length === 0 &&
+      (token === "--profile" || token === "-p")
+    ) {
+      const value = tokens[index + 1];
+      if (!value || value.startsWith("-")) {
+        throw new FusionArgsError(
+          `Missing value for ${token}. ${FUSION_USAGE}`,
+        );
+      }
+      if (profile)
+        throw new FusionArgsError("Profile can only be provided once.");
+      profile = value;
+      index++;
+      continue;
+    }
+
+    if (promptTokens.length === 0 && token.startsWith("--profile=")) {
+      const value = token.slice("--profile=".length).trim();
+      if (!value)
+        throw new FusionArgsError(
+          `Missing value for --profile. ${FUSION_USAGE}`,
+        );
+      if (profile)
+        throw new FusionArgsError("Profile can only be provided once.");
+      profile = value;
+      continue;
+    }
+
+    if (promptTokens.length === 0 && token.startsWith("-")) {
+      throw new FusionArgsError(`Unknown option ${token}. ${FUSION_USAGE}`);
+    }
+
+    promptTokens.push(token, ...tokens.slice(index + 1));
+    break;
+  }
+
+  const prompt = promptTokens.join(" ").trim();
+  if (!prompt) throw new FusionArgsError(FUSION_USAGE);
+  return profile ? { prompt, profile } : { prompt };
+}
+
+export function tokenizeCommandArgs(input: string): string[] {
+  const tokens: string[] = [];
+  let current = "";
+  let quote: "'" | '"' | undefined;
+  let escaping = false;
+
+  for (const char of input.trim()) {
+    if (escaping) {
+      current += char;
+      escaping = false;
+      continue;
+    }
+
+    if (char === "\\") {
+      escaping = true;
+      continue;
+    }
+
+    if (quote) {
+      if (char === quote) {
+        quote = undefined;
+      } else {
+        current += char;
+      }
+      continue;
+    }
+
+    if (char === "'" || char === '"') {
+      quote = char;
+      continue;
+    }
+
+    if (/\s/.test(char)) {
+      if (current) {
+        tokens.push(current);
+        current = "";
+      }
+      continue;
+    }
+
+    current += char;
+  }
+
+  if (escaping) current += "\\";
+  if (quote)
+    throw new FusionArgsError(`Unclosed ${quote} quote in /fusion arguments.`);
+  if (current) tokens.push(current);
+  return tokens;
+}

package/src/orchestrator.ts

@@ -4,18 +4,17 @@ import {
   type ResolvedFusionProfile,
 } from "./config.js";
 import { FusionArgsError } from "./errors.js";
+import { parseFusionArgs } from "./fusion-args.js";
+import { decidePanelCompletion } from "./panel-completion.js";
 import {
   renderCancelledReport,
   renderFailureReport,
   renderJudgeReport,
-  renderPanelFailureReport,
-  renderSinglePanelReport,
 } from "./report.js";
 import { extractPanelResults } from "./result-extract.js";
 import {
   appendThinkingSuffix,
   buildFusionChainSpawnParams,
-  buildJudgeSpawnParams,
 } from "./run-builder.js";
 import { FusionRunStore, FusionRunStoreError } from "./run-store.js";
 import {
@@ -35,8 +34,8 @@ import type {
   FusionProfile,
   FusionRun,
   PanelOutput,
+  ParsedFusionArgs,
 } from "./types.js";
-import { parseFusionArgs, type ParsedFusionArgs } from "./commands.js";
 import type { SubagentsTargetParams } from "./subagents-rpc.js";
 
 export const SUBAGENT_ASYNC_COMPLETE_EVENT = "subagent:async-complete";
@@ -124,15 +123,7 @@ export class FusionOrchestrator {
   ): Promise<FusionCommandResult> {
     this.context = ctx;
 
-    let args: ParsedFusionArgs;
-    try {
-      args = typeof input === "string" ? parseFusionArgs(input) : input;
-    } catch (error: unknown) {
-      const message = errorMessage(error);
-      this.notify(ctx, message, "error");
-      return { status: "failed", error: message };
-    }
-
+    const args = typeof input === "string" ? parseFusionArgs(input) : input;
     const existing = this.runStore.getActiveRun();
     if (existing) {
       const message = `Fusion run ${existing.id} is already active.`;
@@ -475,61 +466,13 @@ export class FusionOrchestrator {
       return this.completeActiveRun(report);
     }
 
-    if (extracted.outputs.length === 0) {
-      const report = renderPanelFailureReport({
-        run: updated,
-        failures: extracted.failures,
-        ...withJudgeModel(configuredJudgeModel(profile)),
-      });
-      return this.failActiveRun(
-        "No fusion panelists completed successfully.",
-        report,
-      );
-    }
-
-    if (extracted.outputs.length === 1) {
-      const report = renderSinglePanelReport({
-        run: updated,
-        output: extracted.outputs[0]!,
-        failures: extracted.failures,
-        ...withJudgeModel(configuredJudgeModel(profile)),
-      });
-      return this.completeActiveRun(report);
-    }
-
-    try {
-      const spawnResult = await this.rpc.spawn(
-        buildJudgeSpawnParams({
-          profile,
-          prompt: active.prompt,
-          panelOutputs: extracted.outputs,
-          failedPanelists: extracted.failures,
-        }),
-      );
-      const judgeRunId = extractSubagentRunId(spawnResult);
-      if (!judgeRunId) {
-        throw new FusionArgsError(
-          "pi-subagents spawn did not return a fallback judge run ID.",
-        );
-      }
-      const judgeAsyncDir = extractSubagentAsyncDir(spawnResult);
-      const nextRun = this.runStore.updateRun(active.id, {
-        phase: "judge",
-        judgeRunId,
-        ...(judgeAsyncDir ? { judgeAsyncDir } : {}),
-        panelOutputs: extracted.outputs,
-        panelFailures: extracted.failures,
-      });
-      publishFusionStatus(this.context, nextRun);
-      this.notify(
-        this.context,
-        `Fusion fallback judge started: ${judgeRunId}`,
-        "info",
-      );
-      return { status: "started", run: nextRun };
-    } catch (error: unknown) {
-      return this.failActiveRun(errorMessage(error));
-    }
+    return this.finishPanelCompletion(
+      updated,
+      profile,
+      extracted.outputs,
+      extracted.failures,
+      { fallbackJudge: true },
+    );
   }
 
   private async handleLegacyPanelComplete(
@@ -576,53 +519,57 @@ export class FusionOrchestrator {
       extracted.failures,
     );
 
-    if (extracted.outputs.length === 0) {
-      const report = renderPanelFailureReport({
-        run: updated,
-        failures: extracted.failures,
-        ...withJudgeModel(configuredJudgeModel(profile)),
-      });
-      return this.failActiveRun(
-        "No fusion panelists completed successfully.",
-        report,
-      );
-    }
+    return this.finishPanelCompletion(
+      updated,
+      profile,
+      extracted.outputs,
+      extracted.failures,
+      { fallbackJudge: false },
+    );
+  }
 
-    if (extracted.outputs.length === 1) {
-      const report = renderSinglePanelReport({
-        run: updated,
-        output: extracted.outputs[0]!,
-        failures: extracted.failures,
-        ...withJudgeModel(configuredJudgeModel(profile)),
-      });
-      return this.completeActiveRun(report);
+  private async finishPanelCompletion(
+    run: FusionRun,
+    profile: FusionProfile,
+    panelOutputs: readonly PanelOutput[],
+    panelFailures: readonly FailedPanelSummary[],
+    options: { fallbackJudge: boolean },
+  ): Promise<FusionCommandResult> {
+    const decision = decidePanelCompletion({
+      run,
+      profile,
+      panelOutputs,
+      panelFailures,
+      fallbackJudge: options.fallbackJudge,
+    });
+
+    if (decision.kind === "fail") {
+      return this.failActiveRun(decision.error, decision.report);
+    }
+    if (decision.kind === "complete") {
+      return this.completeActiveRun(decision.report);
     }
 
     try {
-      const spawnResult = await this.rpc.spawn(
-        buildJudgeSpawnParams({
-          profile,
-          prompt: active.prompt,
-          panelOutputs: extracted.outputs,
-          failedPanelists: extracted.failures,
-        }),
-      );
+      const spawnResult = await this.rpc.spawn(decision.params);
       const judgeRunId = extractSubagentRunId(spawnResult);
       if (!judgeRunId) {
-        throw new FusionArgsError(
-          "pi-subagents spawn did not return a judge run ID.",
-        );
+        throw new FusionArgsError(decision.missingRunIdError);
       }
       const judgeAsyncDir = extractSubagentAsyncDir(spawnResult);
-      const nextRun = this.runStore.updateRun(active.id, {
+      const nextRun = this.runStore.updateRun(run.id, {
         phase: "judge",
         judgeRunId,
         ...(judgeAsyncDir ? { judgeAsyncDir } : {}),
-        panelOutputs: extracted.outputs,
-        panelFailures: extracted.failures,
+        panelOutputs: [...panelOutputs],
+        panelFailures: [...panelFailures],
       });
       publishFusionStatus(this.context, nextRun);
-      this.notify(this.context, `Fusion judge started: ${judgeRunId}`, "info");
+      this.notify(
+        this.context,
+        `${decision.notification}: ${judgeRunId}`,
+        "info",
+      );
       return { status: "started", run: nextRun };
     } catch (error: unknown) {
       return this.failActiveRun(errorMessage(error));

package/src/panel-completion.ts

@@ -0,0 +1,85 @@
+import { renderPanelFailureReport, renderSinglePanelReport } from "./report.js";
+import {
+  appendThinkingSuffix,
+  buildJudgeSpawnParams,
+  type JudgeSpawnParams,
+} from "./run-builder.js";
+import type {
+  FailedPanelSummary,
+  FusionProfile,
+  FusionRun,
+  PanelOutput,
+} from "./types.js";
+
+export type PanelCompletionDecision =
+  | { kind: "fail"; error: string; report: string }
+  | { kind: "complete"; report: string }
+  | {
+      kind: "judge";
+      params: JudgeSpawnParams;
+      missingRunIdError: string;
+      notification: string;
+    };
+
+export interface DecidePanelCompletionInput {
+  run: FusionRun;
+  profile: FusionProfile;
+  panelOutputs: readonly PanelOutput[];
+  panelFailures: readonly FailedPanelSummary[];
+  fallbackJudge?: boolean;
+}
+
+export function decidePanelCompletion(
+  input: DecidePanelCompletionInput,
+): PanelCompletionDecision {
+  const judgeModel = configuredJudgeModel(input.profile);
+
+  if (input.panelOutputs.length === 0) {
+    const report = renderPanelFailureReport({
+      run: input.run,
+      failures: input.panelFailures,
+      ...withJudgeModel(judgeModel),
+    });
+    return {
+      kind: "fail",
+      error: "No fusion panelists completed successfully.",
+      report,
+    };
+  }
+
+  if (input.panelOutputs.length === 1) {
+    const report = renderSinglePanelReport({
+      run: input.run,
+      output: input.panelOutputs[0]!,
+      failures: input.panelFailures,
+      ...withJudgeModel(judgeModel),
+    });
+    return { kind: "complete", report };
+  }
+
+  return {
+    kind: "judge",
+    params: buildJudgeSpawnParams({
+      profile: input.profile,
+      prompt: input.run.prompt,
+      panelOutputs: input.panelOutputs,
+      failedPanelists: input.panelFailures,
+    }),
+    missingRunIdError: input.fallbackJudge
+      ? "pi-subagents spawn did not return a fallback judge run ID."
+      : "pi-subagents spawn did not return a judge run ID.",
+    notification: input.fallbackJudge
+      ? "Fusion fallback judge started"
+      : "Fusion judge started",
+  };
+}
+
+function configuredJudgeModel(profile: FusionProfile): string | undefined {
+  return appendThinkingSuffix(profile.judge.model, profile.judge.thinking);
+}
+
+function withJudgeModel(
+  judgeModel: string | undefined,
+): { judgeModel: string } | Record<string, never> {
+  return judgeModel ? { judgeModel } : {};
+}

package/src/run-store.ts

@@ -1,5 +1,6 @@
 import { randomUUID } from "node:crypto";
 import type { FusionPhase, FusionRun } from "./types.js";
+import { isFiniteNumber, isNonEmptyString, isRecord } from "./utils.js";
 
 export const FUSION_RUN_ENTRY_TYPE = "fusion-run";
 
@@ -423,18 +424,6 @@ function isTerminalPhase(value: unknown): value is FusionTerminalPhase {
   return value === "done" || value === "failed" || value === "cancelled";
 }
 
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function isNonEmptyString(value: unknown): value is string {
-  return typeof value === "string" && value.trim().length > 0;
-}
-
-function isFiniteNumber(value: unknown): value is number {
-  return typeof value === "number" && Number.isFinite(value);
-}
-
 function isPanelOutputArray(
   value: unknown,
 ): value is NonNullable<FusionRun["panelOutputs"]> {

package/src/types.ts

@@ -38,6 +38,11 @@ export interface FusionConfig {
   profiles: Record<string, FusionProfile>;
 }
 
+export interface ParsedFusionArgs {
+  prompt: string;
+  profile?: string;
+}
+
 export interface PanelOutput {
   index: number;
   agent: string;

package/src/utils.ts

@@ -0,0 +1,19 @@
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export function isNonEmptyString(value: unknown): value is string {
+  return typeof value === "string" && value.trim().length > 0;
+}
+
+export function isPositiveInteger(value: unknown): value is number {
+  return typeof value === "number" && Number.isInteger(value) && value > 0;
+}
+
+export function isFiniteNumber(value: unknown): value is number {
+  return typeof value === "number" && Number.isFinite(value);
+}
+
+export function isNodeErrorCode(error: unknown, code: string): boolean {
+  return isRecord(error) && error.code === code;
+}