@runfusion/fusion 0.1.0 → 0.1.1

package/dist/bin.js

@@ -1975,6 +1975,18 @@ function fromJson(json) {
     return void 0;
   }
 }
+function probeFts5(db) {
+  if (process.env.FUSION_DISABLE_FTS5 === "1" || process.env.FUSION_DISABLE_FTS5 === "true") {
+    return false;
+  }
+  try {
+    db.exec("CREATE VIRTUAL TABLE IF NOT EXISTS __fusion_fts5_probe USING fts5(x)");
+    db.exec("DROP TABLE IF EXISTS __fusion_fts5_probe");
+    return true;
+  } catch {
+    return false;
+  }
+}
 function normalizeTaskComments(steeringComments, comments) {
   const normalizedComments = [];
   const seenKeys = /* @__PURE__ */ new Set();
@@ -2495,6 +2507,7 @@ CREATE INDEX IF NOT EXISTS idxInsightRunsProjectId
       dbPath;
       /** Tracks transaction nesting depth for savepoint-based nested transactions. */
       transactionDepth = 0;
+      _fts5Available;
       constructor(kbDir) {
         this.dbPath = join(kbDir, "fusion.db");
         if (!isAbsolute(kbDir)) {
@@ -2507,6 +2520,16 @@ CREATE INDEX IF NOT EXISTS idxInsightRunsProjectId
         this.db.exec("PRAGMA journal_mode = WAL");
         this.db.exec("PRAGMA busy_timeout = 5000");
         this.db.exec("PRAGMA foreign_keys = ON");
+        this._fts5Available = probeFts5(this.db);
+      }
+      /**
+       * True when the underlying SQLite build has FTS5 (`CREATE VIRTUAL TABLE … USING fts5`).
+       * Node's bundled SQLite only exposes FTS5 when built with `SQLITE_ENABLE_FTS5`;
+       * older Node 22.x LTS builds do not. Consumers must fall back to LIKE-based scans
+       * when this is false. Override with `FUSION_DISABLE_FTS5=1` to force the fallback path.
+       */
+      get fts5Available() {
+        return this._fts5Available;
       }
       /**
        * Initialize the database: create tables if they don't exist
@@ -2816,6 +2839,9 @@ CREATE INDEX IF NOT EXISTS idxInsightRunsProjectId
         }
         if (version < 21) {
           this.applyMigration(21, () => {
+            if (!this._fts5Available) {
+              return;
+            }
             this.db.exec(`
           CREATE VIRTUAL TABLE IF NOT EXISTS tasks_fts USING fts5(
             id,
@@ -3225,6 +3251,9 @@ CREATE INDEX IF NOT EXISTS idxInsightRunsProjectId
         }
         if (version < 35) {
           this.applyMigration(35, () => {
+            if (!this._fts5Available) {
+              return;
+            }
             const hasTaskTitle = this.hasColumn("tasks", "title");
             const updateColumns = hasTaskTitle ? "id, title, description, comments" : "id, description, comments";
             const oldTitle = hasTaskTitle ? "COALESCE(old.title, '')" : "''";
@@ -3518,6 +3547,9 @@ function resolveCreationRuntimeConfig(incoming, metadata) {
     return incoming;
   }
   const rc = { ...incoming ?? {} };
+  if (typeof rc.enabled !== "boolean") {
+    rc.enabled = true;
+  }
   if (typeof rc.heartbeatIntervalMs !== "number" || !Number.isFinite(rc.heartbeatIntervalMs)) {
     rc.heartbeatIntervalMs = DEFAULT_AGENT_HEARTBEAT_INTERVAL_MS;
   }
@@ -3563,6 +3595,7 @@ var init_agent_store = __esm({
         const _2 = this.db;
         await mkdir(this.agentsDir, { recursive: true });
         await this.importLegacyFileDataOnce();
+        await this.normalizeHeartbeatDefaultsOnce();
       }
       /**
        * One-way migration helper for projects that still have legacy agent JSON
@@ -3667,6 +3700,51 @@ var init_agent_store = __esm({
     `).run(migrationKey, migrationVersion);
         this.db.bumpLastModified();
       }
+      /**
+       * One-time normalization for durable agents created before the heartbeat
+       * toggle was exposed in the UI. Those agents could persist
+       * `runtimeConfig.enabled = false` even though users had no supported way to
+       * manage that flag, which caused timers to stay disabled after restart.
+       *
+       * We normalize only once per project. After this migration lands, explicit
+       * user choices are preserved because the version gate prevents reruns.
+       */
+      async normalizeHeartbeatDefaultsOnce() {
+        const migrationKey = "agentHeartbeatDefaultVersion";
+        const migrationVersion = "1";
+        const row = this.db.prepare("SELECT value FROM __meta WHERE key = ?").get(migrationKey);
+        if (row?.value === migrationVersion) {
+          return;
+        }
+        const agents = await this.listAgents({ includeEphemeral: true });
+        let changed = 0;
+        for (const agent of agents) {
+          if (isEphemeralAgent(agent)) {
+            continue;
+          }
+          const nextRuntimeConfig = {
+            ...resolveCreationRuntimeConfig(agent.runtimeConfig, agent.metadata) ?? {},
+            enabled: true
+          };
+          const currentRuntimeConfig = agent.runtimeConfig ?? void 0;
+          if (JSON.stringify(nextRuntimeConfig) === JSON.stringify(currentRuntimeConfig)) {
+            continue;
+          }
+          await this.writeAgent({
+            ...agent,
+            runtimeConfig: nextRuntimeConfig
+          });
+          changed++;
+        }
+        this.db.prepare(`
+      INSERT INTO __meta (key, value)
+      VALUES (?, ?)
+      ON CONFLICT(key) DO UPDATE SET value = excluded.value
+    `).run(migrationKey, migrationVersion);
+        if (changed > 0) {
+          this.db.bumpLastModified();
+        }
+      }
       /**
        * Create a new agent with "idle" state.
        *
@@ -5776,11 +5854,12 @@ var init_global_settings = __esm({
 import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
 import { existsSync as existsSync4, mkdirSync as mkdirSync3 } from "node:fs";
 import { join as join5 } from "node:path";
-var ARCHIVE_SCHEMA_SQL, ArchiveDatabase;
+var BASE_SCHEMA_SQL, FTS5_SCHEMA_SQL, ArchiveDatabase;
 var init_archive_db = __esm({
   "../core/src/archive-db.ts"() {
     "use strict";
-    ARCHIVE_SCHEMA_SQL = `
+    init_db();
+    BASE_SCHEMA_SQL = `
 CREATE TABLE IF NOT EXISTS archived_tasks (
   id TEXT PRIMARY KEY,
   taskJson TEXT NOT NULL,
@@ -5796,7 +5875,8 @@ CREATE TABLE IF NOT EXISTS archived_tasks (
 
 CREATE INDEX IF NOT EXISTS idxArchivedTasksArchivedAt ON archived_tasks(archivedAt);
 CREATE INDEX IF NOT EXISTS idxArchivedTasksCreatedAt ON archived_tasks(createdAt);
-
+`;
+    FTS5_SCHEMA_SQL = `
 CREATE VIRTUAL TABLE IF NOT EXISTS archived_tasks_fts USING fts5(
   id,
   title,
@@ -5824,18 +5904,26 @@ CREATE TRIGGER IF NOT EXISTS archived_tasks_fts_ad AFTER DELETE ON archived_task
 END;
 `;
     ArchiveDatabase = class {
+      db;
+      _fts5Available;
       constructor(kbDir) {
-        this.kbDir = kbDir;
         if (!existsSync4(kbDir)) {
           mkdirSync3(kbDir, { recursive: true });
         }
         this.db = new DatabaseSync2(join5(kbDir, "archive.db"));
         this.db.exec("PRAGMA journal_mode = WAL");
         this.db.exec("PRAGMA busy_timeout = 5000");
+        this._fts5Available = probeFts5(this.db);
+      }
+      /** True when this SQLite build has FTS5. See db.ts#probeFts5. */
+      get fts5Available() {
+        return this._fts5Available;
       }
-      db;
       init() {
-        this.db.exec(ARCHIVE_SCHEMA_SQL);
+        this.db.exec(BASE_SCHEMA_SQL);
+        if (this._fts5Available) {
+          this.db.exec(FTS5_SCHEMA_SQL);
+        }
         this.addColumnIfMissing("archived_tasks", "prompt", "TEXT");
       }
       upsert(entry) {
@@ -5876,15 +5964,48 @@ END;
       delete(id) {
         this.db.prepare("DELETE FROM archived_tasks WHERE id = ?").run(id);
       }
+      /**
+       * Full-text search over archived tasks. Accepts a raw user query and routes
+       * through FTS5 when available, or a LIKE-based scan when not.
+       */
       search(query, limit) {
+        const trimmed = query?.trim();
+        if (!trimmed) return [];
+        const tokens = trimmed.split(/\s+/).filter((t) => t.length > 0).map((t) => t.replace(/["{}:*^+()]/g, "")).filter((t) => t.length > 0);
+        if (tokens.length === 0) return [];
+        if (this._fts5Available) {
+          const ftsQuery = tokens.map((token) => {
+            if (/[":(){}*^+-]/.test(token)) {
+              return `"${token.replace(/"/g, '\\"')}"`;
+            }
+            return token;
+          }).join(" OR ");
+          const rows2 = this.db.prepare(`
+        SELECT a.taskJson
+        FROM archived_tasks a
+        JOIN archived_tasks_fts fts ON a.rowid = fts.rowid
+        WHERE archived_tasks_fts MATCH ?
+        ORDER BY rank
+        LIMIT ?
+      `).all(ftsQuery, limit);
+          return rows2.map((row) => JSON.parse(row.taskJson));
+        }
+        const searchColumns = ["id", "title", "description", "comments"];
+        const perTokenClause = `(${searchColumns.map((c) => `"${c}" LIKE ? ESCAPE '\\'`).join(" OR ")})`;
+        const whereTokens = tokens.map(() => perTokenClause).join(" OR ");
+        const params = [];
+        for (const token of tokens) {
+          const pattern = `%${token.replace(/[\\%_]/g, "\\$&")}%`;
+          for (let i = 0; i < searchColumns.length; i++) params.push(pattern);
+        }
+        params.push(limit);
         const rows = this.db.prepare(`
-      SELECT a.taskJson
-      FROM archived_tasks a
-      JOIN archived_tasks_fts fts ON a.rowid = fts.rowid
-      WHERE archived_tasks_fts MATCH ?
-      ORDER BY rank
+      SELECT taskJson
+      FROM archived_tasks
+      WHERE ${whereTokens}
+      ORDER BY archivedAt DESC
       LIMIT ?
-    `).all(query, limit);
+    `).all(...params);
         return rows.map((row) => JSON.parse(row.taskJson));
       }
       close() {
@@ -12197,6 +12318,9 @@ var init_migration = __esm({
        * @returns Generated name
        */
       async generateProjectName(projectPath) {
+        if (!existsSync7(join9(projectPath, ".git"))) {
+          return basename3(projectPath);
+        }
         try {
           const { execFile: execFile5 } = await import("node:child_process");
           const { promisify: promisify14 } = await import("node:util");
@@ -12204,7 +12328,7 @@ var init_migration = __esm({
           const { stdout } = await execFileAsync3(
             "git",
             ["remote", "get-url", "origin"],
-            { cwd: projectPath, timeout: 5e3 }
+            { cwd: projectPath, timeout: 1e3 }
           );
           const remoteUrl = stdout.trim();
           if (remoteUrl) {
@@ -28698,6 +28822,27 @@ var init_run_command = __esm({
   }
 });
 
+// ../core/src/logger.ts
+function createLogger(prefix) {
+  const tag = `[${prefix}]`;
+  return {
+    log(message, ...args) {
+      console.error(`${tag} ${message}`, ...args);
+    },
+    warn(message, ...args) {
+      console.warn(`${tag} ${message}`, ...args);
+    },
+    error(message, ...args) {
+      console.error(`${tag} ${message}`, ...args);
+    }
+  };
+}
+var init_logger = __esm({
+  "../core/src/logger.ts"() {
+    "use strict";
+  }
+});
+
 // ../core/src/store.ts
 import { EventEmitter as EventEmitter11 } from "node:events";
 import { randomUUID as randomUUID6 } from "node:crypto";
@@ -28746,7 +28891,7 @@ function canonicalizeSettings(settings) {
   }
   return settings;
 }
-var LEGACY_BACKUP_DIR, TASK_ACTIVITY_LOG_ENTRY_LIMIT, TASK_ACTIVITY_LOG_OUTCOME_LIMIT, ARCHIVE_AGENT_LOG_SNAPSHOT_LIMIT, ARCHIVE_AGENT_LOG_SNIPPET_LIMIT, TaskHasDependentsError, TaskStore;
+var LEGACY_BACKUP_DIR, TASK_ACTIVITY_LOG_ENTRY_LIMIT, TASK_ACTIVITY_LOG_OUTCOME_LIMIT, ARCHIVE_AGENT_LOG_SNAPSHOT_LIMIT, ARCHIVE_AGENT_LOG_SNIPPET_LIMIT, storeLog, TaskHasDependentsError, TaskStore;
 var init_store = __esm({
   "../core/src/store.ts"() {
     "use strict";
@@ -28764,11 +28909,13 @@ var init_store = __esm({
     init_task_merge();
     init_project_memory();
     init_run_command();
+    init_logger();
     LEGACY_BACKUP_DIR = ".kb/backups";
     TASK_ACTIVITY_LOG_ENTRY_LIMIT = 1e3;
     TASK_ACTIVITY_LOG_OUTCOME_LIMIT = 4e3;
     ARCHIVE_AGENT_LOG_SNAPSHOT_LIMIT = 25;
     ARCHIVE_AGENT_LOG_SNIPPET_LIMIT = 160;
+    storeLog = createLogger("task-store");
     TaskHasDependentsError = class extends Error {
       taskId;
       dependentIds;
@@ -29478,45 +29625,53 @@ ${recentText}` : void 0
        */
       setupActivityLogListeners() {
         this.on("task:created", (task) => {
-          this.recordActivity({
-            type: "task:created",
-            taskId: task.id,
-            taskTitle: task.title,
-            details: `Task ${task.id} created${task.title ? `: ${task.title}` : ""}`
-          }).catch(() => {
-          });
+          this.recordActivityFromListener(
+            {
+              type: "task:created",
+              taskId: task.id,
+              taskTitle: task.title,
+              details: `Task ${task.id} created${task.title ? `: ${task.title}` : ""}`
+            },
+            "task:created"
+          );
         });
         this.on("task:moved", (data) => {
-          this.recordActivity({
-            type: "task:moved",
-            taskId: data.task.id,
-            taskTitle: data.task.title,
-            details: `Task ${data.task.id} moved: ${data.from} \u2192 ${data.to}`,
-            metadata: { from: data.from, to: data.to }
-          }).catch(() => {
-          });
+          this.recordActivityFromListener(
+            {
+              type: "task:moved",
+              taskId: data.task.id,
+              taskTitle: data.task.title,
+              details: `Task ${data.task.id} moved: ${data.from} \u2192 ${data.to}`,
+              metadata: { from: data.from, to: data.to }
+            },
+            "task:moved"
+          );
         });
         this.on("task:merged", (result) => {
           const status = result.merged ? "successfully merged" : "merge attempted";
-          this.recordActivity({
-            type: "task:merged",
-            taskId: result.task.id,
-            taskTitle: result.task.title,
-            details: `Task ${result.task.id} ${status} to main`,
-            metadata: { merged: result.merged, branch: result.branch }
-          }).catch(() => {
-          });
+          this.recordActivityFromListener(
+            {
+              type: "task:merged",
+              taskId: result.task.id,
+              taskTitle: result.task.title,
+              details: `Task ${result.task.id} ${status} to main`,
+              metadata: { merged: result.merged, branch: result.branch }
+            },
+            "task:merged"
+          );
         });
         this.on("task:updated", (task) => {
           if (task.status === "failed") {
-            this.recordActivity({
-              type: "task:failed",
-              taskId: task.id,
-              taskTitle: task.title,
-              details: `Task ${task.id} failed${task.error ? `: ${task.error}` : ""}`,
-              metadata: task.error ? { error: task.error } : void 0
-            }).catch(() => {
-            });
+            this.recordActivityFromListener(
+              {
+                type: "task:failed",
+                taskId: task.id,
+                taskTitle: task.title,
+                details: `Task ${task.id} failed${task.error ? `: ${task.error}` : ""}`,
+                metadata: task.error ? { error: task.error } : void 0
+              },
+              "task:updated"
+            );
           }
         });
         this.on("settings:updated", (data) => {
@@ -29534,21 +29689,35 @@ ${recentText}` : void 0
             importantChanges.push(`engine pause ${data.settings.enginePaused ? "enabled" : "disabled"}`);
           }
           if (importantChanges.length > 0) {
-            this.recordActivity({
-              type: "settings:updated",
-              details: `Settings updated: ${importantChanges.join(", ")}`,
-              metadata: { changes: importantChanges }
-            }).catch(() => {
-            });
+            this.recordActivityFromListener(
+              {
+                type: "settings:updated",
+                details: `Settings updated: ${importantChanges.join(", ")}`,
+                metadata: { changes: importantChanges }
+              },
+              "settings:updated"
+            );
           }
         });
         this.on("task:deleted", (task) => {
-          this.recordActivity({
-            type: "task:deleted",
-            taskId: task.id,
-            taskTitle: task.title,
-            details: `Task ${task.id} deleted${task.title ? `: ${task.title}` : ""}`
-          }).catch(() => {
+          this.recordActivityFromListener(
+            {
+              type: "task:deleted",
+              taskId: task.id,
+              taskTitle: task.title,
+              details: `Task ${task.id} deleted${task.title ? `: ${task.title}` : ""}`
+            },
+            "task:deleted"
+          );
+        });
+      }
+      recordActivityFromListener(entry, sourceEvent) {
+        this.recordActivity(entry).catch((err) => {
+          storeLog.warn("Activity logging listener failed", {
+            sourceEvent,
+            type: entry.type,
+            taskId: entry.taskId,
+            error: err instanceof Error ? err.message : String(err)
           });
         });
       }
@@ -30070,7 +30239,11 @@ ${recentText}` : void 0
             if (defaultOnSteps.length > 0) {
               resolvedWorkflowSteps = defaultOnSteps;
             }
-          } catch {
+          } catch (err) {
+            storeLog.warn("Failed to auto-apply default workflow steps during task creation", {
+              error: err instanceof Error ? err.message : String(err),
+              descriptionLength: input.description.length
+            });
           }
         } else if (input.enabledWorkflowSteps.length === 0) {
           resolvedWorkflowSteps = void 0;
@@ -30088,13 +30261,26 @@ ${recentText}` : void 0
                 }
               }
             } catch (err) {
-              const errorMsg = err instanceof Error ? err.message : String(err);
               const autoEnabled = options?.settings?.autoSummarizeTitles === true;
-              console.warn(
-                `[TaskStore] Title summarization failed for task ${id}: ${errorMsg} (desc length: ${input.description.length}, auto-summarize: ${autoEnabled})`
+              const errorMessage = err instanceof Error ? err.message : String(err);
+              storeLog.warn(
+                `Title summarization failed for task ${id}: ${errorMessage} (desc length: ${input.description.length}, auto-summarize: ${autoEnabled})`,
+                {
+                  taskId: id,
+                  descriptionLength: input.description.length,
+                  autoSummarizeEnabled: autoEnabled,
+                  error: errorMessage
+                }
               );
             }
-          }).catch(() => {
+          }).catch((err) => {
+            const autoEnabled = options?.settings?.autoSummarizeTitles === true;
+            storeLog.error("Unexpected title summarization promise-chain failure", {
+              taskId: id,
+              descriptionLength: input.description.length,
+              autoSummarizeEnabled: autoEnabled,
+              error: err instanceof Error ? err.message : String(err)
+            });
           });
         }
         return task;
@@ -30361,26 +30547,46 @@ ${newTask.description}
         if (sanitizedTokens.length === 0) {
           return this.listTasks(options);
         }
-        const ftsQuery = sanitizedTokens.map((token) => {
-          if (/[":(){}*^+-]/.test(token)) {
-            return `"${token.replace(/"/g, '\\"')}"`;
-          }
-          return token;
-        }).join(" OR ");
         const limit = options?.limit ?? -1;
         const offset = options?.offset ?? 0;
         const offsetClause = offset > 0 ? ` OFFSET ${offset}` : "";
         const includeArchived = options?.includeArchived ?? true;
-        const whereClause = includeArchived ? "" : ` AND t."column" != 'archived'`;
-        const selectClause = this.getTaskSelectClause(options?.slim ?? false, "t");
-        const rows = this.db.prepare(`
-      SELECT ${selectClause} FROM tasks t
-      JOIN tasks_fts fts ON t.rowid = fts.rowid
-      WHERE tasks_fts MATCH ?
-      ${whereClause}
-      ORDER BY rank
-      LIMIT ${limit >= 0 ? limit : -1}${offsetClause}
-    `).all(ftsQuery);
+        const slim = options?.slim ?? false;
+        const selectClause = this.getTaskSelectClause(slim, "t");
+        let rows;
+        if (this.db.fts5Available) {
+          const ftsQuery = sanitizedTokens.map((token) => {
+            if (/[":(){}*^+-]/.test(token)) {
+              return `"${token.replace(/"/g, '\\"')}"`;
+            }
+            return token;
+          }).join(" OR ");
+          const whereClause = includeArchived ? "" : ` AND t."column" != 'archived'`;
+          rows = this.db.prepare(`
+        SELECT ${selectClause} FROM tasks t
+        JOIN tasks_fts fts ON t.rowid = fts.rowid
+        WHERE tasks_fts MATCH ?
+        ${whereClause}
+        ORDER BY rank
+        LIMIT ${limit >= 0 ? limit : -1}${offsetClause}
+      `).all(ftsQuery);
+        } else {
+          const searchColumns = ["id", "title", "description", "comments"];
+          const perTokenClause = `(${searchColumns.map((c) => `t."${c}" LIKE ? ESCAPE '\\'`).join(" OR ")})`;
+          const whereTokens = sanitizedTokens.map(() => perTokenClause).join(" OR ");
+          const params = [];
+          for (const token of sanitizedTokens) {
+            const pattern = `%${token.replace(/[\\%_]/g, "\\$&")}%`;
+            for (let i = 0; i < searchColumns.length; i++) params.push(pattern);
+          }
+          const archivedClause = includeArchived ? "" : ` AND t."column" != 'archived'`;
+          rows = this.db.prepare(`
+        SELECT ${selectClause} FROM tasks t
+        WHERE (${whereTokens})${archivedClause}
+        ORDER BY t.createdAt ASC
+        LIMIT ${limit >= 0 ? limit : -1}${offsetClause}
+      `).all(...params);
+        }
         const activeMatches = await Promise.all(rows.map(async (row) => {
           const task = this.rowToTask(row);
           if (task.steps.length > 0) {
@@ -30389,7 +30595,7 @@ ${newTask.description}
           const steps = await this.parseStepsFromPrompt(task.id);
           return steps.length > 0 ? { ...task, steps } : task;
         }));
-        const archiveMatches = includeArchived ? this.archiveDb.search(ftsQuery, limit >= 0 ? limit : 100).map((entry) => this.archiveEntryToTask(entry, options?.slim ?? false)) : [];
+        const archiveMatches = includeArchived ? this.archiveDb.search(trimmedQuery, limit >= 0 ? limit : 100).map((entry) => this.archiveEntryToTask(entry, slim)) : [];
         const matches = [...activeMatches, ...archiveMatches];
         return limit >= 0 ? matches.slice(0, limit) : matches;
       }
@@ -31525,9 +31731,17 @@ ${task.description}
         try {
           this.watcher = watch(this.tasksDir, { recursive: true }, (_event, _filename) => {
           });
-          this.watcher.on("error", () => {
+          this.watcher.on("error", (err) => {
+            storeLog.warn("fs.watch emitted an error; polling will continue", {
+              error: err instanceof Error ? err.message : String(err),
+              tasksDir: this.tasksDir
+            });
+          });
+        } catch (err) {
+          storeLog.warn("fs.watch unavailable; falling back to polling-only updates", {
+            error: err instanceof Error ? err.message : String(err),
+            tasksDir: this.tasksDir
           });
-        } catch {
         }
         this.pollInterval = setInterval(() => {
           void this.checkForChanges();
@@ -31583,9 +31797,17 @@ ${task.description}
           }
           const elapsed = Date.now() - startTime;
           if (elapsed > 100) {
-            console.warn(`[TaskStore] checkForChanges took ${elapsed}ms \u2014 event loop may have been blocked`);
+            storeLog.warn("checkForChanges took longer than expected", {
+              elapsedMs: elapsed,
+              thresholdMs: 100
+            });
           }
-        } catch {
+        } catch (err) {
+          storeLog.warn("checkForChanges poll cycle failed", {
+            lastKnownModified: this.lastKnownModified,
+            lastPollTime: this.lastPollTime,
+            error: err instanceof Error ? err.message : String(err)
+          });
         } finally {
           this.pollingInProgress = false;
         }
@@ -32840,7 +33062,15 @@ ${notificationsSection}
           );
           this.db.bumpLastModified();
         } catch (err) {
-          console.error("Failed to record activity:", err);
+          storeLog.error("Failed to record activity", {
+            id: fullEntry.id,
+            type: fullEntry.type,
+            taskId: fullEntry.taskId,
+            taskTitle: fullEntry.taskTitle,
+            detailsLength: fullEntry.details.length,
+            hasMetadata: fullEntry.metadata !== void 0,
+            error: err instanceof Error ? err.message : String(err)
+          });
         }
         return fullEntry;
       }
@@ -33822,27 +34052,6 @@ var init_routine_store = __esm({
   }
 });
 
-// ../core/src/logger.ts
-function createLogger(prefix) {
-  const tag = `[${prefix}]`;
-  return {
-    log(message, ...args) {
-      console.error(`${tag} ${message}`, ...args);
-    },
-    warn(message, ...args) {
-      console.warn(`${tag} ${message}`, ...args);
-    },
-    error(message, ...args) {
-      console.error(`${tag} ${message}`, ...args);
-    }
-  };
-}
-var init_logger = __esm({
-  "../core/src/logger.ts"() {
-    "use strict";
-  }
-});
-
 // ../core/src/plugin-loader.ts
 import { isAbsolute as isAbsolute5, resolve as resolve8 } from "node:path";
 import { EventEmitter as EventEmitter13 } from "node:events";
@@ -59048,13 +59257,13 @@ function createLogger2(prefix) {
   const tag = `[${prefix}]`;
   return {
     log(message, ...args) {
-      console.error(`${tag} ${message}`, ...args);
+      globalThis.console.error(`${tag} ${message}`, ...args);
     },
     warn(message, ...args) {
-      console.warn(`${tag} ${message}`, ...args);
+      globalThis.console.warn(`${tag} ${message}`, ...args);
     },
     error(message, ...args) {
-      console.error(`${tag} ${message}`, ...args);
+      globalThis.console.error(`${tag} ${message}`, ...args);
     }
   };
 }
@@ -60372,7 +60581,6 @@ function createSkillsOverrideFromSelection(selection, options = {}) {
       }
     }
     if (newDiagnostics.length > 0) {
-      const _purpose = sessionPurpose ? `[${sessionPurpose}]` : "skills";
       for (const diag of newDiagnostics) {
         piLog.warn(`[skills] ${diag.type}: ${diag.message}`);
       }
@@ -60442,7 +60650,7 @@ import { join as join27 } from "node:path";
 import { AuthStorage } from "@mariozechner/pi-coding-agent";
 import { getOAuthProvider } from "@mariozechner/pi-ai/oauth";
 function getHomeDir2() {
-  return process.env.HOME || process.env.USERPROFILE || homedir6();
+  return globalThis.process.env.HOME || globalThis.process.env.USERPROFILE || homedir6();
 }
 function getFusionAuthPath2(home = getHomeDir2()) {
   return join27(home, ".fusion", "agent", "auth.json");
@@ -60488,7 +60696,7 @@ function readLegacyCredentials(authPaths = getLegacyAuthPaths()) {
 function resolveStoredApiKey(key) {
   if (!key)
     return void 0;
-  return process.env[key] ?? key;
+  return globalThis.process.env[key] ?? key;
 }
 function resolveOAuthApiKey(providerId, credential) {
   if (credential.type !== "oauth" || typeof credential.access !== "string" || typeof credential.refresh !== "string" || typeof credential.expires !== "number" || Date.now() >= credential.expires) {
@@ -60791,8 +60999,8 @@ function createReadOnlyPiSettingsView(cwd, agentDir) {
   const fusionProjectSettings = readJsonObject2(join28(projectRoot, ".fusion", "settings.json"));
   const mergedSettings = { ...globalSettings, ...fusionProjectSettings };
   return {
-    getGlobalSettings: () => structuredClone(globalSettings),
-    getProjectSettings: () => structuredClone(fusionProjectSettings),
+    getGlobalSettings: () => globalThis.structuredClone(globalSettings),
+    getProjectSettings: () => globalThis.structuredClone(fusionProjectSettings),
     getNpmCommand: () => Array.isArray(mergedSettings.npmCommand) ? [...mergedSettings.npmCommand] : void 0
   };
 }
@@ -60911,9 +61119,7 @@ function wrapToolsWithBoundary(tools, worktreePath, projectRoot) {
     return {
       ...tool,
       execute: async (...args) => {
-        const _toolCallId = args[0];
         const params = args[1];
-        const _signal = args[2];
         const pathArg = params.path;
         if (pathArg && !isWorktreeAllowedPath(worktreePath, projectRoot, pathArg)) {
           const relToProject = relative4(projectRoot, pathArg);
@@ -67131,6 +67337,36 @@ function buildReducedStepPrompt(taskDetail, stepIndex) {
   ];
   return parts.join("\n").replace(/\n{3,}/g, "\n\n");
 }
+function resolveExecutorModelPair(taskModelProvider, taskModelId, settings) {
+  if (taskModelProvider && taskModelId) {
+    return { provider: taskModelProvider, modelId: taskModelId };
+  }
+  if (settings?.executionProvider && settings?.executionModelId) {
+    return {
+      provider: settings.executionProvider,
+      modelId: settings.executionModelId
+    };
+  }
+  if (settings?.executionGlobalProvider && settings?.executionGlobalModelId) {
+    return {
+      provider: settings.executionGlobalProvider,
+      modelId: settings.executionGlobalModelId
+    };
+  }
+  if (settings?.defaultProviderOverride && settings?.defaultModelIdOverride) {
+    return {
+      provider: settings.defaultProviderOverride,
+      modelId: settings.defaultModelIdOverride
+    };
+  }
+  if (settings?.defaultProvider && settings?.defaultModelId) {
+    return {
+      provider: settings.defaultProvider,
+      modelId: settings.defaultModelId
+    };
+  }
+  return { provider: void 0, modelId: void 0 };
+}
 function sleep2(ms) {
   return new Promise((resolve29) => setTimeout(resolve29, ms));
 }
@@ -67323,8 +67559,11 @@ var init_step_session_executor = __esm({
                 createSendMessageTool(this.options.messageStore, taskDetail.assignedAgentId),
                 createReadMessagesTool(this.options.messageStore, taskDetail.assignedAgentId)
               ] : [];
-              const executorProvider = taskDetail.modelProvider && taskDetail.modelId ? taskDetail.modelProvider : settings.executionProvider && settings.executionModelId ? settings.executionProvider : settings.executionGlobalProvider && settings.executionGlobalModelId ? settings.executionGlobalProvider : settings.defaultProvider;
-              const executorModelId = taskDetail.modelProvider && taskDetail.modelId ? taskDetail.modelId : settings.executionProvider && settings.executionModelId ? settings.executionModelId : settings.executionGlobalProvider && settings.executionGlobalModelId ? settings.executionGlobalModelId : settings.defaultModelId;
+              const { provider: executorProvider, modelId: executorModelId } = resolveExecutorModelPair(
+                taskDetail.modelProvider,
+                taskDetail.modelId,
+                settings
+              );
               const createResult = await createFnAgent5({
                 cwd: worktreePath,
                 systemPrompt: `You are an AI agent executing step ${stepIndex} of task ${taskDetail.id}. Follow instructions precisely.`,
@@ -67758,6 +67997,36 @@ function getExecutorSystemPrompt(settings) {
   const customPrompt = resolveAgentPrompt("executor", settings.agentPrompts);
   return customPrompt || EXECUTOR_SYSTEM_PROMPT;
 }
+function resolveExecutorModelPair2(taskModelProvider, taskModelId, settings) {
+  if (taskModelProvider && taskModelId) {
+    return { provider: taskModelProvider, modelId: taskModelId };
+  }
+  if (settings?.executionProvider && settings?.executionModelId) {
+    return {
+      provider: settings.executionProvider,
+      modelId: settings.executionModelId
+    };
+  }
+  if (settings?.executionGlobalProvider && settings?.executionGlobalModelId) {
+    return {
+      provider: settings.executionGlobalProvider,
+      modelId: settings.executionGlobalModelId
+    };
+  }
+  if (settings?.defaultProviderOverride && settings?.defaultModelIdOverride) {
+    return {
+      provider: settings.defaultProviderOverride,
+      modelId: settings.defaultModelIdOverride
+    };
+  }
+  if (settings?.defaultProvider && settings?.defaultModelId) {
+    return {
+      provider: settings.defaultProvider,
+      modelId: settings.defaultModelId
+    };
+  }
+  return { provider: void 0, modelId: void 0 };
+}
 function formatTimestamp2(iso) {
   const date = new Date(iso);
   const now = /* @__PURE__ */ new Date();
@@ -67914,7 +68183,7 @@ function detectReviewHandoffIntent(commentText) {
   ];
   return handoffPhrases.some((phrase) => text.includes(phrase));
 }
-var execAsync5, STEP_STATUSES, MAX_WORKFLOW_STEP_RETRIES, WORKFLOW_SCRIPT_OUTPUT_MAX_CHARS2, NonRetryableWorktreeError, taskUpdateParams, taskAddDepParams, spawnAgentParams, reviewStepParams, EXECUTOR_SYSTEM_PROMPT, TaskExecutor;
+var execAsync5, STEP_STATUSES, MAX_WORKFLOW_STEP_RETRIES, MAX_TASK_DONE_SESSION_RETRIES, MAX_TASK_DONE_REQUEUE_RETRIES, WORKFLOW_SCRIPT_OUTPUT_MAX_CHARS2, NonRetryableWorktreeError, taskUpdateParams, taskAddDepParams, spawnAgentParams, reviewStepParams, EXECUTOR_SYSTEM_PROMPT, TaskExecutor;
 var init_executor = __esm({
   "../engine/src/executor.ts"() {
     "use strict";
@@ -67947,6 +68216,8 @@ var init_executor = __esm({
     execAsync5 = promisify6(exec5);
     STEP_STATUSES = ["pending", "in-progress", "done", "skipped"];
     MAX_WORKFLOW_STEP_RETRIES = 3;
+    MAX_TASK_DONE_SESSION_RETRIES = 3;
+    MAX_TASK_DONE_REQUEUE_RETRIES = 3;
     WORKFLOW_SCRIPT_OUTPUT_MAX_CHARS2 = 4e3;
     NonRetryableWorktreeError = class extends Error {
     };
@@ -68234,8 +68505,11 @@ Lint, tests, and typecheck are also hard quality gates:
                 activeEntry.lastModelProvider = task.modelProvider;
                 activeEntry.lastModelId = task.modelId;
                 const settings = await this.store.getSettings();
-                const newProvider = task.modelProvider && task.modelId ? task.modelProvider : settings?.executionProvider && settings?.executionModelId ? settings.executionProvider : settings?.executionGlobalProvider && settings?.executionGlobalModelId ? settings.executionGlobalProvider : settings?.defaultProvider;
-                const newModelId = task.modelProvider && task.modelId ? task.modelId : settings?.executionProvider && settings?.executionModelId ? settings.executionModelId : settings?.executionGlobalProvider && settings?.executionGlobalModelId ? settings.executionGlobalModelId : settings?.defaultModelId;
+                const { provider: newProvider, modelId: newModelId } = resolveExecutorModelPair2(
+                  task.modelProvider,
+                  task.modelId,
+                  settings
+                );
                 if (newProvider && newModelId) {
                   try {
                     const model = this.modelRegistry.find(newProvider, newModelId);
@@ -69142,8 +69416,11 @@ Lint, tests, and typecheck are also hard quality gates:
             }
           });
           const agentWork = async () => {
-            const executorProvider = detail.modelProvider && detail.modelId ? detail.modelProvider : settings.executionProvider && settings.executionModelId ? settings.executionProvider : settings.executionGlobalProvider && settings.executionGlobalModelId ? settings.executionGlobalProvider : settings.defaultProvider;
-            const executorModelId = detail.modelProvider && detail.modelId ? detail.modelId : settings.executionProvider && settings.executionModelId ? settings.executionModelId : settings.executionGlobalProvider && settings.executionGlobalModelId ? settings.executionGlobalModelId : settings.defaultModelId;
+            const { provider: executorProvider, modelId: executorModelId } = resolveExecutorModelPair2(
+              detail.modelProvider,
+              detail.modelId,
+              settings
+            );
             const executorFallbackProvider = settings.fallbackProvider;
             const executorFallbackModelId = settings.fallbackModelId;
             const executorThinkingLevel = detail.thinkingLevel ?? settings.defaultThinkingLevel;
@@ -69325,63 +69602,74 @@ Lint, tests, and typecheck are also hard quality gates:
                 executorLog.log(`\u2713 ${task.id} completed \u2192 in-review`);
                 this.options.onComplete?.(task);
               } else {
-                executorLog.log(`\u26A0 ${task.id} finished without task_done \u2014 retrying with new session`);
-                await this.store.logEntry(task.id, "Agent finished without calling task_done \u2014 retrying with new session", void 0, this.currentRunContext);
-                this.activeSessions.delete(task.id);
-                session.dispose();
-                const { session: retrySession2, sessionFile: retrySessionFile } = await createResolvedAgentSession({
-                  sessionPurpose: "executor",
-                  pluginRunner: this.options.pluginRunner,
-                  cwd: worktreePath,
-                  systemPrompt: executorSystemPrompt,
-                  tools: "coding",
-                  customTools,
-                  onText: agentLogger.onText,
-                  onThinking: agentLogger.onThinking,
-                  onToolStart: agentLogger.onToolStart,
-                  onToolEnd: agentLogger.onToolEnd,
-                  defaultProvider: executorProvider,
-                  defaultModelId: executorModelId,
-                  fallbackProvider: executorFallbackProvider,
-                  fallbackModelId: executorFallbackModelId,
-                  defaultThinkingLevel: executorThinkingLevel,
-                  sessionManager: SessionManager2.create(worktreePath),
-                  // Skill selection: use assigned agent skills if available, otherwise role fallback
-                  ...skillContext.skillSelectionContext ? { skillSelection: skillContext.skillSelectionContext } : {}
-                });
-                if (retrySessionFile) {
-                  this.store.updateTask(task.id, { sessionFile: retrySessionFile }).catch((err) => {
-                    const msg = err instanceof Error ? err.message : String(err);
-                    executorLog.warn(`${task.id} failed to persist retry sessionFile: ${msg}`);
+                let taskDoneSessionRetries = 0;
+                while (!taskDone && taskDoneSessionRetries < MAX_TASK_DONE_SESSION_RETRIES) {
+                  taskDoneSessionRetries++;
+                  executorLog.log(
+                    `\u26A0 ${task.id} finished without task_done \u2014 retrying with new session (${taskDoneSessionRetries}/${MAX_TASK_DONE_SESSION_RETRIES})`
+                  );
+                  await this.store.logEntry(
+                    task.id,
+                    `Agent finished without calling task_done \u2014 retrying with new session (${taskDoneSessionRetries}/${MAX_TASK_DONE_SESSION_RETRIES})`,
+                    void 0,
+                    this.currentRunContext
+                  );
+                  this.activeSessions.delete(task.id);
+                  session.dispose();
+                  const { session: retrySession2, sessionFile: retrySessionFile } = await createResolvedAgentSession({
+                    sessionPurpose: "executor",
+                    pluginRunner: this.options.pluginRunner,
+                    cwd: worktreePath,
+                    systemPrompt: executorSystemPrompt,
+                    tools: "coding",
+                    customTools,
+                    onText: agentLogger.onText,
+                    onThinking: agentLogger.onThinking,
+                    onToolStart: agentLogger.onToolStart,
+                    onToolEnd: agentLogger.onToolEnd,
+                    defaultProvider: executorProvider,
+                    defaultModelId: executorModelId,
+                    fallbackProvider: executorFallbackProvider,
+                    fallbackModelId: executorFallbackModelId,
+                    defaultThinkingLevel: executorThinkingLevel,
+                    sessionManager: SessionManager2.create(worktreePath),
+                    // Skill selection: use assigned agent skills if available, otherwise role fallback
+                    ...skillContext.skillSelectionContext ? { skillSelection: skillContext.skillSelectionContext } : {}
                   });
-                }
-                session = retrySession2;
-                sessionRef.current = retrySession2;
-                this.activeSessions.set(task.id, {
-                  session: retrySession2,
-                  seenSteeringIds,
-                  lastModelProvider: detail.modelProvider,
-                  lastModelId: detail.modelId
-                });
-                stuckDetector?.trackTask(task.id, retrySession2);
-                const retryPrompt = [
-                  "Your previous session ended without calling the task_done tool.",
-                  "The task may already be complete \u2014 review the current state of the worktree and either:",
-                  "1. If the work is done, call task_done with a summary of what was accomplished.",
-                  "2. If there is remaining work, finish it and then call task_done.",
-                  "",
-                  "Original task:",
-                  buildExecutionPrompt(detail, this.rootDir, settings, worktreePath)
-                ].join("\n");
-                stuckDetector?.recordActivity(task.id);
-                await promptWithFallback(retrySession2, retryPrompt);
-                checkSessionError(retrySession2);
-                if (!taskDone) {
-                  const implicitCheck = await this.store.getTask(task.id);
-                  if (implicitCheck.steps.length > 0 && implicitCheck.steps.every((s) => s.status === "done" || s.status === "skipped")) {
-                    taskDone = true;
-                    executorLog.log(`${task.id} all steps done \u2014 treating as implicit task_done`);
-                    await this.store.logEntry(task.id, "All steps complete \u2014 implicit task_done (agent did not call tool explicitly)", void 0, this.currentRunContext);
+                  if (retrySessionFile) {
+                    this.store.updateTask(task.id, { sessionFile: retrySessionFile }).catch((err) => {
+                      const msg = err instanceof Error ? err.message : String(err);
+                      executorLog.warn(`${task.id} failed to persist retry sessionFile: ${msg}`);
+                    });
+                  }
+                  session = retrySession2;
+                  sessionRef.current = retrySession2;
+                  this.activeSessions.set(task.id, {
+                    session: retrySession2,
+                    seenSteeringIds,
+                    lastModelProvider: detail.modelProvider,
+                    lastModelId: detail.modelId
+                  });
+                  stuckDetector?.trackTask(task.id, retrySession2);
+                  const retryPrompt = [
+                    "Your previous session ended without calling the task_done tool.",
+                    "The task may already be complete \u2014 review the current state of the worktree and either:",
+                    "1. If the work is done, call task_done with a summary of what was accomplished.",
+                    "2. If there is remaining work, finish it and then call task_done.",
+                    "",
+                    "Original task:",
+                    buildExecutionPrompt(detail, this.rootDir, settings, worktreePath)
+                  ].join("\n");
+                  stuckDetector?.recordActivity(task.id);
+                  await promptWithFallback(retrySession2, retryPrompt);
+                  checkSessionError(retrySession2);
+                  if (!taskDone) {
+                    const implicitCheck = await this.store.getTask(task.id);
+                    if (implicitCheck.steps.length > 0 && implicitCheck.steps.every((s) => s.status === "done" || s.status === "skipped")) {
+                      taskDone = true;
+                      executorLog.log(`${task.id} all steps done \u2014 treating as implicit task_done`);
+                      await this.store.logEntry(task.id, "All steps complete \u2014 implicit task_done (agent did not call tool explicitly)", void 0, this.currentRunContext);
+                    }
                   }
                 }
                 if (taskDone) {
@@ -69410,11 +69698,29 @@ Lint, tests, and typecheck are also hard quality gates:
                   executorLog.log(`\u2713 ${task.id} completed on retry \u2192 in-review`);
                   this.options.onComplete?.(task);
                 } else {
-                  const errorMessage = "Agent finished without calling task_done (after retry)";
-                  await this.store.updateTask(task.id, { status: "failed", error: errorMessage });
-                  await this.store.logEntry(task.id, `${errorMessage} \u2014 moved to in-review for inspection`, void 0, this.currentRunContext);
-                  await this.store.moveTask(task.id, "in-review");
-                  executorLog.log(`\u2717 ${task.id} failed after retry \u2014 no task_done \u2192 in-review`);
+                  const priorRequeues = task.taskDoneRetryCount ?? 0;
+                  const nextRequeueCount = priorRequeues + 1;
+                  const errorMessage = `Agent finished without calling task_done (after ${MAX_TASK_DONE_SESSION_RETRIES} retries)`;
+                  if (priorRequeues < MAX_TASK_DONE_REQUEUE_RETRIES) {
+                    await this.store.updateTask(task.id, {
+                      status: "failed",
+                      error: errorMessage,
+                      taskDoneRetryCount: nextRequeueCount
+                    });
+                    await this.store.logEntry(
+                      task.id,
+                      `${errorMessage} \u2014 requeued to todo immediately (${nextRequeueCount}/${MAX_TASK_DONE_REQUEUE_RETRIES})`,
+                      void 0,
+                      this.currentRunContext
+                    );
+                    await this.store.moveTask(task.id, "todo");
+                    executorLog.log(`\u2717 ${task.id} failed after ${MAX_TASK_DONE_SESSION_RETRIES} retries \u2014 requeued to todo (${nextRequeueCount}/${MAX_TASK_DONE_REQUEUE_RETRIES})`);
+                  } else {
+                    await this.store.updateTask(task.id, { status: "failed", error: errorMessage });
+                    await this.store.logEntry(task.id, `${errorMessage} \u2014 moved to in-review for inspection`, void 0, this.currentRunContext);
+                    await this.store.moveTask(task.id, "in-review");
+                    executorLog.log(`\u2717 ${task.id} failed after ${MAX_TASK_DONE_SESSION_RETRIES} retries \u2014 no task_done \u2192 in-review`);
+                  }
                   this.options.onError?.(task, new Error(errorMessage));
                 }
               }
@@ -76000,7 +76306,7 @@ async function getHeartbeatMemorySettings(taskStore) {
   return maybeGetSettings.call(taskStore);
 }
 function isTickableState(state) {
-  return state === "active" || state === "running";
+  return state === "active" || state === "running" || state === "idle";
 }
 function isHeartbeatManaged(agent) {
   return !isEphemeralAgent(agent);
@@ -115145,9 +115451,10 @@ function createApiRoutes(store, options) {
     try {
       const { store: scopedStore } = await getProjectContext2(req);
       const settings = await scopedStore.getSettingsFast();
+      const prAuthAvailable = isGhAvailable() && isGhAuthenticated() || Boolean(githubToken);
       res.json({
         ...settings,
-        githubTokenConfigured: Boolean(githubToken)
+        prAuthAvailable
       });
     } catch (err) {
       if (err instanceof ApiError) {
@@ -115159,7 +115466,7 @@ function createApiRoutes(store, options) {
   router.put("/settings", async (req, res) => {
     try {
       const { store: scopedStore, engine } = await getProjectContext2(req);
-      const { githubTokenConfigured, ...clientSettings } = req.body;
+      const { githubTokenConfigured, prAuthAvailable, ...clientSettings } = req.body;
       const globalKeySet = new Set(GLOBAL_SETTINGS_KEYS);
       const globalFieldsFound = Object.keys(clientSettings).filter((k) => globalKeySet.has(k));
       if (globalFieldsFound.length > 0) {
@@ -133847,6 +134154,26 @@ function visibleTruncate(text, maxWidth) {
   }
   return result;
 }
+function formatConsoleArgs(args) {
+  const stringified = args.map((arg) => {
+    if (typeof arg === "string") return arg;
+    if (arg instanceof Error) return arg.stack ?? arg.message;
+    if (arg === null || arg === void 0) return String(arg);
+    if (typeof arg === "object") {
+      try {
+        return JSON.stringify(arg);
+      } catch {
+        return String(arg);
+      }
+    }
+    return String(arg);
+  }).join(" ");
+  const match = stringified.match(/^\[([^\]]+)\]\s*(.*)$/s);
+  if (match) {
+    return { prefix: match[1], message: match[2] };
+  }
+  return { message: stringified };
+}
 function centerText(text, width, padChar = " ") {
   const visibleLen = visibleLength(text);
   const padding = Math.max(0, width - visibleLen);
@@ -133854,11 +134181,6 @@ function centerText(text, width, padChar = " ") {
   const rightPad = padding - leftPad;
   return padChar.repeat(leftPad) + text + padChar.repeat(rightPad);
 }
-function padRight(text, width) {
-  if (width <= 0) return "";
-  const visibleLen = visibleLength(text);
-  return text + " ".repeat(Math.max(0, width - visibleLen));
-}
 function isTTYAvailable() {
   return Boolean(process.stdout.isTTY && process.stdin.isTTY);
 }
@@ -133896,9 +134218,9 @@ var init_dashboard_tui = __esm({
         return this.count;
       }
     };
-    SECTION_ORDER = ["logs", "system", "utilities", "stats", "settings"];
+    SECTION_ORDER = ["system", "logs", "utilities", "stats", "settings"];
     DashboardTUI = class {
-      activeSection = "logs";
+      activeSection = "system";
       logBuffer;
       systemInfo = null;
       taskStats = null;
@@ -133911,6 +134233,11 @@ var init_dashboard_tui = __esm({
       showHelp = false;
       uptimeTimer = null;
       resizeHandler = null;
+      // Logs interaction state
+      selectedLogIndex = 0;
+      logsViewportStart = 0;
+      logsWrapEnabled = false;
+      logsExpandedMode = false;
       constructor() {
         this.logBuffer = new LogRingBuffer();
       }
@@ -133939,8 +134266,21 @@ var init_dashboard_tui = __esm({
           ...entry,
           timestamp: /* @__PURE__ */ new Date()
         });
+        const newLength = this.logBuffer.getAll().length;
+        if (this.selectedLogIndex >= newLength) {
+          this.selectedLogIndex = Math.max(0, newLength - 1);
+        }
         this.render();
       }
+      /**
+       * Clear logs and reset selection state.
+       */
+      clearLogs() {
+        this.logBuffer.clear();
+        this.selectedLogIndex = 0;
+        this.logsViewportStart = 0;
+        this.logsExpandedMode = false;
+      }
       log(message, prefix) {
         this.addLog({ level: "info", message, prefix });
       }
@@ -133970,6 +134310,8 @@ var init_dashboard_tui = __esm({
             this.handleKeypress(str);
           } else if (key.ctrl && key.name === "c") {
             this.handleKeypress("");
+          } else if (key.name === "return" || key.name === "enter") {
+            this.handleKeypress("\r");
           } else if (key.name === "right") {
             this.handleKeypress("\x1B[C");
           } else if (key.name === "left") {
@@ -133980,6 +134322,12 @@ var init_dashboard_tui = __esm({
             this.handleKeypress("\x1B[B");
           } else if (key.name === "escape") {
             this.handleKeypress("\x1B");
+          } else if (key.name === "home") {
+            this.handleKeypress("Home");
+          } else if (key.name === "end") {
+            this.handleKeypress("End");
+          } else if (key.name === "space") {
+            this.handleKeypress(" ");
           }
         });
         this.uptimeTimer = setInterval(() => {
@@ -134079,6 +134427,79 @@ var init_dashboard_tui = __esm({
         }
         if (this.activeSection === "utilities") {
           this.handleUtilityKeypress(key);
+          return;
+        }
+        if (this.activeSection === "logs") {
+          this.handleLogsKeypress(key);
+          return;
+        }
+      }
+      handleLogsKeypress(key) {
+        const entries = this.logBuffer.getAll();
+        const maxIndex = Math.max(0, entries.length - 1);
+        if (key === "\x1B") {
+          if (this.logsExpandedMode) {
+            this.logsExpandedMode = false;
+            this.showHelp = false;
+            this.render();
+          } else if (this.showHelp) {
+            this.showHelp = false;
+            this.render();
+          }
+          return;
+        }
+        if (key === "\r") {
+          if (entries.length === 0) {
+            return;
+          }
+          this.logsExpandedMode = !this.logsExpandedMode;
+          this.render();
+          return;
+        }
+        if (key === "w" || key === "W") {
+          this.logsWrapEnabled = !this.logsWrapEnabled;
+          this.render();
+          return;
+        }
+        if (key === "\x1B[A" || key === "k" || key === "K") {
+          if (entries.length === 0) return;
+          if (this.selectedLogIndex > 0) {
+            this.selectedLogIndex--;
+            this.render();
+          }
+          return;
+        }
+        if (key === "\x1B[B" || key === "j" || key === "J") {
+          if (entries.length === 0) return;
+          if (this.selectedLogIndex < maxIndex) {
+            this.selectedLogIndex++;
+            this.render();
+          }
+          return;
+        }
+        if (key === "Home") {
+          if (entries.length === 0) return;
+          if (this.selectedLogIndex !== 0) {
+            this.selectedLogIndex = 0;
+            this.render();
+          }
+          return;
+        }
+        if (key === "End") {
+          if (entries.length === 0) return;
+          if (this.selectedLogIndex !== maxIndex) {
+            this.selectedLogIndex = maxIndex;
+            this.render();
+          }
+          return;
+        }
+        if (key === " " || key === "e" || key === "E") {
+          if (entries.length === 0) {
+            return;
+          }
+          this.logsExpandedMode = !this.logsExpandedMode;
+          this.render();
+          return;
         }
       }
       async handleUtilityKeypress(key) {
@@ -134089,8 +134510,7 @@ var init_dashboard_tui = __esm({
             break;
           case "c":
             this.callbacks.onClearLogs();
-            this.logBuffer.clear();
-            this.render();
+            this.clearLogs();
             break;
           case "t":
             if (this.systemInfo) {
@@ -134117,7 +134537,7 @@ var init_dashboard_tui = __esm({
       }
       renderHeader() {
         const cols = process.stdout.columns || 80;
-        const title = colorize("  fn board  ", "cyan");
+        const title = colorize("  fusion  ", "cyan");
         const titleLen = visibleLength(title);
         process.stdout.write(title);
         if (cols >= 70) {
@@ -134199,28 +134619,159 @@ var init_dashboard_tui = __esm({
             break;
         }
       }
+      getLogViewportStart(totalEntries, maxRows) {
+        if (totalEntries <= 0) {
+          this.logsViewportStart = 0;
+          return 0;
+        }
+        const maxStart = Math.max(0, totalEntries - maxRows);
+        let start = Math.min(this.logsViewportStart, maxStart);
+        if (this.selectedLogIndex < start) {
+          start = this.selectedLogIndex;
+        } else if (this.selectedLogIndex >= start + maxRows) {
+          start = this.selectedLogIndex - maxRows + 1;
+        }
+        this.logsViewportStart = Math.max(0, Math.min(start, maxStart));
+        return this.logsViewportStart;
+      }
       renderLogsSection() {
         const cols = process.stdout.columns || 80;
         const entries = this.logBuffer.getAll();
-        const maxRows = Math.max(1, (process.stdout.rows ?? 38) - 8);
+        const maxRows = Math.max(1, (process.stdout.rows ?? 38) - 9);
         process.stdout.write(colorize("\n  LOGS\n", "bold"));
         process.stdout.write(colorize(`  Ring buffer: ${this.logBuffer.total}/${MAX_LOG_ENTRIES} entries
-
 `, "dim"));
         if (entries.length === 0) {
           process.stdout.write(colorize("  No log entries yet.\n", "dim"));
           return;
         }
-        const displayEntries = entries.slice(-maxRows).reverse();
-        for (const entry of displayEntries) {
+        const safeSelectedIndex = Math.min(this.selectedLogIndex, Math.max(0, entries.length - 1));
+        if (safeSelectedIndex !== this.selectedLogIndex) {
+          this.selectedLogIndex = safeSelectedIndex;
+        }
+        if (this.logsExpandedMode) {
+          this.renderLogsExpandedPane(entries[safeSelectedIndex], safeSelectedIndex, entries.length);
+          return;
+        }
+        const modeIndicator = this.logsWrapEnabled ? colorize("  [w] wrap on", "dim") : colorize("  [w] wrap off", "dim");
+        process.stdout.write(modeIndicator + "\n\n");
+        const startIndex = this.getLogViewportStart(entries.length, maxRows);
+        const visibleEntries = entries.slice(startIndex, startIndex + maxRows);
+        const visibleReversed = [...visibleEntries].reverse();
+        const selectedDisplayIndex = safeSelectedIndex >= startIndex && safeSelectedIndex < startIndex + visibleEntries.length ? visibleEntries.length - 1 - (safeSelectedIndex - startIndex) : -1;
+        const prefixLen = 30;
+        const availableWidth = Math.max(8, cols - prefixLen);
+        for (let displayIdx = 0; displayIdx < visibleReversed.length; displayIdx++) {
+          const entry = visibleReversed[displayIdx];
+          const isSelected = displayIdx === selectedDisplayIndex;
+          const selector = isSelected ? colorize("\u25B8 ", "brightGreen") : "  ";
           const ts = colorize(formatTimestamp3(entry.timestamp), "dim");
           const prefix = entry.prefix ? colorize(`[${entry.prefix}]`, "gray") : "";
           const levelChar = entry.level === "error" ? colorize("\u2717", "brightRed") : entry.level === "warn" ? colorize("\u26A0", "brightYellow") : colorize("\u2713", "brightGreen");
-          const messageWidth = Math.max(8, cols - 40);
-          const message = visibleTruncate(entry.message, messageWidth);
-          const line = `  ${ts} ${levelChar} ${prefix ? prefix + " " : ""}${message}`;
-          process.stdout.write(visibleTruncate(line, cols - 1) + "\n");
+          if (this.logsWrapEnabled) {
+            const wrappedLines = this.wrapText(entry.message, availableWidth);
+            const firstLine = `${selector}${ts} ${levelChar} ${prefix ? prefix + " " : ""}${wrappedLines[0]}`;
+            process.stdout.write(visibleTruncate(firstLine, cols - 1) + "\n");
+            for (let i = 1; i < wrappedLines.length; i++) {
+              const continuation = `    ${wrappedLines[i]}`;
+              process.stdout.write(visibleTruncate(continuation, cols - 1) + "\n");
+            }
+          } else {
+            const messageWidth = Math.max(8, cols - prefixLen);
+            const message = visibleTruncate(entry.message, messageWidth);
+            const line = `${selector}${ts} ${levelChar} ${prefix ? prefix + " " : ""}${message}`;
+            process.stdout.write(visibleTruncate(line, cols - 1) + "\n");
+          }
+        }
+      }
+      /**
+       * Render the expanded log entry detail pane.
+       * Replaces the normal list view with a focused view of a single entry.
+       */
+      renderLogsExpandedPane(entry, index2, total) {
+        const cols = process.stdout.columns || 80;
+        const rows = process.stdout.rows ?? 24;
+        const maxContentRows = Math.max(1, rows - 12);
+        process.stdout.write(colorize("  EXPANDED LOG ENTRY\n", "bold"));
+        const navHint = colorize(`  Entry ${index2 + 1} of ${total} | [\u2191/k] older  [\u2193/j] newer  [Enter/Esc] close
+`, "dim");
+        process.stdout.write(navHint);
+        process.stdout.write(colorize("  " + "\u2500".repeat(Math.max(20, cols - 4)) + "\n", "dim"));
+        const ts = formatTimestamp3(entry.timestamp);
+        const levelLabel = entry.level === "error" ? colorize("ERROR", "brightRed") : entry.level === "warn" ? colorize("WARN", "brightYellow") : colorize("INFO", "brightGreen");
+        process.stdout.write(colorize(`  Timestamp: `, "gray") + colorize(ts, "white") + "\n");
+        process.stdout.write(colorize(`  Level: `, "gray") + levelLabel + "\n");
+        if (entry.prefix) {
+          process.stdout.write(colorize(`  Prefix: `, "gray") + colorize(entry.prefix, "dim") + "\n");
         }
+        process.stdout.write("\n");
+        process.stdout.write(colorize("  MESSAGE\n", "bold"));
+        const messageIndent = "  ";
+        const availableWidth = Math.max(8, cols - messageIndent.length);
+        const wrappedMessage = this.wrapText(entry.message, availableWidth);
+        let linesPrinted = 5;
+        for (const line of wrappedMessage) {
+          if (linesPrinted >= maxContentRows) {
+            process.stdout.write(colorize(`
+  ... (truncated)
+`, "dim"));
+            break;
+          }
+          process.stdout.write(messageIndent + line + "\n");
+          linesPrinted++;
+        }
+        const footerHint = colorize(`
+  [Esc] or [Enter] to close expanded view
+`, "dim");
+        process.stdout.write(footerHint);
+      }
+      /**
+       * Wrap text to fit within available width, returning an array of lines.
+       * Respects ANSI escape sequences via visibleLength.
+       */
+      wrapText(text, maxWidth) {
+        if (maxWidth <= 0) return [""];
+        if (visibleLength(text) <= maxWidth) return [text];
+        const lines = [];
+        let remaining = text;
+        while (visibleLength(remaining) > maxWidth) {
+          let breakIdx = 0;
+          for (let i = 0; i < remaining.length; i++) {
+            const char = remaining[i];
+            if (char === " " || char === "	") {
+              if (visibleLength(remaining.substring(0, i)) <= maxWidth) {
+                breakIdx = i;
+              }
+            }
+            if (visibleLength(remaining.substring(0, i + 1)) > maxWidth) {
+              break;
+            }
+          }
+          if (breakIdx === 0) {
+            const firstTokenMatch = remaining.match(/^(\S+)/);
+            if (firstTokenMatch) {
+              const firstToken = firstTokenMatch[1];
+              if (visibleLength(firstToken) > maxWidth) {
+                const chunkSize = Math.max(1, maxWidth - 1);
+                let chunkStart = 0;
+                while (chunkStart < firstToken.length) {
+                  const chunk = firstToken.substring(chunkStart, chunkStart + chunkSize);
+                  lines.push(chunk);
+                  chunkStart += chunkSize;
+                }
+                remaining = remaining.substring(firstToken.length).trimStart();
+                continue;
+              }
+            }
+            breakIdx = Math.min(maxWidth, remaining.length);
+          }
+          lines.push(remaining.substring(0, breakIdx).trimEnd());
+          remaining = remaining.substring(breakIdx).trimStart();
+        }
+        if (remaining.length > 0) {
+          lines.push(remaining);
+        }
+        return lines.length > 0 ? lines : [""];
       }
       renderSystemSection() {
         if (!this.systemInfo) {
@@ -134355,39 +134906,59 @@ var init_dashboard_tui = __esm({
         process.stdout.write(right);
         process.stdout.write("\n");
       }
-      renderHelpOverlay() {
-        const cols = process.stdout.columns || 80;
-        const rows = process.stdout.rows || 24;
-        const boxWidth = Math.min(62, Math.max(cols - 4, 20));
-        const useBoxDrawing = cols >= boxWidth + 4;
-        let helpLines;
+      /**
+       * Build help overlay lines as an array of strings.
+       * Uses dynamic visibleLength calculation to ensure consistent box width.
+       * All box-drawing rows (including borders) have the same total visible width.
+       *
+       * @param boxWidth - The interior content width (excluding the two box characters)
+       * @param useBoxDrawing - Whether to use box-drawing characters (true) or compact text (false)
+       * @returns Array of help lines
+       */
+      buildHelpLines(boxWidth, useBoxDrawing) {
         if (useBoxDrawing) {
-          helpLines = [
-            colorize("\u250C" + "\u2500".repeat(boxWidth) + "\u2510", "brightBlue"),
-            colorize("\u2502" + centerText("KEYBOARD SHORTCUTS", boxWidth, " ") + "\u2502", "brightBlue"),
-            colorize("\u251C" + "\u2500".repeat(boxWidth) + "\u2524", "brightBlue"),
-            colorize("\u2502  [1-5]       Switch to tab by number" + padRight("", boxWidth - 39) + "\u2502", "white"),
-            colorize("\u2502  [n] / \u2192     Next tab" + padRight("", boxWidth - 25) + "\u2502", "white"),
-            colorize("\u2502  [p] / \u2190     Previous tab" + padRight("", boxWidth - 27) + "\u2502", "white"),
-            colorize("\u2502  [r]         Refresh stats (Utilities)" + padRight("", boxWidth - 36) + "\u2502", "white"),
-            colorize("\u2502  [c]         Clear logs (Utilities)" + padRight("", boxWidth - 33) + "\u2502", "white"),
-            colorize("\u2502  [t]         Toggle engine pause (Utilities)" + padRight("", boxWidth - 42) + "\u2502", "white"),
-            colorize("\u2502  [?] / [h]   Toggle help" + padRight("", boxWidth - 24) + "\u2502", "white"),
-            colorize("\u2502  [q]         Quit" + padRight("", boxWidth - 15) + "\u2502", "white"),
-            colorize("\u2502  [Ctrl+C]    Force quit" + padRight("", boxWidth - 22) + "\u2502", "white"),
-            colorize("\u2514" + "\u2500".repeat(boxWidth) + "\u2518", "brightBlue")
+          const boxRow = (content) => {
+            const padding = Math.max(0, boxWidth - visibleLength(content));
+            return "\u2502" + content + " ".repeat(padding) + "\u2502";
+          };
+          return [
+            "\u250C" + "\u2500".repeat(boxWidth) + "\u2510",
+            boxRow(centerText("KEYBOARD SHORTCUTS", boxWidth, " ")),
+            "\u251C" + "\u2500".repeat(boxWidth) + "\u2524",
+            boxRow("  [1-5]       Switch to tab by number"),
+            boxRow("  [n] / \u2192     Next tab"),
+            boxRow("  [p] / \u2190     Previous tab"),
+            boxRow("  [r]         Refresh stats (Utilities)"),
+            boxRow("  [c]         Clear logs (Utilities)"),
+            boxRow("  [t]         Toggle engine pause (Utilities)"),
+            boxRow("  [\u2191/\u2193/k/j]   Navigate log entries (Logs)"),
+            boxRow("  [Home/End]   First/last log entry (Logs)"),
+            boxRow("  [Enter/Space/e] Expand log (Logs)"),
+            boxRow("  [w]          Toggle word wrap (Logs)"),
+            boxRow("  [?] / [h]   Toggle help"),
+            boxRow("  [q]         Quit"),
+            boxRow("  [Ctrl+C]    Force quit"),
+            "\u2514" + "\u2500".repeat(boxWidth) + "\u2518"
           ];
         } else {
-          const maxLineWidth = cols - 2;
-          helpLines = [
-            visibleTruncate(colorize("KEYBOARD SHORTCUTS", "brightBlue"), maxLineWidth),
-            visibleTruncate(colorize("  [1-5] Switch tab | [n/p] Next/Prev | [q] Quit", "white"), maxLineWidth),
-            visibleTruncate(colorize("  [r] Refresh | [c] Clear logs | [t] Toggle engine", "white"), maxLineWidth),
-            visibleTruncate(colorize("  [?/h] Help | [Ctrl+C] Force quit", "white"), maxLineWidth)
+          return [
+            "KEYBOARD SHORTCUTS",
+            "  [1-5] Switch tab | [n/p] Next/Prev | [q] Quit",
+            "  [\u2191\u2193/k/j] Navigate logs | [Home/End] First/Last (Logs)",
+            "  [Enter/Space/e] Expand log | [w] Toggle wrap (Logs)",
+            "  [r] Refresh | [c] Clear logs | [t] Toggle engine",
+            "  [?/h] Help | [Ctrl+C] Force quit"
           ];
         }
-        const compactBoxWidth = useBoxDrawing ? boxWidth : Math.max(...helpLines.map(visibleLength));
-        const boxHeight = helpLines.length;
+      }
+      renderHelpOverlay() {
+        const cols = process.stdout.columns || 80;
+        const rows = process.stdout.rows || 24;
+        const boxWidth = Math.min(62, Math.max(cols - 4, 20));
+        const useBoxDrawing = cols >= boxWidth + 4;
+        const rawHelpLines = this.buildHelpLines(boxWidth, useBoxDrawing);
+        const compactBoxWidth = useBoxDrawing ? boxWidth : Math.max(...rawHelpLines.map(visibleLength));
+        const boxHeight = rawHelpLines.length;
         const safeStartX = Math.max(1, Math.floor((cols - compactBoxWidth) / 2));
         const safeStartY = Math.max(1, Math.floor((rows - boxHeight) / 2));
         const clearTop = Math.max(1, safeStartY - 1);
@@ -134396,15 +134967,17 @@ var init_dashboard_tui = __esm({
           moveCursorTo(1, y);
           clearLine();
         }
-        for (let i = 0; i < helpLines.length; i++) {
+        for (let i = 0; i < rawHelpLines.length; i++) {
+          const color = i === 0 || i === 2 || i === rawHelpLines.length - 1 ? "brightBlue" : "white";
           moveCursorTo(safeStartX, safeStartY + i);
-          process.stdout.write(helpLines[i]);
+          process.stdout.write(colorize(rawHelpLines[i], color));
         }
       }
     };
     DashboardLogSink = class {
       tui = null;
       isTTY;
+      originalConsole = null;
       constructor(tui) {
         this.tui = tui ?? null;
         this.isTTY = tui?.running ?? false;
@@ -134414,26 +134987,74 @@ var init_dashboard_tui = __esm({
         this.isTTY = true;
       }
       log(message, prefix) {
+        const line = prefix ? `[${prefix}] ${message}` : message;
         if (this.tui && this.isTTY) {
           this.tui.log(message, prefix);
+        } else if (this.originalConsole) {
+          this.originalConsole.log.call(console, line);
         } else {
-          console.log(prefix ? `[${prefix}] ${message}` : message);
+          console.log(line);
         }
       }
       warn(message, prefix) {
+        const line = prefix ? `[${prefix}] ${message}` : message;
         if (this.tui && this.isTTY) {
           this.tui.warn(message, prefix);
+        } else if (this.originalConsole) {
+          this.originalConsole.warn.call(console, line);
         } else {
-          console.warn(prefix ? `[${prefix}] ${message}` : message);
+          console.warn(line);
         }
       }
       error(message, prefix) {
+        const line = prefix ? `[${prefix}] ${message}` : message;
         if (this.tui && this.isTTY) {
           this.tui.error(message, prefix);
+        } else if (this.originalConsole) {
+          this.originalConsole.error.call(console, line);
         } else {
-          console.error(prefix ? `[${prefix}] ${message}` : message);
+          console.error(line);
         }
       }
+      /**
+       * Monkey-patch `console.log/warn/error` so everything (including the engine's
+       * createLogger() output, which writes directly to console.error) surfaces in
+       * the TUI's log ring buffer. Without this, most runtime logs render beneath
+       * the alt-screen TUI and are immediately overwritten on the next render,
+       * leaving the Logs tab nearly empty.
+       *
+       * Messages that start with `[prefix] rest` are unpacked so the TUI stores
+       * `prefix="prefix"` and `message="rest"`. Idempotent; call `releaseConsole()`
+       * on TUI shutdown to restore the originals.
+       */
+      captureConsole() {
+        if (this.originalConsole) return;
+        this.originalConsole = {
+          log: console.log,
+          warn: console.warn,
+          error: console.error
+        };
+        console.log = (...args) => {
+          const { message, prefix } = formatConsoleArgs(args);
+          this.log(message, prefix);
+        };
+        console.warn = (...args) => {
+          const { message, prefix } = formatConsoleArgs(args);
+          this.warn(message, prefix);
+        };
+        console.error = (...args) => {
+          const { message, prefix } = formatConsoleArgs(args);
+          this.error(message, prefix);
+        };
+      }
+      /** Restore console.log/warn/error to their pre-capture implementations. */
+      releaseConsole() {
+        if (!this.originalConsole) return;
+        console.log = this.originalConsole.log;
+        console.warn = this.originalConsole.warn;
+        console.error = this.originalConsole.error;
+        this.originalConsole = null;
+      }
     };
   }
 });
@@ -134441,6 +135062,7 @@ var init_dashboard_tui = __esm({
 // src/commands/dashboard.ts
 var dashboard_exports = {};
 __export(dashboard_exports, {
+  StreamedLogBuffer: () => StreamedLogBuffer,
   promptForPort: () => promptForPort,
   runDashboard: () => runDashboard
 });
@@ -134628,6 +135250,7 @@ async function runDashboard(port, opts = {}) {
     });
     await tui.start();
     logSink.setTUI(tui);
+    logSink.captureConsole();
   }
   store = new TaskStore(cwd);
   await store.init();
@@ -134710,7 +135333,7 @@ async function runDashboard(port, opts = {}) {
     try {
       if (!store) {
         taskSummary = "tasks=unavailable (store not initialized)";
-        console.log(`[dashboard] shutdown requested reason=${reason} pid=${process.pid} ppid=${process.ppid} uptime=${uptimeSeconds}s ${taskSummary}`);
+        logSink.log(`shutdown requested reason=${reason} pid=${process.pid} ppid=${process.ppid} uptime=${uptimeSeconds}s ${taskSummary}`, "dashboard");
         return;
       }
       const tasks = await store.listTasks({ slim: true, includeArchived: false });
@@ -134726,8 +135349,9 @@ async function runDashboard(port, opts = {}) {
       const message = error instanceof Error ? error.message : String(error);
       taskSummary = `tasks=unavailable (${message})`;
     }
-    console.log(
-      `[dashboard] shutdown requested reason=${reason} pid=${process.pid} ppid=${process.ppid} uptime=${uptimeSeconds}s ${taskSummary}`
+    logSink.log(
+      `shutdown requested reason=${reason} pid=${process.pid} ppid=${process.ppid} uptime=${uptimeSeconds}s ${taskSummary}`,
+      "dashboard"
     );
   }
   function registerHandler(target, event, handler) {
@@ -134762,10 +135386,21 @@ async function runDashboard(port, opts = {}) {
     await store.updateSettings({ enginePaused: true });
     logSink.log("Starting in paused mode \u2014 automation disabled", "engine");
   }
-  const onMergeImpl = (taskId) => aiMergeTask(store, cwd, taskId, {
-    agentStore,
-    onAgentText: (delta) => process.stdout.write(delta)
-  });
+  const onMergeImpl = async (taskId) => {
+    const streamedMergeLog = new StreamedLogBuffer(
+      (line) => logSink.log(line, "merge"),
+      STREAM_LOG_FLUSH_IDLE_MS
+    );
+    try {
+      return await aiMergeTask(store, cwd, taskId, {
+        agentStore,
+        onAgentText: (delta) => streamedMergeLog.push(delta)
+      });
+    } finally {
+      streamedMergeLog.flush();
+      streamedMergeLog.dispose();
+    }
+  };
   const onMerge = (taskId) => onMergeImpl(taskId);
   const missionAutopilotImpl = new MissionAutopilot(store, store.getMissionStore());
   const missionExecutionLoopImpl = new MissionExecutionLoop({
@@ -134877,6 +135512,7 @@ async function runDashboard(port, opts = {}) {
       tuiRefreshDebounceTimer = null;
     }
     if (tui) {
+      logSink.releaseConsole();
       void tui.stop();
     }
     for (const { target, event, handler } of handlers) {
@@ -134910,7 +135546,7 @@ async function runDashboard(port, opts = {}) {
       peerExchangeService.start();
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
-      console.warn(`[dashboard] Failed to start peer exchange service: ${message}`);
+      logSink.warn(`Failed to start peer exchange service: ${message}`, "dashboard");
     }
     centralCoreForMesh = centralCoreForEngine;
     let cwdEngine;
@@ -134960,7 +135596,7 @@ async function runDashboard(port, opts = {}) {
           handleTypes[type] = (handleTypes[type] ?? 0) + 1;
         }
         const handleSummary = Object.entries(handleTypes).sort((a, b) => b[1] - a[1]).map(([type, count]) => `${type}:${count}`).join(", ");
-        console.log(`[dashboard] active handles at shutdown: ${handleSummary}`);
+        logSink.log(`active handles at shutdown: ${handleSummary}`, "dashboard");
       } catch {
       }
       await logShutdownDiagnostics(signal);
@@ -134972,7 +135608,7 @@ async function runDashboard(port, opts = {}) {
           await peerExchangeService.stop();
         } catch (err) {
           const message = err instanceof Error ? err.message : String(err);
-          console.warn(`[dashboard] Failed to stop peer exchange service: ${message}`);
+          logSink.warn(`Failed to stop peer exchange service: ${message}`, "dashboard");
         }
       }
       if (centralCoreForMesh && localNodeIdForMesh) {
@@ -134980,13 +135616,13 @@ async function runDashboard(port, opts = {}) {
           centralCoreForMesh.stopDiscovery();
         } catch (err) {
           const message = err instanceof Error ? err.message : String(err);
-          console.warn(`[dashboard] Failed to stop mDNS discovery: ${message}`);
+          logSink.warn(`Failed to stop mDNS discovery: ${message}`, "dashboard");
         }
         try {
           await centralCoreForMesh.updateNode(localNodeIdForMesh, { status: "offline" });
         } catch (err) {
           const message = err instanceof Error ? err.message : String(err);
-          console.warn(`[dashboard] Failed to set local node offline: ${message}`);
+          logSink.warn(`Failed to set local node offline: ${message}`, "dashboard");
         }
       }
       await centralCoreForEngine.close().catch(() => {
@@ -134997,7 +135633,7 @@ async function runDashboard(port, opts = {}) {
     registerHandler(process, "SIGINT", () => void shutdown("SIGINT"));
     registerHandler(process, "SIGTERM", () => void shutdown("SIGTERM"));
     registerHandler(process, "SIGHUP", () => {
-      console.log("[dashboard] Received SIGHUP (terminal disconnected) \u2014 ignoring");
+      logSink.log("Received SIGHUP (terminal disconnected) \u2014 ignoring", "dashboard");
     });
   } else {
     try {
@@ -135007,7 +135643,7 @@ async function runDashboard(port, opts = {}) {
       peerExchangeService.start();
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
-      console.warn(`[dashboard] Failed to initialize mesh networking: ${message}`);
+      logSink.warn(`Failed to initialize mesh networking: ${message}`, "dashboard");
     }
     try {
       heartbeatMonitorImpl = new HeartbeatMonitor({
@@ -135104,7 +135740,7 @@ async function runDashboard(port, opts = {}) {
           handleTypes[type] = (handleTypes[type] ?? 0) + 1;
         }
         const handleSummary = Object.entries(handleTypes).sort((a, b) => b[1] - a[1]).map(([type, count]) => `${type}:${count}`).join(", ");
-        console.log(`[dashboard] active handles at shutdown: ${handleSummary}`);
+        logSink.log(`active handles at shutdown: ${handleSummary}`, "dashboard");
       } catch {
       }
       await logShutdownDiagnostics(signal);
@@ -135117,7 +135753,7 @@ async function runDashboard(port, opts = {}) {
           await peerExchangeService.stop();
         } catch (err) {
           const message = err instanceof Error ? err.message : String(err);
-          console.warn(`[dashboard] Failed to stop peer exchange service: ${message}`);
+          logSink.warn(`Failed to stop peer exchange service: ${message}`, "dashboard");
         }
       }
       if (centralCoreForMesh && localNodeIdForMesh) {
@@ -135125,13 +135761,13 @@ async function runDashboard(port, opts = {}) {
           centralCoreForMesh.stopDiscovery();
         } catch (err) {
           const message = err instanceof Error ? err.message : String(err);
-          console.warn(`[dashboard] Failed to stop mDNS discovery: ${message}`);
+          logSink.warn(`Failed to stop mDNS discovery: ${message}`, "dashboard");
         }
         try {
           await centralCoreForMesh.updateNode(localNodeIdForMesh, { status: "offline" });
         } catch (err) {
           const message = err instanceof Error ? err.message : String(err);
-          console.warn(`[dashboard] Failed to set local node offline: ${message}`);
+          logSink.warn(`Failed to set local node offline: ${message}`, "dashboard");
         }
       }
       if (centralCoreForMesh) {
@@ -135144,7 +135780,7 @@ async function runDashboard(port, opts = {}) {
     registerHandler(process, "SIGINT", () => void devShutdown("SIGINT"));
     registerHandler(process, "SIGTERM", () => void devShutdown("SIGTERM"));
     registerHandler(process, "SIGHUP", () => {
-      console.log("[dashboard] Received SIGHUP (terminal disconnected) \u2014 ignoring");
+      logSink.log("Received SIGHUP (terminal disconnected) \u2014 ignoring", "dashboard");
     });
   }
   const server = app.listen(selectedPort, selectedHost);
@@ -135152,14 +135788,14 @@ async function runDashboard(port, opts = {}) {
     if (err.code === "EADDRINUSE") {
       server.listen(0, selectedHost);
     } else {
-      console.error(`Failed to start server: ${err.message}`);
+      logSink.error(`Failed to start server: ${err.message}`, "dashboard");
       process.exit(1);
     }
   });
   server.on("listening", async () => {
     const actualPort = server.address().port;
     if (actualPort !== selectedPort) {
-      console.log(`\u26A0 Port ${selectedPort} in use, using ${actualPort} instead`);
+      logSink.warn(`Port ${selectedPort} in use, using ${actualPort} instead`, "dashboard");
     }
     if (centralCoreForMesh) {
       try {
@@ -135172,7 +135808,7 @@ async function runDashboard(port, opts = {}) {
         });
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
-        console.warn(`[dashboard] Failed to start mDNS discovery: ${message}`);
+        logSink.warn(`Failed to start mDNS discovery: ${message}`, "dashboard");
       }
     }
     if (centralCoreForMesh) {
@@ -135185,7 +135821,7 @@ async function runDashboard(port, opts = {}) {
         }
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
-        console.warn(`[dashboard] Failed to set local node online: ${message}`);
+        logSink.warn(`Failed to set local node online: ${message}`, "dashboard");
       }
     }
     const displayHost = selectedHost === "0.0.0.0" || selectedHost === "::" ? selectedHost : "localhost";
@@ -135277,7 +135913,7 @@ async function runDashboard(port, opts = {}) {
   });
   return { dispose };
 }
-var processDiagnosticsRegistered, diagnosticIntervalHandle, DIAGNOSTIC_INTERVAL_MS, diagnosticStartTime, diagnosticDbHealthCheck, diagnosticStoreListenerCheck;
+var processDiagnosticsRegistered, diagnosticIntervalHandle, DIAGNOSTIC_INTERVAL_MS, diagnosticStartTime, diagnosticDbHealthCheck, diagnosticStoreListenerCheck, STREAM_LOG_FLUSH_IDLE_MS, StreamedLogBuffer;
 var init_dashboard = __esm({
   "src/commands/dashboard.ts"() {
     "use strict";
@@ -135297,6 +135933,60 @@ var init_dashboard = __esm({
     diagnosticStartTime = 0;
     diagnosticDbHealthCheck = null;
     diagnosticStoreListenerCheck = null;
+    STREAM_LOG_FLUSH_IDLE_MS = 100;
+    StreamedLogBuffer = class {
+      constructor(emitLine, flushIdleMs = STREAM_LOG_FLUSH_IDLE_MS) {
+        this.emitLine = emitLine;
+        this.flushIdleMs = flushIdleMs;
+      }
+      pending = "";
+      flushTimer = null;
+      push(delta) {
+        if (!delta) return;
+        this.pending += delta;
+        this.flushCompletedLines();
+        this.scheduleFlush();
+      }
+      flush() {
+        this.clearFlushTimer();
+        const trailing = this.pending.trim();
+        if (trailing.length > 0) {
+          this.emitLine(trailing);
+        }
+        this.pending = "";
+      }
+      dispose() {
+        this.clearFlushTimer();
+        this.pending = "";
+      }
+      flushCompletedLines() {
+        if (!this.pending.includes("\n")) {
+          return;
+        }
+        const splitLines = this.pending.split(/\r?\n/);
+        const completeLines = splitLines.slice(0, -1);
+        this.pending = splitLines[splitLines.length - 1] ?? "";
+        for (const line of completeLines) {
+          const normalized = line.trim();
+          if (normalized.length > 0) {
+            this.emitLine(normalized);
+          }
+        }
+      }
+      scheduleFlush() {
+        this.clearFlushTimer();
+        this.flushTimer = setTimeout(() => {
+          this.flush();
+        }, this.flushIdleMs);
+        this.flushTimer.unref?.();
+      }
+      clearFlushTimer() {
+        if (this.flushTimer) {
+          clearTimeout(this.flushTimer);
+          this.flushTimer = null;
+        }
+      }
+    };
   }
 });