feat(FN-2727): add node routing controls to CLI and dashboard

- Add CLI support for task node routing with create --node, task set-node, and task clear-node commands - Extend settings command validation/output for defaultNodeId and unavailableNodePolicy and document new keys - Surface task routing details in CLI task show plus dashboard Routing tab status/binding reason indicators - Enhance Settings modal node routing UX with selected-node health status and add/refresh tests and changeset
2026-04-28 14:14:18 -07:00
parent b17889f123
commit 58510e179f
14 changed files with 511 additions and 20 deletions
--- a/.changeset/cli-node-routing.md
+++ b/.changeset/cli-node-routing.md
@@ -0,0 +1,5 @@
+---
+"@runfusion/fusion": minor
+---
+
+Add CLI support for multi-node routing: configure project default node (`fn settings set defaultNodeId`), unavailable-node policy (`fn settings set unavailableNodePolicy`), per-task node overrides (`fn task set-node`, `fn task clear-node`), and `--node` flag for `fn task create`.
--- a/docs/settings-reference.md
+++ b/docs/settings-reference.md
@@ -91,7 +91,13 @@ Defaults from `DEFAULT_PROJECT_SETTINGS`; key scope from `PROJECT_SETTINGS_KEYS`
 | `maxWorktrees` | `number` | `4` | Max git worktrees. |
 | `pollIntervalMs` | `number` | `15000` | Scheduler poll interval (ms). |
 | `heartbeatMultiplier` | `number` | `1` | Global multiplier applied to all agent heartbeat intervals. Configured from the Agents screen (not Settings). |
+| `defaultNodeId` | `string` | `undefined` | Optional project default node ID. When set, tasks without a per-task `nodeId` override are routed to this node. |
 | `unavailableNodePolicy` | `"block" \| "fallback-local"` | `"block"` | Routing policy when a selected node is unavailable/unhealthy. `"block"` stops execution until the node is healthy; `"fallback-local"` runs the task on the local node instead. Applies to both project-default node routing and per-task node overrides. |
+
+CLI usage:
+- `fn settings set defaultNodeId <node-id>`
+- `fn settings set unavailableNodePolicy <block|fallback-local>`
+
 | `groupOverlappingFiles` | `boolean` | `true` | Serialize execution when file scopes overlap. |
 | `overlapIgnorePaths` | `string[]` | `[]` | Optional project-relative file or directory paths to exclude from overlap blocking (for example `docs` or `generated/openapi.json`). Entries are trimmed, deduplicated, and must not be absolute or contain `..` traversal. |
 | `autoMerge` | `boolean` | `true` | Auto-finalize tasks from `in-review`. |
