@runfusion/fusion 0.0.6 → 0.1.1

package/dist/extension.js

@@ -137,7 +137,7 @@ var init_settings_schema = __esm({
       worktreeRebaseRemote: "",
       strictScopeEnforcement: false,
       buildRetryCount: 0,
-      verificationFixRetries: 1,
+      verificationFixRetries: 3,
       buildTimeoutMs: 3e5,
       requirePlanApproval: false,
       specStalenessEnabled: false,
@@ -1974,6 +1974,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();
@@ -2494,6 +2506,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)) {
@@ -2506,6 +2519,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
@@ -2815,6 +2838,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,
@@ -3224,6 +3250,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, '')" : "''";
@@ -3517,6 +3546,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;
   }
@@ -3562,6 +3594,7 @@ var init_agent_store = __esm({
         const _ = 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
@@ -3666,6 +3699,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.
        *
@@ -5775,11 +5853,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,
@@ -5795,7 +5874,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,
@@ -5823,18 +5903,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) {
@@ -5875,15 +5963,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() {
@@ -12196,6 +12317,9 @@ var init_migration = __esm({
        * @returns Generated name
        */
       async generateProjectName(projectPath) {
+        if (!existsSync7(join9(projectPath, ".git"))) {
+          return basename3(projectPath);
+        }
         try {
           const { execFile: execFile4 } = await import("node:child_process");
           const { promisify: promisify11 } = await import("node:util");
@@ -12203,7 +12327,7 @@ var init_migration = __esm({
           const { stdout } = await execFileAsync2(
             "git",
             ["remote", "get-url", "origin"],
-            { cwd: projectPath, timeout: 5e3 }
+            { cwd: projectPath, timeout: 1e3 }
           );
           const remoteUrl = stdout.trim();
           if (remoteUrl) {
@@ -28697,6 +28821,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";
@@ -28745,7 +28890,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";
@@ -28763,11 +28908,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;
@@ -29477,45 +29624,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) => {
@@ -29533,21 +29688,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)
           });
         });
       }
@@ -30069,7 +30238,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;
@@ -30087,13 +30260,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;
@@ -30360,26 +30546,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) {
@@ -30388,7 +30594,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;
       }
@@ -31524,9 +31730,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();
@@ -31582,9 +31796,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;
         }
@@ -32839,7 +33061,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;
       }
@@ -33821,27 +34051,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";
@@ -47406,13 +47615,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);
     }
   };
 }
