@runfusion/fusion 0.0.4 → 0.0.6

package/dist/bin.js

@@ -134,6 +134,8 @@ var init_settings_schema = __esm({
       defaultPresetBySize: {},
       autoResolveConflicts: true,
       smartConflictResolution: true,
+      worktreeRebaseBeforeMerge: true,
+      worktreeRebaseRemote: "",
       strictScopeEnforcement: false,
       buildRetryCount: 0,
       verificationFixRetries: 1,
@@ -3510,13 +3512,25 @@ import { mkdir, readFile, writeFile, readdir, unlink, rename } from "node:fs/pro
 import { basename, join as join2, resolve } from "node:path";
 import { randomUUID, randomBytes, createHash } from "node:crypto";
 import { EventEmitter } from "node:events";
-var AgentStore;
+function resolveCreationRuntimeConfig(incoming, metadata) {
+  const isEphemeral = isEphemeralAgent({ metadata });
+  if (isEphemeral) {
+    return incoming;
+  }
+  const rc = { ...incoming ?? {} };
+  if (typeof rc.heartbeatIntervalMs !== "number" || !Number.isFinite(rc.heartbeatIntervalMs)) {
+    rc.heartbeatIntervalMs = DEFAULT_AGENT_HEARTBEAT_INTERVAL_MS;
+  }
+  return rc;
+}
+var DEFAULT_AGENT_HEARTBEAT_INTERVAL_MS, AgentStore;
 var init_agent_store = __esm({
   "../core/src/agent-store.ts"() {
     "use strict";
     init_types();
     init_agent_permissions();
     init_db();
+    DEFAULT_AGENT_HEARTBEAT_INTERVAL_MS = 36e5;
     AgentStore = class extends EventEmitter {
       rootDir;
       agentsDir;
@@ -3655,6 +3669,16 @@ var init_agent_store = __esm({
       }
       /**
        * Create a new agent with "idle" state.
+       *
+       * For non-ephemeral agents, ensures `runtimeConfig.heartbeatIntervalMs` is
+       * persisted at creation time — previously it was only ever written when the
+       * user interacted with the dashboard dropdown, so agents created and never
+       * touched would end up with no interval on disk. That made the dashboard's
+       * freshness check behave inconsistently between agents that had been
+       * configured and agents that hadn't, even though the scheduler applied the
+       * same default (1h) to both at runtime. Writing the default explicitly
+       * removes that divergence and keeps the persisted config truthful.
+       *
        * @param input - Creation parameters
        * @returns The created agent
        * @throws Error if input is invalid
@@ -3668,6 +3692,8 @@ var init_agent_store = __esm({
         }
         const now = (/* @__PURE__ */ new Date()).toISOString();
         const agentId = `agent-${randomUUID().slice(0, 8)}`;
+        const metadata = input.metadata ?? {};
+        const runtimeConfig = resolveCreationRuntimeConfig(input.runtimeConfig, metadata);
         const agent = {
           id: agentId,
           name: input.name.trim(),
@@ -3675,11 +3701,11 @@ var init_agent_store = __esm({
           state: "idle",
           createdAt: now,
           updatedAt: now,
-          metadata: input.metadata ?? {},
+          metadata,
           ...input.title && { title: input.title },
           ...input.icon && { icon: input.icon },
           ...input.reportsTo && { reportsTo: input.reportsTo },
-          ...input.runtimeConfig && { runtimeConfig: input.runtimeConfig },
+          ...runtimeConfig && { runtimeConfig },
           ...input.permissions && { permissions: input.permissions },
           ...input.instructionsPath && { instructionsPath: input.instructionsPath },
           ...input.instructionsText && { instructionsText: input.instructionsText },
@@ -30525,6 +30551,7 @@ ${newTask.description}
             }
           }
           if (updates.steps !== void 0) task.steps = updates.steps;
+          if (updates.currentStep !== void 0) task.currentStep = updates.currentStep;
           if (updates.status === null) {
             task.status = void 0;
           } else if (updates.status !== void 0) {
@@ -47049,6 +47076,7 @@ __export(src_exports, {
   CheckoutConflictError: () => CheckoutConflictError,
   DAEMON_TOKEN_HEX_LENGTH: () => DAEMON_TOKEN_HEX_LENGTH,
   DAEMON_TOKEN_PREFIX: () => DAEMON_TOKEN_PREFIX,
+  DEFAULT_AGENT_HEARTBEAT_INTERVAL_MS: () => DEFAULT_AGENT_HEARTBEAT_INTERVAL_MS,
   DEFAULT_AUTO_SUMMARIZE_SCHEDULE: () => DEFAULT_AUTO_SUMMARIZE_SCHEDULE,
   DEFAULT_EXECUTION_MODE: () => DEFAULT_EXECUTION_MODE,
   DEFAULT_GLOBAL_SETTINGS: () => DEFAULT_GLOBAL_SETTINGS,
@@ -50765,12 +50793,59 @@ var require_lib = __commonJS({
 import { EventEmitter as EventEmitter17 } from "events";
 import * as os2 from "os";
 import * as path from "path";
-import { existsSync as existsSync17 } from "node:fs";
+import { existsSync as existsSync17, chmodSync } from "node:fs";
 import { join as join22, dirname as dirname7 } from "node:path";
-function findStagedNativeDir() {
+function getNativePrebuildName() {
   const platform3 = process.platform === "darwin" ? "darwin" : process.platform === "linux" ? "linux" : process.platform === "win32" ? "win32" : "unknown";
   const arch = process.arch === "arm64" ? "arm64" : process.arch === "x64" ? "x64" : "unknown";
-  const prebuildName = `${platform3}-${arch}`;
+  return `${platform3}-${arch}`;
+}
+function findInstalledNodePtyNativeDir() {
+  try {
+    const packageJsonPath = __require.resolve("node-pty/package.json");
+    const nativeDir = join22(dirname7(packageJsonPath), "prebuilds", getNativePrebuildName());
+    return existsSync17(join22(nativeDir, "pty.node")) ? nativeDir : null;
+  } catch {
+    return null;
+  }
+}
+function ensureNodePtyNativePermissions() {
+  if (process.platform === "win32") {
+    return;
+  }
+  const candidateDirs = /* @__PURE__ */ new Set();
+  const envNativeDir = process.env.NODE_PTY_SPAWN_HELPER_DIR || process.env.FUSION_NATIVE_ASSETS_PATH;
+  if (envNativeDir) {
+    candidateDirs.add(envNativeDir);
+  }
+  const stagedNativeDir = findStagedNativeDir();
+  if (stagedNativeDir) {
+    candidateDirs.add(stagedNativeDir);
+  }
+  const installedNativeDir = findInstalledNodePtyNativeDir();
+  if (installedNativeDir) {
+    candidateDirs.add(installedNativeDir);
+  }
+  for (const nativeDir of candidateDirs) {
+    const helperPath = join22(nativeDir, "spawn-helper");
+    const nativeModulePath = join22(nativeDir, "pty.node");
+    try {
+      if (existsSync17(helperPath)) {
+        chmodSync(helperPath, 493);
+      }
+      if (existsSync17(nativeModulePath)) {
+        chmodSync(nativeModulePath, 493);
+      }
+    } catch (err) {
+      console.warn("[terminal] Failed to repair node-pty native permissions:", {
+        nativeDir,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+}
+function findStagedNativeDir() {
+  const prebuildName = getNativePrebuildName();
   if (process.env.FUSION_RUNTIME_DIR) {
     const envPath = join22(process.env.FUSION_RUNTIME_DIR, prebuildName);
     if (existsSync17(join22(envPath, "pty.node"))) {
@@ -50811,6 +50886,7 @@ async function loadPtyModule() {
     }
   }
   try {
+    ensureNodePtyNativePermissions();
     const mod = await Promise.resolve().then(() => __toESM(require_lib(), 1));
     ptyModule = mod;
     return ptyModule;
@@ -65047,6 +65123,71 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
       mergerLog.warn(`${taskId}: unable to verify/checkout main branch \u2014 proceeding on current HEAD`);
     }
   }
+  if (settings.worktreeRebaseBeforeMerge !== false) {
+    try {
+      let remote = settings.worktreeRebaseRemote?.trim();
+      if (!remote) {
+        try {
+          const { stdout: mainBranchOut } = await execAsync2(
+            "git rev-parse --abbrev-ref HEAD",
+            { cwd: rootDir, encoding: "utf-8" }
+          );
+          const mainBranch = mainBranchOut.trim();
+          const { stdout: configuredRemote } = await execAsync2(
+            `git config --get branch.${mainBranch}.remote`,
+            { cwd: rootDir, encoding: "utf-8" }
+          ).catch(() => ({ stdout: "" }));
+          remote = configuredRemote.trim();
+        } catch {
+        }
+      }
+      if (!remote) {
+        try {
+          const { stdout: remotesOut } = await execAsync2("git remote", {
+            cwd: rootDir,
+            encoding: "utf-8"
+          });
+          const remotes = remotesOut.trim().split(/\s+/).filter(Boolean);
+          if (remotes.length === 1) {
+            remote = remotes[0];
+          } else if (remotes.includes("origin")) {
+            remote = "origin";
+          }
+        } catch {
+        }
+      }
+      if (!remote) {
+        mergerLog.log(`${taskId}: no remote resolvable \u2014 skipping pre-merge rebase`);
+      } else {
+        mergerLog.log(`${taskId}: fetching ${remote} before merge`);
+        await execAsync2(`git fetch "${remote}"`, { cwd: rootDir });
+        try {
+          const { stdout: mainBranchOut } = await execAsync2(
+            "git rev-parse --abbrev-ref HEAD",
+            { cwd: rootDir, encoding: "utf-8" }
+          );
+          const mainBranch = mainBranchOut.trim();
+          const remoteRef = `${remote}/${mainBranch}`;
+          if (worktreePath) {
+            await execAsync2(`git rebase "${remoteRef}"`, { cwd: worktreePath });
+            mergerLog.log(`${taskId}: rebased ${branch} onto ${remoteRef}`);
+          } else {
+            mergerLog.warn(`${taskId}: no worktreePath \u2014 skipping task branch rebase`);
+          }
+        } catch (rebaseErr) {
+          const msg = rebaseErr instanceof Error ? rebaseErr.message : String(rebaseErr);
+          mergerLog.warn(`${taskId}: pre-merge rebase failed (${msg}) \u2014 aborting rebase and falling through to smart/AI merge`);
+          if (worktreePath) {
+            await execAsync2("git rebase --abort", { cwd: worktreePath }).catch(() => {
+            });
+          }
+        }
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      mergerLog.warn(`${taskId}: pre-merge rebase pipeline failed (${msg}) \u2014 proceeding without rebase`);
+    }
+  }
   let commitLog = "";
   let diffStat = "";
   try {
@@ -67563,19 +67704,6 @@ import { existsSync as existsSync26 } from "node:fs";
 import { readFile as readFile16, writeFile as writeFile12 } from "node:fs/promises";
 import { Type as Type4 } from "@mariozechner/pi-ai";
 import { ModelRegistry as ModelRegistry2, SessionManager as SessionManager2 } from "@mariozechner/pi-coding-agent";
-function determineRevisionResetStart(steps, feedback) {
-  const total = steps.length;
-  if (total === 0) return 0;
-  const skipPreflight = /preflight/i.test(steps[0].name);
-  const firstCandidate = skipPreflight ? 1 : 0;
-  if (firstCandidate >= total) return total;
-  const fb = feedback.toLowerCase();
-  for (let i = firstCandidate; i < total; i++) {
-    const tokens = steps[i].name.toLowerCase().match(/[a-z][a-z]{4,}/g) ?? [];
-    if (tokens.some((t) => fb.includes(t))) return i;
-  }
-  return firstCandidate;
-}
 function truncateWorkflowScriptOutput2(output) {
   if (output.length <= WORKFLOW_SCRIPT_OUTPUT_MAX_CHARS2) return output;
   return `... output truncated to last ${WORKFLOW_SCRIPT_OUTPUT_MAX_CHARS2} characters ...
@@ -69892,35 +70020,23 @@ Take a different approach. Do NOT repeat the rejected strategy. Re-read the step
       }
       /**
        * Handle a workflow step revision request.
-       * 
-       * This method:
-       * 1. Updates PROMPT.md with "Workflow Revision Instructions" section
-       * 2. Resets task execution state (all steps reset to pending)
-       * 3. Schedules fresh execution to run after current guard unwinds
-       * 
-       * The task stays in "in-progress" and is scheduled for a fresh executor pass.
+       *
+       * Re-opens ONLY the last step so the executor has exactly one pending slot
+       * to re-enter through. All earlier done steps stay done — the agent reads
+       * the injected feedback from PROMPT.md and applies an in-place fix rather
+       * than redoing any completed step.
        */
       async handleWorkflowRevisionRequest(task, worktreePath, feedback, stepName) {
         executorLog.log(`${task.id}: workflow revision requested by step "${stepName}"`);
         const updatedTask = await this.store.getTask(task.id);
-        const resetStart = determineRevisionResetStart(updatedTask.steps, feedback);
-        const targetStepName = resetStart < updatedTask.steps.length ? updatedTask.steps[resetStart].name : null;
-        const resetSummary = resetStart >= updatedTask.steps.length ? "no steps to reset" : `resetting steps ${resetStart + 1}\u2013${updatedTask.steps.length} (starting at "${targetStepName}")`;
+        const reopen = await this.reopenLastStepForRevision(task.id, updatedTask);
+        const reopenSummary = reopen ? `re-opening Step ${reopen.index + 1} ("${reopen.name}") for in-place fix` : "no step to re-open (none were completed)";
         await this.store.logEntry(
           task.id,
-          `Workflow step "${stepName}" requested revision \u2014 ${resetSummary}`,
+          `Workflow step "${stepName}" requested revision \u2014 ${reopenSummary}`,
           feedback
         );
-        await this.injectWorkflowRevisionInstructions(task, feedback, {
-          resetStart,
-          targetStepName,
-          totalSteps: updatedTask.steps.length
-        });
-        for (let i = resetStart; i < updatedTask.steps.length; i++) {
-          if (updatedTask.steps[i].status !== "pending") {
-            await this.store.updateStep(task.id, i, "pending");
-          }
-        }
+        await this.injectWorkflowRevisionInstructions(task, feedback);
         await this.store.updateTask(task.id, {
           status: null,
           sessionFile: null
@@ -69942,12 +70058,36 @@ Take a different approach. Do NOT repeat the rejected strategy. Re-read the step
           }
         }, 0);
       }
+      /**
+       * Re-open the last non-pending step so a revision/failure handler gives the
+       * executor exactly one pending slot to re-enter through. Returns the index
+       * and name of the step that was flipped to `pending`, or null when there
+       * was nothing to re-open.
+       */
+      async reopenLastStepForRevision(taskId, task) {
+        const steps = task.steps;
+        if (steps.length === 0) return null;
+        let targetIndex = -1;
+        for (let i = steps.length - 1; i >= 0; i--) {
+          if (steps[i].status !== "pending") {
+            targetIndex = i;
+            break;
+          }
+        }
+        if (targetIndex === -1) {
+          await this.store.updateTask(taskId, { currentStep: 0 });
+          return null;
+        }
+        await this.store.updateStep(taskId, targetIndex, "pending");
+        await this.store.updateTask(taskId, { currentStep: targetIndex });
+        return { index: targetIndex, name: steps[targetIndex].name };
+      }
       /**
        * Inject or update the "Workflow Revision Instructions" section in PROMPT.md.
        * This section contains feedback from workflow steps that requested revisions.
        * The section is replaced entirely to avoid accumulation of old feedback.
        */
-      async injectWorkflowRevisionInstructions(task, feedback, scope) {
+      async injectWorkflowRevisionInstructions(task, feedback) {
         const promptPath = join35(this.store.getFusionDir(), "tasks", task.id, "PROMPT.md");
         let content;
         try {
@@ -69956,14 +70096,7 @@ Take a different approach. Do NOT repeat the rejected strategy. Re-read the step
           executorLog.warn(`${task.id}: PROMPT.md not found at ${promptPath}, skipping revision injection`);
           return;
         }
-        let scopeLine;
-        if (scope && scope.targetStepName && scope.resetStart < scope.totalSteps) {
-          scopeLine = `Re-execution starts at **Step ${scope.resetStart + 1} ("${scope.targetStepName}")**. Earlier steps remain done \u2014 do not re-run them unless the feedback explicitly calls them out.`;
-        } else if (scope && scope.resetStart >= scope.totalSteps) {
-          scopeLine = "No steps were reset; apply the feedback as an in-place fix and call task_done() when complete.";
-        } else {
-          scopeLine = "Address the feedback above by making the necessary code changes, then mark all affected steps as done and call task_done() when complete.";
-        }
+        const scopeLine = "All prior steps remain **done**. Apply the feedback above as an in-place fix (make the necessary code changes, commit, and call `task_done()` when complete). Do **not** re-run or re-plan any earlier step unless the feedback explicitly calls it out.";
         const revisionSectionHeader = "## Workflow Revision Instructions";
         const revisionSectionContent = `${revisionSectionHeader}
 
@@ -70022,11 +70155,7 @@ ${feedback}
         });
         await this.injectWorkflowStepFailureInstructions(task, failureFeedback, stepName, retryCount);
         const updatedTask = await this.store.getTask(task.id);
-        for (let i = 0; i < updatedTask.steps.length; i++) {
-          if (updatedTask.steps[i].status !== "pending") {
-            await this.store.updateStep(task.id, i, "pending");
-          }
-        }
+        await this.reopenLastStepForRevision(task.id, updatedTask);
         await this.store.updateTask(task.id, {
           status: null,
           sessionFile: null
@@ -70070,11 +70199,7 @@ Please fix the issues so the verification can pass on the next attempt.`,
         );
         await this.injectWorkflowStepFailureInstructions(task, failureFeedback, stepName, MAX_WORKFLOW_STEP_RETRIES);
         const updatedTask = await this.store.getTask(taskId);
-        for (let i = 0; i < updatedTask.steps.length; i++) {
-          if (updatedTask.steps[i].status !== "pending") {
-            await this.store.updateStep(taskId, i, "pending");
-          }
-        }
+        await this.reopenLastStepForRevision(taskId, updatedTask);
         await this.store.updateTask(taskId, {
           status: null,
           error: null,
@@ -75873,6 +75998,12 @@ async function getHeartbeatMemorySettings(taskStore) {
   }
   return maybeGetSettings.call(taskStore);
 }
+function isTickableState(state) {
+  return state === "active" || state === "running";
+}
+function isHeartbeatManaged(agent) {
+  return !isEphemeralAgent(agent);
+}
 var HEARTBEAT_SYSTEM_PROMPT, HEARTBEAT_NO_TASK_SYSTEM_PROMPT, heartbeatDoneParams, HeartbeatMonitor, HeartbeatTriggerScheduler;
 var init_agent_heartbeat = __esm({
   "../engine/src/agent-heartbeat.ts"() {
@@ -77109,10 +77240,6 @@ ${taskDetail.prompt}` : "No PROMPT.md available.",
        * @param config - Per-agent heartbeat config
        */
       registerAgent(agentId, config) {
-        if (config.enabled === false) {
-          heartbeatLog.log(`Skipping timer registration for ${agentId} (disabled)`);
-          return;
-        }
         let rawIntervalMs = config.heartbeatIntervalMs;
         let usingDefaultInterval = false;
         if (!rawIntervalMs || typeof rawIntervalMs !== "number" || !Number.isFinite(rawIntervalMs) || rawIntervalMs <= 0) {
@@ -77202,8 +77329,8 @@ ${taskDetail.prompt}` : "No PROMPT.md available.",
         this.assignedListener = async (agent, taskId) => {
           if (!this.running) return;
           try {
-            if (agent.runtimeConfig?.enabled === false) {
-              heartbeatLog.log(`Assignment trigger skipped for ${agent.id} (heartbeat disabled)`);
+            if (!isHeartbeatManaged(agent) || !isTickableState(agent.state)) {
+              heartbeatLog.log(`Assignment trigger skipped for ${agent.id} (state=${agent.state})`);
               return;
             }
             const activeRun = await this.store.getActiveHeartbeatRun(agent.id);
@@ -77272,9 +77399,21 @@ ${taskDetail.prompt}` : "No PROMPT.md available.",
       watchAgentLifecycle() {
         if (this.updatedListener || this.deletedListener) return;
         this.updatedListener = (agent) => {
-          if (agent.state === "terminated" || agent.runtimeConfig?.enabled === false) {
+          if (!isHeartbeatManaged(agent) || !isTickableState(agent.state)) {
             this.unregisterAgent(agent.id);
+            return;
+          }
+          if (this.timers.has(agent.id)) {
+            return;
           }
+          const rc = agent.runtimeConfig ?? {};
+          this.registerAgent(agent.id, {
+            heartbeatIntervalMs: rc.heartbeatIntervalMs,
+            maxConcurrentRuns: rc.maxConcurrentRuns
+          });
+          heartbeatLog.log(
+            `State-driven registration: ${agent.id} is ${agent.state} \u2014 timer armed`
+          );
         };
         this.deletedListener = (agentId) => {
           this.unregisterAgent(agentId);
@@ -77305,8 +77444,8 @@ ${taskDetail.prompt}` : "No PROMPT.md available.",
             this.unregisterAgent(agentId);
             return;
           }
-          if (agent.state === "terminated" || agent.runtimeConfig?.enabled === false) {
-            heartbeatLog.log(`Timer tick skipped for ${agentId} (disabled or terminated)`);
+          if (!isHeartbeatManaged(agent) || !isTickableState(agent.state)) {
+            heartbeatLog.log(`Timer tick skipped for ${agentId} (state=${agent.state})`);
             this.unregisterAgent(agentId);
             return;
           }
@@ -79511,13 +79650,13 @@ var init_in_process_runtime = __esm({
               this.taskStore
             );
             this.triggerScheduler.start();
+            const isTickable = (agent) => !isEphemeralAgent(agent) && (agent.state === "active" || agent.state === "running");
             this.agentCreatedListener = (agent) => {
               if (!this.triggerScheduler) return;
+              if (!isTickable(agent)) return;
               const rc = agent.runtimeConfig;
-              if (rc?.enabled === false) return;
               this.triggerScheduler.registerAgent(agent.id, {
                 heartbeatIntervalMs: rc?.heartbeatIntervalMs,
-                enabled: rc?.enabled,
                 maxConcurrentRuns: rc?.maxConcurrentRuns
               });
               runtimeLog.log(`Registered new agent ${agent.id} for heartbeat triggers`);
@@ -79525,18 +79664,17 @@ var init_in_process_runtime = __esm({
             this.agentStore.on("agent:created", this.agentCreatedListener);
             this.agentUpdatedListener = (agent) => {
               if (!this.triggerScheduler) return;
-              const rc = agent.runtimeConfig;
-              if (rc?.enabled === false) {
+              if (!isTickable(agent)) {
                 this.triggerScheduler.unregisterAgent(agent.id);
-                runtimeLog.log(`Unregistered agent ${agent.id} from heartbeat triggers (disabled)`);
-              } else {
-                this.triggerScheduler.registerAgent(agent.id, {
-                  heartbeatIntervalMs: rc?.heartbeatIntervalMs,
-                  enabled: rc?.enabled,
-                  maxConcurrentRuns: rc?.maxConcurrentRuns
-                });
-                runtimeLog.log(`Re-registered agent ${agent.id} for heartbeat triggers`);
+                runtimeLog.log(`Unregistered agent ${agent.id} from heartbeat triggers (state=${agent.state})`);
+                return;
               }
+              const rc = agent.runtimeConfig;
+              this.triggerScheduler.registerAgent(agent.id, {
+                heartbeatIntervalMs: rc?.heartbeatIntervalMs,
+                maxConcurrentRuns: rc?.maxConcurrentRuns
+              });
+              runtimeLog.log(`Re-registered agent ${agent.id} for heartbeat triggers (state=${agent.state})`);
             };
             this.agentStore.on("agent:updated", this.agentUpdatedListener);
             this.ephemeralTerminationListener = (agentId, from, to) => {
@@ -79571,15 +79709,13 @@ var init_in_process_runtime = __esm({
               const agents = await this.agentStore.listAgents();
               let registeredCount = 0;
               for (const agent of agents) {
+                if (!isTickable(agent)) continue;
                 const rc = agent.runtimeConfig;
-                if (rc?.enabled !== false) {
-                  this.triggerScheduler.registerAgent(agent.id, {
-                    heartbeatIntervalMs: rc?.heartbeatIntervalMs,
-                    enabled: rc?.enabled,
-                    maxConcurrentRuns: rc?.maxConcurrentRuns
-                  });
-                  registeredCount++;
-                }
+                this.triggerScheduler.registerAgent(agent.id, {
+                  heartbeatIntervalMs: rc?.heartbeatIntervalMs,
+                  maxConcurrentRuns: rc?.maxConcurrentRuns
+                });
+                registeredCount++;
               }
               if (agents.length > 0) {
                 runtimeLog.log(`Registered ${registeredCount} of ${agents.length} agents for heartbeat triggers`);
@@ -121443,6 +121579,34 @@ Description: ${step.description}`
       rethrowAsApiError3(err);
     }
   });
+  const TERMINAL_TASK_STATUSES = /* @__PURE__ */ new Set(["done", "archived"]);
+  function isTerminalTaskStatus(status) {
+    return status !== void 0 && TERMINAL_TASK_STATUSES.has(status);
+  }
+  async function sanitizeAgentTaskLinks(agents, scopedStore) {
+    const taskIds = [...new Set(agents.map((a) => a.taskId).filter((id) => id !== void 0))];
+    const taskStatusMap = /* @__PURE__ */ new Map();
+    await Promise.all(
+      taskIds.map(async (taskId) => {
+        try {
+          const task = await scopedStore.getTask(taskId);
+          if (task) {
+            taskStatusMap.set(taskId, task.column);
+          }
+        } catch {
+        }
+      })
+    );
+    return agents.map((agent) => {
+      if (!agent.taskId) return agent;
+      const taskStatus = taskStatusMap.get(agent.taskId);
+      if (isTerminalTaskStatus(taskStatus)) {
+        const { taskId: _omitted, ...sanitized } = agent;
+        return sanitized;
+      }
+      return agent;
+    });
+  }
   router.get("/agents", async (req, res) => {
     try {
       const filter2 = {};
@@ -121460,7 +121624,8 @@ Description: ${step.description}`
       const agentStore = new AgentStore2({ rootDir: scopedStore.getFusionDir() });
       await agentStore.init();
       const agents = await agentStore.listAgents(filter2);
-      res.json(agents);
+      const sanitizedAgents = await sanitizeAgentTaskLinks(agents, scopedStore);
+      res.json(sanitizedAgents);
     } catch (err) {
       if (err instanceof ApiError) {
         throw err;
@@ -122155,7 +122320,8 @@ ${body}`;
       await agentStore.init();
       const agents = await agentStore.listAgents();
       const activeCount = agents.filter((a) => a.state === "active" || a.state === "running").length;
-      const assignedTaskCount = agents.filter((a) => a.taskId).length;
+      const sanitizedAgents = await sanitizeAgentTaskLinks(agents, scopedStore);
+      const assignedTaskCount = sanitizedAgents.filter((a) => a.taskId).length;
       let completedRuns = 0;
       let failedRuns = 0;
       for (const agent of agents) {
@@ -122217,7 +122383,8 @@ ${body}`;
       if (!agent) {
         throw notFound("Agent not found");
       }
-      res.json(agent);
+      const [sanitizedAgent] = await sanitizeAgentTaskLinks([agent], scopedStore);
+      res.json(sanitizedAgent);
     } catch (err) {
       if (err instanceof ApiError) {
         throw err;
@@ -131552,6 +131719,9 @@ function isApiPath(path4) {
   return path4 === "/api" || path4.startsWith("/api/");
 }
 function getDaemonToken(options) {
+  if (options?.noAuth) {
+    return void 0;
+  }
   if (options?.daemon?.token) {
     return options.daemon.token;
   }
@@ -131775,7 +131945,7 @@ function createServer(store, options) {
       }
     }
   }));
-  const daemonToken = options?.daemon?.token ?? process.env.FUSION_DAEMON_TOKEN;
+  const daemonToken = options?.noAuth ? void 0 : options?.daemon?.token ?? process.env.FUSION_DAEMON_TOKEN;
   if (daemonToken) {
     app.use(createAuthMiddleware(daemonToken));
   }
@@ -133928,7 +134098,8 @@ async function runDashboard(port, opts = {}) {
       onProjectFirstAccessed: (projectId) => engineManager.onProjectAccessed(projectId),
       skillsAdapter,
       https: loadTlsCredentialsFromEnv(),
-      daemon: dashboardAuthToken ? { token: dashboardAuthToken } : void 0
+      daemon: dashboardAuthToken ? { token: dashboardAuthToken } : void 0,
+      noAuth: opts.noAuth
     });
     const shutdown = async (signal) => {
       if (shutdownInProgress) return;
@@ -134023,14 +134194,13 @@ async function runDashboard(port, opts = {}) {
       triggerScheduler.start();
       const agents = await agentStore.listAgents();
       for (const agent of agents) {
+        if (isEphemeralAgent(agent)) continue;
+        if (agent.state !== "active" && agent.state !== "running") continue;
         const rc = agent.runtimeConfig;
-        if (rc && (rc.heartbeatIntervalMs || rc.enabled !== void 0 || rc.maxConcurrentRuns)) {
-          triggerScheduler.registerAgent(agent.id, {
-            heartbeatIntervalMs: rc.heartbeatIntervalMs,
-            enabled: rc.enabled,
-            maxConcurrentRuns: rc.maxConcurrentRuns
-          });
-        }
+        triggerScheduler.registerAgent(agent.id, {
+          heartbeatIntervalMs: rc?.heartbeatIntervalMs,
+          maxConcurrentRuns: rc?.maxConcurrentRuns
+        });
       }
       if (agents.length > 0) {
         console.log(`[engine] Registered ${triggerScheduler.getRegisteredAgents().length} agents for heartbeat triggers`);
@@ -134069,7 +134239,8 @@ async function runDashboard(port, opts = {}) {
       pluginRunner: pluginLoader,
       skillsAdapter,
       https: loadTlsCredentialsFromEnv(),
-      daemon: dashboardAuthToken ? { token: dashboardAuthToken } : void 0
+      daemon: dashboardAuthToken ? { token: dashboardAuthToken } : void 0,
+      noAuth: opts.noAuth
     });
   }
   if (opts.dev) {