--- a/packages/cli/src/tests/bin.test.ts
+++ b/packages/cli/src/tests/bin.test.ts
@@ -32,6 +32,8 @@ const commandMocks = vi.hoisted(() => ({
  runTaskComment: vi.fn(),
  runTaskComments: vi.fn(),
  runTaskSteer: vi.fn(),
+  runTaskSetNode: vi.fn(),
+  runTaskClearNode: vi.fn(),
  runTaskPrCreate: vi.fn(),

  runSettingsShow: vi.fn(),
@@ -122,6 +124,8 @@ vi.mock("../commands/task.js", () => ({
  runTaskComment: commandMocks.runTaskComment,
  runTaskComments: commandMocks.runTaskComments,
  runTaskSteer: commandMocks.runTaskSteer,
+  runTaskSetNode: commandMocks.runTaskSetNode,
+  runTaskClearNode: commandMocks.runTaskClearNode,
  runTaskPrCreate: commandMocks.runTaskPrCreate,
 }));

--- a/packages/cli/src/bin.ts
+++ b/packages/cli/src/bin.ts
@@ -117,7 +117,7 @@ async function loadCommandHandlers() {
  const { runServe } = await import("./commands/serve.js");
  const { runDaemon } = await import("./commands/daemon.js");
  const { runDesktop } = await import("./commands/desktop.js");
-  const { runTaskCreate, runTaskList, runTaskMove, runTaskMerge, runTaskUpdate, runTaskLog, runTaskLogs, runTaskShow, runTaskAttach, runTaskPause, runTaskUnpause, runTaskImportFromGitHub, runTaskDuplicate, runTaskArchive, runTaskUnarchive, runTaskRefine, runTaskPlan, runTaskDelete, runTaskRetry, runTaskComment, runTaskComments, runTaskSteer, runTaskPrCreate } = await import("./commands/task.js");
+  const { runTaskCreate, runTaskList, runTaskMove, runTaskMerge, runTaskUpdate, runTaskLog, runTaskLogs, runTaskShow, runTaskAttach, runTaskPause, runTaskUnpause, runTaskImportFromGitHub, runTaskDuplicate, runTaskArchive, runTaskUnarchive, runTaskRefine, runTaskPlan, runTaskDelete, runTaskRetry, runTaskComment, runTaskComments, runTaskSteer, runTaskSetNode, runTaskClearNode, runTaskPrCreate } = await import("./commands/task.js");
  const { runSettingsShow, runSettingsSet } = await import("./commands/settings.js");
  const { runSettingsExport } = await import("./commands/settings-export.js");
  const { runSettingsImport } = await import("./commands/settings-import.js");
@@ -162,6 +162,8 @@ async function loadCommandHandlers() {
    runTaskComment,
    runTaskComments,
    runTaskSteer,
+    runTaskSetNode,
+    runTaskClearNode,
    runTaskPrCreate,
    runSettingsShow,
    runSettingsSet,
@@ -233,7 +235,7 @@ Usage:
  fn desktop                          Launch the Fusion desktop app (Electron)
  fn desktop --dev                    Launch with hot-reload (connects to Vite dev server)
  fn desktop --paused                 Launch with automation paused
-  fn task create [desc] [opts]         Create a new task (goes to triage)
+  fn task create [desc] [opts]         Create a new task (goes to triage; supports --node <name>)
  fn task plan [description] [opts]    Create task via AI-guided planning
  fn task list                        List all tasks
  fn task show <id>                   Show task details, steps, log
@@ -254,6 +256,8 @@ Usage:
  fn task comment <id> [message]      Add task comment (prompts if message omitted)
  fn task comments <id>               List task comments
  fn task steer <id> [message]        Add steering comment (prompts if message omitted)
+  fn task set-node <id> <node-name-or-id>  Set a per-task node override
+  fn task clear-node <id>                Clear a per-task node override
  fn task retry <id>                  Retry a failed task (clears error, moves to todo)
  fn task pr-create <id> [--title <title>] [--base <branch>] [--body <body>]
                         Create a GitHub PR for an in-review task
@@ -281,6 +285,8 @@ Usage:
  fn mesh status [--json]              Show full mesh state
  fn settings                          Show current Fusion configuration
  fn settings set <key> <value>        Update a configuration setting
+  fn settings set defaultNodeId <node-id>
+  fn settings set unavailableNodePolicy <block|fallback-local>
  fn settings export [opts]              Export settings to a JSON file
  fn settings import <file> [opts]       Import settings from a JSON file

@@ -435,6 +441,8 @@ async function main() {
    runTaskComment,
    runTaskComments,
    runTaskSteer,
+    runTaskSetNode,
+    runTaskClearNode,
    runTaskPrCreate,
    runSettingsShow,
    runSettingsSet,
@@ -708,6 +716,7 @@ async function main() {
            const createArgs = args.slice(2);
            const attachFiles: string[] = [];
            const dependsIds: string[] = [];
+            let nodeName: string | undefined;
            const descParts: string[] = [];
            for (let i = 0; i < createArgs.length; i++) {
              if (createArgs[i] === "--attach" && i + 1 < createArgs.length) {
@@ -716,12 +725,15 @@ async function main() {
              } else if (createArgs[i] === "--depends" && i + 1 < createArgs.length) {
                dependsIds.push(createArgs[i + 1]);
                i++; // skip the value
+              } else if (createArgs[i] === "--node" && i + 1 < createArgs.length) {
+                nodeName = createArgs[i + 1];
+                i++; // skip the value
              } else {
                descParts.push(createArgs[i]);
              }
            }
            const title = descParts.join(" ");
-            await runTaskCreate(title || undefined, attachFiles.length > 0 ? attachFiles : undefined, dependsIds.length > 0 ? dependsIds : undefined, projectName);
+            await runTaskCreate(title || undefined, attachFiles.length > 0 ? attachFiles : undefined, dependsIds.length > 0 ? dependsIds : undefined, projectName, nodeName);
            break;
          }
          case "plan": {
@@ -889,6 +901,25 @@ async function main() {
            await runTaskSteer(id, message || undefined, projectName);
            break;
          }
+          case "set-node": {
+            const id = args[2];
+            const nodeName = args[3];
+            if (!id || !nodeName) {
+              console.error("Usage: fn task set-node <id> <node-name-or-id>");
+              process.exit(1);
+            }
+            await runTaskSetNode(id, nodeName, projectName);
+            break;
+          }
+          case "clear-node": {
+            const id = args[2];
+            if (!id) {
+              console.error("Usage: fn task clear-node <id>");
+              process.exit(1);
+            }
+            await runTaskClearNode(id, projectName);
+            break;
+          }
          case "retry": {
            const id = args[2];
            if (!id) {
@@ -971,7 +1002,7 @@ async function main() {
          }
          default:
            console.error(`Unknown subcommand: task ${subcommand || ""}`);
-            console.log("Try: fn task create | list | move");
+            console.log("Try: fn task create | list | move | set-node | clear-node");
            process.exit(1);
        }
        break;
--- a/packages/cli/src/commands/tests/settings.test.ts
+++ b/packages/cli/src/commands/tests/settings.test.ts
@@ -13,6 +13,8 @@ vi.mock("@fusion/core", () => {
    githubTokenConfigured: false,
    defaultProvider: undefined,
    defaultModelId: undefined,
+    defaultNodeId: undefined,
+    unavailableNodePolicy: undefined,
  };

  return {
@@ -55,9 +57,15 @@ describe("settings commands", () => {

  it("exposes expected valid settings and parser behavior", () => {
    expect(VALID_SETTINGS).toContain("maxConcurrent");
+    expect(VALID_SETTINGS).toContain("defaultNodeId");
+    expect(VALID_SETTINGS).toContain("unavailableNodePolicy");
    expect(parseValue("ntfyEnabled", "yes")).toBe(true);
    expect(parseValue("maxConcurrent", "4")).toBe(4);
    expect(parseValue("worktreeNaming", "task-id")).toBe("task-id");
+    expect(parseValue("defaultNodeId", "node-abc-123")).toBe("node-abc-123");
+    expect(parseValue("unavailableNodePolicy", "block")).toBe("block");
+    expect(parseValue("unavailableNodePolicy", "fallback-local")).toBe("fallback-local");
+    expect(() => parseValue("unavailableNodePolicy", "invalid")).toThrow(/block, fallback-local/);
  });

  it("runSettingsShow without project uses global settings even if a project could resolve", async () => {
@@ -172,6 +180,24 @@ describe("settings commands", () => {
    expect(updateSettings).toHaveBeenCalledWith({ maxParallelSteps: 3 });
  });

+  it("runSettingsSet updates defaultNodeId and unavailableNodePolicy", async () => {
+    const updateSettings = vi.fn().mockResolvedValue(makeSettings({ defaultNodeId: "my-node", unavailableNodePolicy: "fallback-local" }));
+    const getSettings = vi.fn().mockResolvedValue(makeSettings({ defaultNodeId: "my-node", unavailableNodePolicy: "fallback-local" }));
+    vi.mocked(resolveProject).mockResolvedValue({
+      projectId: "proj-1",
+      projectName: "demo-project",
+      projectPath: "/projects/demo",
+      isRegistered: true,
+      store: { updateSettings, getSettings } as any,
+    });
+
+    await runSettingsSet("defaultNodeId", "my-node", "demo-project");
+    await runSettingsSet("unavailableNodePolicy", "fallback-local", "demo-project");
+
+    expect(updateSettings).toHaveBeenNthCalledWith(1, { defaultNodeId: "my-node" });
+    expect(updateSettings).toHaveBeenNthCalledWith(2, { unavailableNodePolicy: "fallback-local" });
+  });
+
  it("rejects maxParallelSteps values outside range", async () => {
    vi.mocked(resolveProject).mockResolvedValue({
      projectId: "proj-1",
@@ -205,4 +231,25 @@ describe("settings commands", () => {
    expect(output).toContain("Run Steps In New Sessions");
    expect(output).toContain("Max Parallel Steps");
  });
+
+  it("runSettingsShow includes Node Routing section", async () => {
+    const getSettings = vi.fn().mockResolvedValue(makeSettings({
+      defaultNodeId: "node-abc",
+      unavailableNodePolicy: "block",
+    }));
+    vi.mocked(resolveProject).mockResolvedValue({
+      projectId: "proj-1",
+      projectName: "demo-project",
+      projectPath: "/projects/demo",
+      isRegistered: true,
+      store: { getSettings } as any,
+    });
+
+    await runSettingsShow("demo-project");
+
+    const output = logSpy.mock.calls.map((args) => args.join(" ")).join("\n");
+    expect(output).toContain("Node Routing");
+    expect(output).toContain("Default Node Id");
+    expect(output).toContain("Unavailable Node Policy");
+  });
 });
--- a/packages/cli/src/commands/tests/task.test.ts
+++ b/packages/cli/src/commands/tests/task.test.ts
@@ -37,6 +37,8 @@ vi.mock("@fusion/core", () => {
        getProject: vi.fn().mockResolvedValue(undefined),
        getProjectByPath: vi.fn().mockResolvedValue(undefined),
        registerProject: vi.fn().mockResolvedValue({ id: "proj_test", name: "test", path: "/test" }),
+        getNode: vi.fn().mockResolvedValue(undefined),
+        getNodeByName: vi.fn().mockResolvedValue(undefined),
      };
    }),
  };
@@ -79,9 +81,9 @@ vi.mock("../../project-context.js", () => ({
 }));

 import { createInterface } from "node:readline/promises";
-import { TaskStore } from "@fusion/core";
+import { TaskStore, CentralCore } from "@fusion/core";
 import { watchFile, unwatchFile, statSync, existsSync, readFileSync } from "node:fs";
-import { runTaskShow, runTaskCreate, runTaskList, runTaskDuplicate, runTaskRefine, runTaskDelete, runTaskRetry, runTaskLogs, runTaskComment, runTaskComments, runTaskPrCreate, runTaskPlan, runTaskMove, runTaskAttach, runTaskPause, runTaskUnpause, runTaskArchive, runTaskUnarchive, runTaskSteer, runTaskImportFromGitHub, runTaskImportGitHubInteractive, runTaskUpdate, runTaskLog, runTaskMerge, type LogsOptions } from "../task.js";
+import { runTaskShow, runTaskCreate, runTaskList, runTaskDuplicate, runTaskRefine, runTaskDelete, runTaskRetry, runTaskLogs, runTaskComment, runTaskComments, runTaskPrCreate, runTaskPlan, runTaskMove, runTaskAttach, runTaskPause, runTaskUnpause, runTaskArchive, runTaskUnarchive, runTaskSteer, runTaskSetNode, runTaskClearNode, runTaskImportFromGitHub, runTaskImportGitHubInteractive, runTaskUpdate, runTaskLog, runTaskMerge, type LogsOptions } from "../task.js";
 import {
  getCurrentRepo,
  isGhAuthenticated,
@@ -162,6 +164,151 @@ describe("runTaskShow", () => {
  });
 });

+describe("task node overrides", () => {
+  let errorSpy: ReturnType<typeof vi.spyOn>;
+  let exitSpy: ReturnType<typeof vi.spyOn>;
+  let logSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+    logSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+    exitSpy = vi.spyOn(process, "exit").mockImplementation((code?: string | number | null) => {
+      throw new Error(`process.exit:${code ?? 0}`);
+    });
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("runTaskSetNode resolves node name and updates task", async () => {
+    const updateTask = vi.fn().mockResolvedValue(makeTask({ nodeId: "node-123" }));
+    (TaskStore as unknown as ReturnType<typeof vi.fn>).mockImplementation(() => ({
+      init: vi.fn(),
+      getTask: vi.fn().mockResolvedValue(makeTask({ column: "todo" })),
+      updateTask,
+    }));
+
+    const getNodeByName = vi.fn().mockResolvedValue({ id: "node-123", name: "my-remote" });
+    const getNode = vi.fn().mockResolvedValue(undefined);
+    (CentralCore as unknown as ReturnType<typeof vi.fn>).mockImplementation(() => ({
+      init: vi.fn().mockResolvedValue(undefined),
+      close: vi.fn().mockResolvedValue(undefined),
+      getNode,
+      getNodeByName,
+    }));
+
+    await runTaskSetNode("FN-001", "my-remote");
+    expect(updateTask).toHaveBeenCalledWith("FN-001", { nodeId: "node-123" });
+  });
+
+  it("runTaskSetNode accepts raw node id", async () => {
+    const updateTask = vi.fn().mockResolvedValue(makeTask({ nodeId: "12345678-1234-1234-1234-123456789012" }));
+    (TaskStore as unknown as ReturnType<typeof vi.fn>).mockImplementation(() => ({
+      init: vi.fn(),
+      getTask: vi.fn().mockResolvedValue(makeTask({ column: "todo" })),
+      updateTask,
+    }));
+
+    const getNode = vi.fn().mockResolvedValue({ id: "12345678-1234-1234-1234-123456789012", name: "raw" });
+    (CentralCore as unknown as ReturnType<typeof vi.fn>).mockImplementation(() => ({
+      init: vi.fn().mockResolvedValue(undefined),
+      close: vi.fn().mockResolvedValue(undefined),
+      getNode,
+      getNodeByName: vi.fn().mockResolvedValue(undefined),
+    }));
+
+    await runTaskSetNode("FN-001", "12345678-1234-1234-1234-123456789012");
+    expect(updateTask).toHaveBeenCalledWith("FN-001", { nodeId: "12345678-1234-1234-1234-123456789012" });
+  });
+
+  it("runTaskSetNode blocks in-progress tasks", async () => {
+    (TaskStore as unknown as ReturnType<typeof vi.fn>).mockImplementation(() => ({
+      init: vi.fn(),
+      getTask: vi.fn().mockResolvedValue(makeTask({ column: "in-progress" })),
+    }));
+
+    await expect(runTaskSetNode("FN-001", "my-remote")).rejects.toThrow("process.exit:1");
+    expect(errorSpy).toHaveBeenCalledWith("Cannot change node override: task FN-001 is in progress");
+  });
+
+  it("runTaskSetNode errors when node is unknown", async () => {
+    (TaskStore as unknown as ReturnType<typeof vi.fn>).mockImplementation(() => ({
+      init: vi.fn(),
+      getTask: vi.fn().mockResolvedValue(makeTask({ column: "todo" })),
+      updateTask: vi.fn(),
+    }));
+
+    (CentralCore as unknown as ReturnType<typeof vi.fn>).mockImplementation(() => ({
+      init: vi.fn().mockResolvedValue(undefined),
+      close: vi.fn().mockResolvedValue(undefined),
+      getNode: vi.fn().mockResolvedValue(undefined),
+      getNodeByName: vi.fn().mockResolvedValue(undefined),
+    }));
+
+    await expect(runTaskSetNode("FN-001", "missing-node")).rejects.toThrow("process.exit:1");
+  });
+
+  it("runTaskClearNode clears override", async () => {
+    const updateTask = vi.fn().mockResolvedValue(makeTask({ nodeId: undefined }));
+    (TaskStore as unknown as ReturnType<typeof vi.fn>).mockImplementation(() => ({
+      init: vi.fn(),
+      getTask: vi.fn().mockResolvedValue(makeTask({ column: "todo", nodeId: "node-123" })),
+      updateTask,
+    }));
+
+    await runTaskClearNode("FN-001");
+    expect(updateTask).toHaveBeenCalledWith("FN-001", { nodeId: null });
+  });
+
+  it("runTaskClearNode blocks in-progress tasks", async () => {
+    (TaskStore as unknown as ReturnType<typeof vi.fn>).mockImplementation(() => ({
+      init: vi.fn(),
+      getTask: vi.fn().mockResolvedValue(makeTask({ column: "in-progress" })),
+    }));
+
+    await expect(runTaskClearNode("FN-001")).rejects.toThrow("process.exit:1");
+    expect(errorSpy).toHaveBeenCalledWith("Cannot change node override: task FN-001 is in progress");
+  });
+
+  it("runTaskShow displays node routing info", async () => {
+    (TaskStore as unknown as ReturnType<typeof vi.fn>).mockImplementation(() => ({
+      init: vi.fn(),
+      getTask: vi.fn().mockResolvedValue(makeTask({ nodeId: "node-123", column: "todo" })),
+      getSettings: vi.fn().mockResolvedValue({ unavailableNodePolicy: "block" }),
+    }));
+    (CentralCore as unknown as ReturnType<typeof vi.fn>).mockImplementation(() => ({
+      init: vi.fn().mockResolvedValue(undefined),
+      close: vi.fn().mockResolvedValue(undefined),
+      getNode: vi.fn().mockResolvedValue({ id: "node-123", name: "remote-a" }),
+      getNodeByName: vi.fn().mockResolvedValue(undefined),
+    }));
+
+    await runTaskShow("FN-001");
+    const output = logSpy.mock.calls.map((call) => String(call[0])).join("\n");
+    expect(output).toContain("Node:");
+    expect(output).toContain("Unavailable Node Policy");
+  });
+
+  it("runTaskCreate with node resolves and applies override", async () => {
+    const updateTask = vi.fn().mockResolvedValue(makeTask({ nodeId: "node-123" }));
+    (TaskStore as unknown as ReturnType<typeof vi.fn>).mockImplementation(() => ({
+      init: vi.fn(),
+      createTask: vi.fn().mockResolvedValue(makeTask({ id: "FN-900", column: "triage" })),
+      updateTask,
+    }));
+    (CentralCore as unknown as ReturnType<typeof vi.fn>).mockImplementation(() => ({
+      init: vi.fn().mockResolvedValue(undefined),
+      close: vi.fn().mockResolvedValue(undefined),
+      getNode: vi.fn().mockResolvedValue(undefined),
+      getNodeByName: vi.fn().mockResolvedValue({ id: "node-123", name: "remote-a" }),
+    }));
+
+    await runTaskCreate("new task", undefined, undefined, undefined, "remote-a");
+    expect(updateTask).toHaveBeenCalledWith("FN-900", { nodeId: "node-123" });
+  });
+});
+
 // Mock fs/promises for runTaskCreate attach tests
 vi.mock("node:fs/promises", () => ({
  readFile: vi.fn(),
--- a/packages/cli/src/commands/settings.ts
+++ b/packages/cli/src/commands/settings.ts
@@ -15,6 +15,8 @@ export const VALID_SETTINGS = [
  "defaultModel",
  "runStepsInNewSessions",
  "maxParallelSteps",
+  "defaultNodeId",
+  "unavailableNodePolicy",
 ] as const;

 const GLOBAL_ONLY_SETTINGS = ["ntfyEnabled", "ntfyTopic", "defaultModel"] as const;
@@ -28,6 +30,8 @@ const PROJECT_ONLY_SETTINGS = [
  "requirePlanApproval",
  "runStepsInNewSessions",
  "maxParallelSteps",
+  "defaultNodeId",
+  "unavailableNodePolicy",
 ] as const;

 type ValidSettingKey = (typeof VALID_SETTINGS)[number];
@@ -45,9 +49,10 @@ const NUMBER_SETTINGS: readonly string[] = ["maxConcurrent", "maxWorktrees", "ma

 const ENUM_SETTINGS: Record<string, readonly string[]> = {
  worktreeNaming: ["random", "task-id", "task-title"],
+  unavailableNodePolicy: ["block", "fallback-local"],
 };

-const STRING_SETTINGS: readonly string[] = ["taskPrefix", "ntfyTopic", "defaultModel"];
+const STRING_SETTINGS: readonly string[] = ["taskPrefix", "ntfyTopic", "defaultModel", "defaultNodeId"];

 // Validation ranges for numeric settings
 const NUMBER_RANGES: Record<string, { min: number; max: number }> = {
@@ -203,6 +208,10 @@ export async function runSettingsShow(projectName?: string): Promise<void> {
      title: "Tasks",
      keys: ["taskPrefix", "requirePlanApproval", "includeTaskIdInCommit"],
    },
+    {
+      title: "Node Routing",
+      keys: ["defaultNodeId", "unavailableNodePolicy"],
+    },
    {
      title: "Notifications",
      keys: ["ntfyEnabled", "ntfyTopic"],
--- a/packages/cli/src/commands/task.ts
+++ b/packages/cli/src/commands/task.ts
@@ -1,4 +1,4 @@
-import { TaskStore, COLUMNS, COLUMN_LABELS, type Column, type StepStatus, type AgentLogType, type AgentLogEntry } from "@fusion/core";
+import { TaskStore, COLUMNS, COLUMN_LABELS, CentralCore, type Settings, type Column, type StepStatus, type AgentLogType, type AgentLogEntry } from "@fusion/core";
 import { aiMergeTask } from "@fusion/engine";
 import { createInterface } from "node:readline/promises";
 import type { PlanningQuestion, PlanningSummary } from "@fusion/core";
@@ -14,6 +14,7 @@ import {
  runGhJsonAsync,
 } from "@fusion/core/gh-cli";
 import { resolveProject, type ProjectContext } from "../project-context.js";
+import { findNodeByNameOrId } from "./node.js";

 const STEP_STATUSES: StepStatus[] = ["pending", "in-progress", "done", "skipped"];

@@ -93,7 +94,31 @@ async function getProjectPath(projectName?: string): Promise<string> {
  return (await getCommandContext(projectName)).projectPath;
 }

-export async function runTaskCreate(descriptionArg?: string, attachFiles?: string[], depends?: string[], projectName?: string) {
+async function resolveNodeByNameOrId(nodeNameOrId: string): Promise<{ id: string; name?: string }> {
+  const central = new CentralCore();
+  await central.init();
+
+  try {
+    const looksLikeNodeId = nodeNameOrId.includes("-") && nodeNameOrId.length > 20;
+    let node = looksLikeNodeId
+      ? await central.getNode(nodeNameOrId)
+      : await central.getNodeByName(nodeNameOrId);
+
+    if (!node) {
+      node = await findNodeByNameOrId(central, nodeNameOrId);
+    }
+
+    if (!node) {
+      throw new Error(`Node not found: ${nodeNameOrId}`);
+    }
+
+    return { id: node.id, name: node.name };
+  } finally {
+    await central.close();
+  }
+}
+
+export async function runTaskCreate(descriptionArg?: string, attachFiles?: string[], depends?: string[], projectName?: string, nodeName?: string) {
  let description = descriptionArg;
  const projectContext = await getProjectContext(projectName);

@@ -111,6 +136,17 @@ export async function runTaskCreate(descriptionArg?: string, attachFiles?: strin
  const store = projectContext?.store ?? await getStore(projectName);
  const task = await store.createTask({ description: description.trim(), dependencies: depends });

+  let resolvedNode: { id: string; name?: string } | undefined;
+  if (nodeName) {
+    try {
+      resolvedNode = await resolveNodeByNameOrId(nodeName);
+      await store.updateTask(task.id, { nodeId: resolvedNode.id });
+    } catch (error) {
+      console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+      process.exit(1);
+    }
+  }
+
  const label = task.description.length > 60
    ? task.description.slice(0, 60) + "…"
    : task.description;
@@ -124,6 +160,9 @@ export async function runTaskCreate(descriptionArg?: string, attachFiles?: strin
  if (task.dependencies.length > 0) {
    console.log(`    Dependencies: ${task.dependencies.join(", ")}`);
  }
+  if (resolvedNode) {
+    console.log(`    Node: ${resolvedNode.name || resolvedNode.id}`);
+  }
  console.log(`    Path:   .fusion/tasks/${task.id}/`);

  if (attachFiles && attachFiles.length > 0) {
@@ -411,9 +450,60 @@ export async function runTaskLogs(id: string, options: LogsOptions = {}, project
  }
 }

+export async function runTaskSetNode(id: string, nodeNameOrId: string, projectName?: string) {
+  const store = await getStore(projectName);
+  const task = await store.getTask(id);
+
+  if (task.column === "in-progress") {
+    console.error(`Cannot change node override: task ${id} is in progress`);
+    process.exit(1);
+  }
+
+  let resolvedNode: { id: string; name?: string };
+  try {
+    resolvedNode = await resolveNodeByNameOrId(nodeNameOrId);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+    return;
+  }
+
+  await store.updateTask(id, { nodeId: resolvedNode.id });
+  console.log(`✓ Set node override for ${id}: ${resolvedNode.name || resolvedNode.id}`);
+}
+
+export async function runTaskClearNode(id: string, projectName?: string) {
+  const store = await getStore(projectName);
+  const task = await store.getTask(id);
+
+  if (task.column === "in-progress") {
+    console.error(`Cannot change node override: task ${id} is in progress`);
+    process.exit(1);
+  }
+
+  await store.updateTask(id, { nodeId: null });
+  console.log(`✓ Cleared node override for ${id}`);
+}
+
 export async function runTaskShow(id: string, projectName?: string) {
  const store = await getStore(projectName);
  const task = await store.getTask(id);
+  const settings: Partial<Settings> = "getSettings" in store ? await store.getSettings() : {};
+
+  let nodeSummary = "(default local)";
+  if (task.nodeId) {
+    let nodeName: string | undefined;
+    const central = new CentralCore();
+    await central.init();
+    try {
+      nodeName = (await central.getNode(task.nodeId))?.name;
+    } finally {
+      await central.close();
+    }
+    nodeSummary = nodeName ? `${nodeName} (${task.nodeId})` : task.nodeId;
+  } else if (settings.defaultNodeId) {
+    nodeSummary = `project default: ${settings.defaultNodeId}`;
+  }

  console.log();
  console.log(`  ${task.id}: ${task.title || task.description}`);
@@ -421,6 +511,10 @@ export async function runTaskShow(id: string, projectName?: string) {
  if (task.dependencies.length) {
    console.log(`  Dependencies: ${task.dependencies.join(", ")}`);
  }
+  console.log(`  Node: ${nodeSummary}`);
+  if (settings.unavailableNodePolicy) {
+    console.log(`  Unavailable Node Policy: ${settings.unavailableNodePolicy}`);
+  }
  console.log();

  // Steps
--- a/packages/dashboard/app/components/RoutingTab.css
+++ b/packages/dashboard/app/components/RoutingTab.css
@@ -50,10 +50,13 @@
 }

 .routing-summary-value {
-  display: inline-flex;
+  display: flex;
+  flex-wrap: wrap;
+  min-width: 0;
  align-items: center;
  gap: var(--space-sm);
  color: var(--text);
+  overflow-wrap: anywhere;
 }

 .routing-summary-warning {
@@ -65,6 +68,49 @@
  color: var(--color-warning);
 }

+.routing-node-status {
+  display: inline-flex;
+  align-items: center;
+  gap: var(--space-xs);
+  color: var(--text-muted);
+}
+
+.routing-node-status__dot {
+  width: var(--space-sm);
+  height: var(--space-sm);
+  border-radius: 50%;
+  background: var(--text-dim);
+}
+
+.routing-node-status--online .routing-node-status__dot {
+  background: var(--color-success);
+}
+
+.routing-node-status--offline .routing-node-status__dot,
+.routing-node-status--error .routing-node-status__dot {
+  background: var(--color-error);
+}
+
+.routing-node-status--connecting .routing-node-status__dot {
+  background: var(--color-warning);
+}
+
+.routing-node-status--error {
+  color: var(--color-error);
+}
+
+.routing-node-status--connecting {
+  color: var(--color-warning);
+}
+
+.routing-node-status--online {
+  color: var(--color-success);
+}
+
+.routing-node-status--offline {
+  color: var(--text-muted);
+}
+
 .routing-tab__info-banner,
 .routing-tab__warning-banner,
 .routing-tab__error {
--- a/packages/dashboard/app/components/RoutingTab.tsx
+++ b/packages/dashboard/app/components/RoutingTab.tsx
@@ -13,12 +13,19 @@ interface RoutingTabProps {
  onTaskUpdated?: (task: Task) => void;
 }

-const STATUS_DOT: Record<NodeInfo["status"], string> = {
-  online: "🟢",
-  offline: "🔴",
-  connecting: "🟡",
-  error: "🔴",
-};
+function getNodeStatusLabel(status: NodeInfo["status"]): string {
+  if (status === "online") return "Online";
+  if (status === "connecting") return "Connecting";
+  if (status === "error") return "Error";
+  return "Offline";
+}
+
+function getNodeStatusClass(status: NodeInfo["status"]): string {
+  if (status === "online") return "routing-node-status--online";
+  if (status === "connecting") return "routing-node-status--connecting";
+  if (status === "error") return "routing-node-status--error";
+  return "routing-node-status--offline";
+}

 type RoutingSettings = Settings & {
  defaultNodeId?: string;
@@ -82,10 +89,14 @@ export function RoutingTab({ task, settings, addToast, onTaskUpdated }: RoutingT

  const effectiveNode = effectiveNodeId ? nodesById.get(effectiveNodeId) : undefined;
  const effectiveNodeName = effectiveNode
-    ? `${STATUS_DOT[effectiveNode.status]} ${effectiveNode.name} (${effectiveNode.type})`
+    ? `${effectiveNode.name} (${effectiveNode.type})`
    : effectiveNodeId
      ? `${effectiveNodeId} (node unavailable or unknown)`
      : "Local (no routing configured)";
+  const blockingReason =
+    (task as Task & { blockedReason?: string; statusReason?: string }).blockedReason
+    || (task as Task & { statusReason?: string }).statusReason
+    || "(not blocked)";

  const taskInProgress = task.column === "in-progress";
  const selectorDisabled = taskInProgress || savingNode || loadingNodes;
@@ -137,6 +148,12 @@ export function RoutingTab({ task, settings, addToast, onTaskUpdated }: RoutingT
            <span className="routing-summary-label">Effective node</span>
            <span className="routing-summary-value">
              {effectiveNodeName}
+              {effectiveNode ? (
+                <span className={`routing-node-status ${getNodeStatusClass(effectiveNode.status)}`}>
+                  <span className="routing-node-status__dot" aria-hidden="true" />
+                  {getNodeStatusLabel(effectiveNode.status)}
+                </span>
+              ) : null}
              {isUnhealthy(effectiveNode?.status) ? (
                <span className="routing-summary-warning">Unhealthy</span>
              ) : null}
@@ -150,6 +167,10 @@ export function RoutingTab({ task, settings, addToast, onTaskUpdated }: RoutingT
            <span className="routing-summary-label">Unavailable-node policy</span>
            <span className="routing-summary-value">{getRoutingPolicyLabel(routingSettings?.unavailableNodePolicy)}</span>
          </div>
+          <div className="routing-summary-row" role="listitem">
+            <span className="routing-summary-label">Blocking reason</span>
+            <span className="routing-summary-value">{blockingReason}</span>
+          </div>
        </div>
        {taskInProgress && effectiveNodeId ? (
          <div className="routing-tab__info-banner">
@@ -181,7 +202,7 @@ export function RoutingTab({ task, settings, addToast, onTaskUpdated }: RoutingT
          <option value="">Use project default</option>
          {sortedNodes.map((node) => (
            <option key={node.id} value={node.id}>
-              {STATUS_DOT[node.status]} {node.name} ({node.type})
+              {node.name} ({node.type}) — {getNodeStatusLabel(node.status)}
            </option>
          ))}
        </select>
--- a/packages/dashboard/app/components/SettingsModal.css
+++ b/packages/dashboard/app/components/SettingsModal.css
@@ -1522,3 +1522,32 @@
 .settings-node-status--connecting .settings-node-status__dot {
  background: var(--color-warning);
 }
+
+.settings-node-status {
+  display: inline-flex;
+  align-items: center;
+  gap: var(--space-xs);
+  margin-top: var(--space-sm);
+  font-size: 12px;
+  color: var(--text-muted);
+}
+
+.settings-node-status__dot {
+  width: var(--space-sm);
+  height: var(--space-sm);
+  border-radius: var(--radius-pill);
+  background: var(--color-muted);
+}
+
+.settings-node-status--online .settings-node-status__dot {
+  background: var(--color-success);
+}
+
+.settings-node-status--offline .settings-node-status__dot,
+.settings-node-status--error .settings-node-status__dot {
+  background: var(--color-error);
+}
+
+.settings-node-status--connecting .settings-node-status__dot {
+  background: var(--color-warning);
+}
--- a/packages/dashboard/app/components/SettingsModal.tsx
+++ b/packages/dashboard/app/components/SettingsModal.tsx
@@ -2,8 +2,7 @@ import { useState, useEffect, useCallback, useRef, lazy, Suspense, type MouseEve
 import { Globe, Folder, RefreshCw, Star, HelpCircle, Loader2 } from "lucide-react";
 import { THINKING_LEVELS, isGlobalSettingsKey, isProjectSettingsKey, getErrorMessage } from "@fusion/core";
 import type { Settings, GlobalSettings, ThemeMode, ColorTheme, ModelPreset, NtfyNotificationEvent, AgentPromptsConfig, ThinkingLevel } from "@fusion/core";
-import { fetchSettings, fetchSettingsByScope, updateSettings, updateGlobalSettings, fetchAuthStatus, loginProvider, logoutProvider, saveApiKey, clearApiKey, fetchModels, testNtfyNotification, fetchBackups, createBackup, exportSettings, importSettings, fetchMemoryFile, fetchMemoryFiles, saveMemoryFile, compactMemory, fetchGlobalConcurrency, updateGlobalConcurrency, installQmd, testMemoryRetrieval, triggerMemoryDreams, fetchGitRemotesDetailed, fetchDashboardHealth, checkForUpdates, fetchRemoteSettings, updateRemoteSettings, fetchRemoteStatus, startRemoteTunnel, stopRemoteTunnel, regenerateRemotePersistentToken, generateShortLivedRemoteToken, fetchRemoteQr, fetchRemoteUrl } from "../api";
-import type { AuthProvider, ModelInfo, BackupListResponse, SettingsExportData, MemoryFileInfo, MemoryRetrievalTestResult, GitRemoteDetailed, RemoteSettings, RemoteStatus, UpdateCheckResponse } from "../api";
+import { fetchSettings, fetchSettingsByScope, updateSettings, updateGlobalSettings, fetchAuthStatus, loginProvider, logoutProvider, saveApiKey, clearApiKey, fetchModels, testNtfyNotification, fetchBackups, createBackup, exportSettings, importSettings, fetchMemoryFile, fetchMemoryFiles, saveMemoryFile, compactMemory, fetchGlobalConcurrency, updateGlobalConcurrency, installQmd, testMemoryRetrieval, triggerMemoryDreams, fetchGitRemotesDetailed, fetchDashboardHealth, checkForUpdates, fetchRemoteSettings, updateRemoteSettings, fetchRemoteStatus, startRemoteTunnel, stopRemoteTunnel, regenerateRemotePersistentToken, generateShortLivedRemoteToken, fetchRemoteQr, fetchRemoteUrl } from "../api";import type { AuthProvider, ModelInfo, BackupListResponse, SettingsExportData, MemoryFileInfo, MemoryRetrievalTestResult, GitRemoteDetailed, RemoteSettings, RemoteStatus, UpdateCheckResponse } from "../api";
 import { useMemoryBackendStatus } from "../hooks/useMemoryBackendStatus";
 import { useOverlayDismiss } from "../hooks/useOverlayDismiss";
 import type { ToastType } from "../hooks/useToast";
--- a/packages/dashboard/app/components/tests/RoutingTab.test.tsx
+++ b/packages/dashboard/app/components/tests/RoutingTab.test.tsx
@@ -76,6 +76,7 @@ describe("RoutingTab", () => {

    expect(await screen.findByText("Per-task override")).toBeInTheDocument();
    expect(screen.getByText(/Effective node/i)).toBeInTheDocument();
+    expect(screen.getByText("Online")).toBeInTheDocument();
  });

  it("renders routing summary with project default", async () => {
@@ -96,6 +97,7 @@ describe("RoutingTab", () => {

    expect(await screen.findByText("Local (no routing configured)")).toBeInTheDocument();
    expect(screen.getByText("No routing")).toBeInTheDocument();
+    expect(screen.getByText("(not blocked)")).toBeInTheDocument();
  });

  it.each([
--- a/packages/dashboard/app/components/tests/SettingsModal.test.tsx
+++ b/packages/dashboard/app/components/tests/SettingsModal.test.tsx
@@ -1757,6 +1757,57 @@ describe("SettingsModal", () => {
  });


+  describe("memory dream trigger", () => {
+    const openMemorySection = async () => {
+      const [memorySectionButton] = await screen.findAllByRole("button", { name: /^Memory$/i });
+      await userEvent.click(memorySectionButton);
+    };
+
+    it("shows Dream Now button when dreams are enabled", async () => {
+      mockFetchSettings.mockResolvedValueOnce({
+        ...defaultSettings,
+        memoryEnabled: true,
+        memoryDreamsEnabled: true,
+        memoryDreamsSchedule: "0 4 * * *",
+      });
+
+      renderModal();
+      await waitForSettingsModalReady();
+      await openMemorySection();
+
+      expect(await screen.findByRole("button", { name: "Dream Now" })).toBeInTheDocument();
+    });
+
+    it("triggers dream processing from Dream Now button", async () => {
+      const addToast = vi.fn();
+      mockFetchSettings.mockResolvedValueOnce({
+        ...defaultSettings,
+        memoryEnabled: true,
+        memoryDreamsEnabled: true,
+      });
+      mockTriggerMemoryDreams.mockResolvedValueOnce({ success: true, summary: "done" });
+
+      renderModal({ addToast });
+      await waitForSettingsModalReady();
+      await openMemorySection();
+
+      await userEvent.click(await screen.findByRole("button", { name: "Dream Now" }));
+
+      await waitFor(() => {
+        expect(mockTriggerMemoryDreams).toHaveBeenCalledWith(undefined);
+      });
+      expect(addToast).toHaveBeenCalledWith("Dream processing completed", "success");
+    });
+
+    it("hides Dream Now button when dreams are disabled", async () => {
+      renderModal();
+      await waitForSettingsModalReady();
+      await openMemorySection();
+
+      expect(screen.queryByRole("button", { name: "Dream Now" })).not.toBeInTheDocument();
+    });
+  });
+
  describe("memory dream trigger", () => {
    const openMemorySection = async () => {
      const [memorySectionButton] = await screen.findAllByRole("button", { name: /^Memory$/i });