@@ -48730,7 +48939,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}`);
       }
@@ -48800,7 +49008,7 @@ import { join as join24 } 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 || homedir5();
+  return globalThis.process.env.HOME || globalThis.process.env.USERPROFILE || homedir5();
 }
 function getFusionAuthPath(home = getHomeDir2()) {
   return join24(home, ".fusion", "agent", "auth.json");
@@ -48846,7 +49054,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) {
@@ -49149,8 +49357,8 @@ function createReadOnlyPiSettingsView(cwd, agentDir) {
   const fusionProjectSettings = readJsonObject2(join25(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
   };
 }
@@ -49269,9 +49477,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 = relative3(projectRoot, pathArg);
@@ -53586,7 +53792,7 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
     } catch (error) {
       if (error.name === "VerificationError") {
         const verificationErr = error;
-        const maxFixRetries = Math.min(settings.verificationFixRetries ?? 1, 3);
+        const maxFixRetries = Math.min(settings.verificationFixRetries ?? 3, 3);
         if (maxFixRetries > 0 && (verificationErr.verificationResult.testResult || verificationErr.verificationResult.buildResult)) {
           mergerLog.log(`${taskId}: deterministic verification failed \u2014 attempting in-merge fix (up to ${maxFixRetries} attempts)`);
           await store.logEntry(taskId, `Verification failed during merge \u2014 attempting in-merge fix (up to ${maxFixRetries} attempts)`);
@@ -53631,7 +53837,7 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
         throw error;
       }
       if (error.message?.includes("Build verification failed")) {
-        const maxFixRetries = Math.min(settings.verificationFixRetries ?? 1, 3);
+        const maxFixRetries = Math.min(settings.verificationFixRetries ?? 3, 3);
         if (maxFixRetries > 0 && (effectiveTestCommand || effectiveBuildCommand)) {
           mergerLog.log(`${taskId}: build verification failed \u2014 attempting in-merge fix`);
           await store.logEntry(taskId, `Build verification failed during merge \u2014 attempting in-merge fix`);
@@ -55430,6 +55636,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((resolve17) => setTimeout(resolve17, ms));
 }
@@ -55622,8 +55858,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 createFnAgent2({
                 cwd: worktreePath,
                 systemPrompt: `You are an AI agent executing step ${stepIndex} of task ${taskDetail.id}. Follow instructions precisely.`,
@@ -56057,6 +56296,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();
@@ -56213,7 +56482,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";
@@ -56246,6 +56515,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 {
     };
@@ -56533,8 +56804,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);
@@ -57441,8 +57715,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;
@@ -57624,63 +57901,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: retrySession, 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: retrySession, 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 = retrySession;
-                sessionRef.current = retrySession;
-                this.activeSessions.set(task.id, {
-                  session: retrySession,
-                  seenSteeringIds,
-                  lastModelProvider: detail.modelProvider,
-                  lastModelId: detail.modelId
-                });
-                stuckDetector?.trackTask(task.id, retrySession);
-                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(retrySession, retryPrompt);
-                checkSessionError(retrySession);
-                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 = retrySession;
+                  sessionRef.current = retrySession;
+                  this.activeSessions.set(task.id, {
+                    session: retrySession,
+                    seenSteeringIds,
+                    lastModelProvider: detail.modelProvider,
+                    lastModelId: detail.modelId
+                  });
+                  stuckDetector?.trackTask(task.id, retrySession);
+                  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(retrySession, retryPrompt);
+                  checkSessionError(retrySession);
+                  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) {
@@ -57709,11 +57997,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));
                 }
               }
@@ -64299,7 +64605,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);
@@ -65629,8 +65935,13 @@ ${taskDetail.prompt}` : "No PROMPT.md available.",
         this.assignedListener = async (agent, taskId) => {
           if (!this.running) return;
           try {
-            if (!isHeartbeatManaged(agent) || !isTickableState(agent.state)) {
-              heartbeatLog.log(`Assignment trigger skipped for ${agent.id} (state=${agent.state})`);
+            if (!isHeartbeatManaged(agent)) {
+              heartbeatLog.log(`Assignment trigger skipped for ${agent.id} (ephemeral/internal)`);
+              return;
+            }
+            const runtimeConfig = agent.runtimeConfig ?? {};
+            if (runtimeConfig.enabled === false) {
+              heartbeatLog.log(`Assignment trigger skipped for ${agent.id} (disabled)`);
               return;
             }
             const activeRun = await this.store.getActiveHeartbeatRun(agent.id);
@@ -66089,6 +66400,10 @@ var init_self_healing = __esm({
           const result = await readLog("HEAD");
           stdout = result.stdout;
         }
+        if (!stdout.trim() && task.baseCommitSha) {
+          const result = await readLog("HEAD");
+          stdout = result.stdout;
+        }
         const firstLine = stdout.trim().split("\n").find(Boolean);
         if (!firstLine) return null;
         const [sha, subject] = firstLine.split("");
@@ -67950,10 +68265,10 @@ var init_in_process_runtime = __esm({
               this.taskStore
             );
             this.triggerScheduler.start();
-            const isTickable = (agent) => !isEphemeralAgent(agent) && (agent.state === "active" || agent.state === "running");
+            const isHeartbeatEnabledAgent = (agent) => !isEphemeralAgent(agent) && agent.runtimeConfig?.enabled !== false;
             this.agentCreatedListener = (agent) => {
               if (!this.triggerScheduler) return;
-              if (!isTickable(agent)) return;
+              if (!isHeartbeatEnabledAgent(agent)) return;
               const rc = agent.runtimeConfig;
               this.triggerScheduler.registerAgent(agent.id, {
                 heartbeatIntervalMs: rc?.heartbeatIntervalMs,
@@ -67964,9 +68279,9 @@ var init_in_process_runtime = __esm({
             this.agentStore.on("agent:created", this.agentCreatedListener);
             this.agentUpdatedListener = (agent) => {
               if (!this.triggerScheduler) return;
-              if (!isTickable(agent)) {
+              if (!isHeartbeatEnabledAgent(agent)) {
                 this.triggerScheduler.unregisterAgent(agent.id);
-                runtimeLog.log(`Unregistered agent ${agent.id} from heartbeat triggers (state=${agent.state})`);
+                runtimeLog.log(`Unregistered agent ${agent.id} from heartbeat triggers`);
                 return;
               }
               const rc = agent.runtimeConfig;
@@ -67974,7 +68289,7 @@ var init_in_process_runtime = __esm({
                 heartbeatIntervalMs: rc?.heartbeatIntervalMs,
                 maxConcurrentRuns: rc?.maxConcurrentRuns
               });
-              runtimeLog.log(`Re-registered agent ${agent.id} for heartbeat triggers (state=${agent.state})`);
+              runtimeLog.log(`Re-registered agent ${agent.id} for heartbeat triggers`);
             };
             this.agentStore.on("agent:updated", this.agentUpdatedListener);
             this.ephemeralTerminationListener = (agentId, from, to) => {
@@ -68009,7 +68324,7 @@ var init_in_process_runtime = __esm({
               const agents = await this.agentStore.listAgents();
               let registeredCount = 0;
               for (const agent of agents) {
-                if (!isTickable(agent)) continue;
+                if (!isHeartbeatEnabledAgent(agent)) continue;
                 const rc = agent.runtimeConfig;
                 this.triggerScheduler.registerAgent(agent.id, {
                   heartbeatIntervalMs: rc?.heartbeatIntervalMs,
@@ -72458,11 +72773,13 @@ var init_terminal = __esm({
 });
 
 // ../dashboard/src/terminal-service.ts
-var isBunBinary;
+import { createRequire } from "node:module";
+var isBunBinary, require2;
 var init_terminal_service = __esm({
   "../dashboard/src/terminal-service.ts"() {
     "use strict";
     isBunBinary = typeof Bun !== "undefined" && !!Bun.embeddedFiles;
+    require2 = createRequire(import.meta.url);
   }
 });