@runfusion/fusion 0.7.1 → 0.8.1

package/dist/extension.js

@@ -37,7 +37,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // ../core/src/settings-schema.ts
 function isGlobalSettingsKey(key) {
@@ -61,8 +60,13 @@ var init_settings_schema = __esm({
       ntfyEnabled: false,
       ntfyTopic: void 0,
       ntfyBaseUrl: void 0,
-      ntfyEvents: ["in-review", "merged", "failed", "awaiting-approval", "awaiting-user-review", "planning-awaiting-input"],
+      ntfyEvents: ["in-review", "merged", "failed", "awaiting-approval", "awaiting-user-review", "planning-awaiting-input", "gridlock"],
       ntfyDashboardHost: void 0,
+      webhookEnabled: false,
+      webhookUrl: void 0,
+      webhookFormat: "generic",
+      webhookEvents: [],
+      notificationProviders: [],
       defaultProjectId: void 0,
       setupComplete: void 0,
       favoriteProviders: void 0,
@@ -115,6 +119,7 @@ var init_settings_schema = __esm({
       pushAfterMerge: false,
       pushRemote: "origin",
       unavailableNodePolicy: "block",
+      defaultNodeId: void 0,
       worktreeInitCommand: void 0,
       testCommand: void 0,
       buildCommand: void 0,
@@ -145,6 +150,9 @@ var init_settings_schema = __esm({
       smartConflictResolution: true,
       worktreeRebaseBeforeMerge: true,
       worktreeRebaseRemote: "",
+      worktreeRebaseLocalBase: true,
+      mergeConflictStrategy: "smart-prefer-main",
+      workflowStepTimeoutMs: 36e4,
       strictScopeEnforcement: false,
       buildRetryCount: 0,
       verificationFixRetries: 3,
@@ -210,7 +218,7 @@ var init_settings_schema = __esm({
           },
           cloudflare: {
             enabled: false,
-            quickTunnel: false,
+            quickTunnel: true,
             tunnelName: "",
             tunnelToken: null,
             ingressUrl: ""
@@ -728,7 +736,132 @@ var init_error_message = __esm({
   }
 });
 
+// ../core/src/model-resolution.ts
+function hasCompleteModelPair(pair) {
+  return Boolean(pair?.provider && pair?.modelId);
+}
+function pickFirstModelPair(...pairs) {
+  for (const pair of pairs) {
+    if (hasCompleteModelPair(pair)) {
+      return { provider: pair.provider, modelId: pair.modelId };
+    }
+  }
+  return {};
+}
+function resolveProjectDefaultModel(settings) {
+  return pickFirstModelPair(
+    {
+      provider: settings?.defaultProviderOverride,
+      modelId: settings?.defaultModelIdOverride
+    },
+    {
+      provider: settings?.defaultProvider,
+      modelId: settings?.defaultModelId
+    }
+  );
+}
+function resolveExecutionSettingsModel(settings) {
+  return pickFirstModelPair(
+    {
+      provider: settings?.executionProvider,
+      modelId: settings?.executionModelId
+    },
+    {
+      provider: settings?.executionGlobalProvider,
+      modelId: settings?.executionGlobalModelId
+    },
+    resolveProjectDefaultModel(settings)
+  );
+}
+function resolvePlanningSettingsModel(settings) {
+  return pickFirstModelPair(
+    {
+      provider: settings?.planningProvider,
+      modelId: settings?.planningModelId
+    },
+    {
+      provider: settings?.planningGlobalProvider,
+      modelId: settings?.planningGlobalModelId
+    },
+    resolveProjectDefaultModel(settings)
+  );
+}
+function resolveValidatorSettingsModel(settings) {
+  return pickFirstModelPair(
+    {
+      provider: settings?.validatorProvider,
+      modelId: settings?.validatorModelId
+    },
+    {
+      provider: settings?.validatorGlobalProvider,
+      modelId: settings?.validatorGlobalModelId
+    },
+    resolveProjectDefaultModel(settings)
+  );
+}
+function resolveTitleSummarizerSettingsModel(settings) {
+  return pickFirstModelPair(
+    {
+      provider: settings?.titleSummarizerProvider,
+      modelId: settings?.titleSummarizerModelId
+    },
+    {
+      provider: settings?.titleSummarizerGlobalProvider,
+      modelId: settings?.titleSummarizerGlobalModelId
+    },
+    {
+      provider: settings?.planningProvider,
+      modelId: settings?.planningModelId
+    },
+    resolveProjectDefaultModel(settings)
+  );
+}
+function resolveTaskExecutionModel(task, settings) {
+  return pickFirstModelPair(
+    {
+      provider: task.modelProvider,
+      modelId: task.modelId
+    },
+    resolveExecutionSettingsModel(settings)
+  );
+}
+function resolveTaskValidatorModel(task, settings) {
+  return pickFirstModelPair(
+    {
+      provider: task.validatorModelProvider,
+      modelId: task.validatorModelId
+    },
+    resolveValidatorSettingsModel(settings)
+  );
+}
+function resolveTaskPlanningModel(task, settings) {
+  return pickFirstModelPair(
+    {
+      provider: task.planningModelProvider,
+      modelId: task.planningModelId
+    },
+    resolvePlanningSettingsModel(settings)
+  );
+}
+var init_model_resolution = __esm({
+  "../core/src/model-resolution.ts"() {
+    "use strict";
+  }
+});
+
 // ../core/src/types.ts
+function normalizeMergeConflictStrategy(value) {
+  switch (value) {
+    case "smart":
+      return "smart-prefer-branch";
+    case "prefer-main":
+      return "smart-prefer-main";
+    case void 0:
+      return "smart-prefer-main";
+    default:
+      return value;
+  }
+}
 function validateDocumentKey(key) {
   if (!DOCUMENT_KEY_RE.test(key)) {
     throw new Error(
@@ -812,13 +945,14 @@ function validateMessageMetadata(metadata) {
     throw new Error("metadata.replyTo.messageId must be a non-empty string");
   }
 }
-var THINKING_LEVELS, COLUMNS, TASK_PRIORITIES, DEFAULT_TASK_PRIORITY, EXECUTION_MODES, DEFAULT_EXECUTION_MODE, THEME_MODES, COLOR_THEMES, WORKFLOW_STEP_TEMPLATES, DOCUMENT_KEY_RE, CheckoutConflictError, COLUMN_LABELS, COLUMN_DESCRIPTIONS, VALID_TRANSITIONS, AGENT_VALID_TRANSITIONS, AGENT_PERMISSIONS;
+var THINKING_LEVELS, COLUMNS, TASK_PRIORITIES, DEFAULT_TASK_PRIORITY, EXECUTION_MODES, DEFAULT_EXECUTION_MODE, THEME_MODES, COLOR_THEMES, NOTIFICATION_EVENTS, WORKFLOW_STEP_TEMPLATES, DOCUMENT_KEY_RE, CheckoutConflictError, COLUMN_LABELS, COLUMN_DESCRIPTIONS, VALID_TRANSITIONS, AGENT_VALID_TRANSITIONS, AGENT_PERMISSIONS;
 var init_types = __esm({
   "../core/src/types.ts"() {
     "use strict";
     init_settings_schema();
     init_prompt_overrides();
     init_error_message();
+    init_model_resolution();
     THINKING_LEVELS = ["off", "minimal", "low", "medium", "high"];
     COLUMNS = ["triage", "todo", "in-progress", "in-review", "done", "archived"];
     TASK_PRIORITIES = ["low", "normal", "high", "urgent"];
@@ -882,6 +1016,15 @@ var init_types = __esm({
       "neon-bloom",
       "sepia"
     ];
+    NOTIFICATION_EVENTS = [
+      "in-review",
+      "merged",
+      "failed",
+      "awaiting-approval",
+      "awaiting-user-review",
+      "planning-awaiting-input",
+      "gridlock"
+    ];
     WORKFLOW_STEP_TEMPLATES = [
       {
         id: "documentation-review",
@@ -2289,7 +2432,7 @@ var init_db = __esm({
     "use strict";
     init_sqlite_adapter();
     init_types();
-    SCHEMA_VERSION = 49;
+    SCHEMA_VERSION = 51;
     SCHEMA_SQL = `
 -- Tasks table with JSON columns for nested data
 CREATE TABLE IF NOT EXISTS tasks (
@@ -2823,6 +2966,74 @@ CREATE INDEX IF NOT EXISTS idxTodoItemsSortOrder ON todo_items(listId, sortOrder
       get fts5Available() {
         return this._fts5Available;
       }
+      /**
+       * Rebuild the task FTS5 index and maintenance triggers from scratch.
+       * Returns false when FTS5 is unavailable in this runtime.
+       */
+      rebuildFts5Index() {
+        if (!this._fts5Available) {
+          return false;
+        }
+        try {
+          this.db.exec("DROP TRIGGER IF EXISTS tasks_fts_ai");
+          this.db.exec("DROP TRIGGER IF EXISTS tasks_fts_au");
+          this.db.exec("DROP TRIGGER IF EXISTS tasks_fts_ad");
+          this.db.exec("DROP TABLE IF EXISTS tasks_fts");
+          this.db.exec(`
+        CREATE VIRTUAL TABLE IF NOT EXISTS tasks_fts USING fts5(
+          id,
+          title,
+          description,
+          comments,
+          content='tasks',
+          content_rowid='rowid'
+        )
+      `);
+          this.db.exec(`
+        CREATE TRIGGER IF NOT EXISTS tasks_fts_ai AFTER INSERT ON tasks BEGIN
+          INSERT INTO tasks_fts(rowid, id, title, description, comments)
+          VALUES (new.rowid, new.id, COALESCE(new.title, ''), new.description, COALESCE(new.comments, '[]'));
+        END
+      `);
+          const hasTaskTitle = this.hasColumn("tasks", "title");
+          const updateColumns = hasTaskTitle ? "id, title, description, comments" : "id, description, comments";
+          const oldTitle = hasTaskTitle ? "COALESCE(old.title, '')" : "''";
+          const newTitle = hasTaskTitle ? "COALESCE(new.title, '')" : "''";
+          this.db.exec(`
+        CREATE TRIGGER IF NOT EXISTS tasks_fts_au AFTER UPDATE OF ${updateColumns} ON tasks BEGIN
+          INSERT INTO tasks_fts(tasks_fts, rowid, id, title, description, comments)
+            VALUES('delete', old.rowid, old.id, ${oldTitle}, old.description, COALESCE(old.comments, '[]'));
+          INSERT INTO tasks_fts(rowid, id, title, description, comments)
+            VALUES (new.rowid, new.id, ${newTitle}, new.description, COALESCE(new.comments, '[]'));
+        END
+      `);
+          this.db.exec(`
+        CREATE TRIGGER IF NOT EXISTS tasks_fts_ad AFTER DELETE ON tasks BEGIN
+          INSERT INTO tasks_fts(tasks_fts, rowid, id, title, description, comments)
+            VALUES('delete', old.rowid, old.id, COALESCE(old.title, ''), old.description, COALESCE(old.comments, '[]'));
+        END
+      `);
+          this.db.exec("INSERT INTO tasks_fts(tasks_fts) VALUES('rebuild')");
+          return true;
+        } catch (error) {
+          console.warn("[fusion:db] Failed to rebuild FTS5 index", error);
+          throw error;
+        }
+      }
+      /**
+       * Run FTS5 integrity check. Returns true when healthy or unavailable.
+       */
+      checkFts5Integrity() {
+        if (!this._fts5Available) {
+          return true;
+        }
+        try {
+          this.db.exec("INSERT INTO tasks_fts(tasks_fts) VALUES('integrity-check')");
+          return true;
+        } catch {
+          return false;
+        }
+      }
       /**
        * Initialize the database: create tables if they don't exist
        * and seed meta values.
@@ -3748,6 +3959,19 @@ CREATE INDEX IF NOT EXISTS idxTodoItemsSortOrder ON todo_items(listId, sortOrder
             this.addColumnIfMissing("tasks", "nodeId", "TEXT");
           });
         }
+        if (version < 50) {
+          this.applyMigration(50, () => {
+            this.addColumnIfMissing("tasks", "effectiveNodeId", "TEXT");
+            this.addColumnIfMissing("tasks", "effectiveNodeSource", "TEXT");
+          });
+        }
+        if (version < 51) {
+          this.applyMigration(51, () => {
+            if (this.hasTable("chat_messages")) {
+              this.addColumnIfMissing("chat_messages", "attachments", "TEXT");
+            }
+          });
+        }
       }
       /**
        * Run a single migration step inside a transaction and bump the version.
@@ -3763,6 +3987,14 @@ CREATE INDEX IF NOT EXISTS idxTodoItemsSortOrder ON todo_items(listId, sortOrder
         const row = this.db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?").get(table);
         return Boolean(row);
       }
+      /**
+       * Check whether an error appears to be an FTS5 corruption/integrity failure.
+       */
+      isFts5CorruptionError(error) {
+        const message = error instanceof Error ? error.message : String(error ?? "");
+        const lower = message.toLowerCase();
+        return lower.includes("corruption found reading blob") || lower.includes("database disk image is malformed") || lower.includes("fts5") && lower.includes("corrupt");
+      }
       /**
        * Check whether a table has a given column.
        */
@@ -18238,10 +18470,31 @@ var init_task_merge = __esm({
     "use strict";
     BLOCKING_TASK_STATUSES = /* @__PURE__ */ new Set([
       "failed",
+      // ── User-attention / awaiting-handoff states ─────────────────────────
       "awaiting-inspection",
       "awaiting-user-review",
+      "awaiting-approval",
+      // triage spec awaiting user approval
+      // ── Active merge in-flight ───────────────────────────────────────────
       "merging",
-      "merging-pr"
+      "merging-pr",
+      // ── Re-planning / triage states (scope not finalized) ────────────────
+      // A task in planning/triage hasn't finalized its scope yet — letting it
+      // merge skips the work the user moved it back to plan. Same for the legacy
+      // "specifying" alias migrated to "planning" in db.ts.
+      "planning",
+      "specifying",
+      "needs-replan",
+      // scheduler/executor/triage signaled re-plan
+      // ── Mission-level validation in flight ───────────────────────────────
+      "mission-validation",
+      // ── Scheduler-side transient state ───────────────────────────────────
+      "queued",
+      // scheduler placed the task in line; not finalized
+      // ── Abnormal termination — defensive guard ───────────────────────────
+      // Task was killed by the stuck detector. If it surfaces in in-review,
+      // it needs investigation, not auto-merge.
+      "stuck-killed"
     ]);
     NON_TERMINAL_STEP_STATUSES = /* @__PURE__ */ new Set([
       "pending",
@@ -29462,6 +29715,26 @@ var init_logger = __esm({
   }
 });
 
+// ../core/src/node-override-guard.ts
+function validateNodeOverrideChange(task, newNodeId) {
+  if (newNodeId === void 0) {
+    return { allowed: true };
+  }
+  if (task.column === "in-progress") {
+    return {
+      allowed: false,
+      reason: "task-in-progress",
+      message: `Cannot change node override for ${task.id} while it is in progress. The task is currently executing and routing cannot be changed mid-flight. Wait for the task to complete, or pause/stop it first before changing the node assignment.`
+    };
+  }
+  return { allowed: true };
+}
+var init_node_override_guard = __esm({
+  "../core/src/node-override-guard.ts"() {
+    "use strict";
+  }
+});
+
 // ../core/src/store.ts
 import { EventEmitter as EventEmitter12 } from "node:events";
 import { randomUUID as randomUUID6 } from "node:crypto";
@@ -29549,6 +29822,7 @@ var init_store = __esm({
     init_project_memory();
     init_run_command();
     init_logger();
+    init_node_override_guard();
     TASK_ACTIVITY_LOG_ENTRY_LIMIT = 1e3;
     TASK_ACTIVITY_LOG_OUTCOME_LIMIT = 4e3;
     ARCHIVE_AGENT_LOG_SNAPSHOT_LIMIT = 25;
@@ -29835,6 +30109,8 @@ var init_store = __esm({
           assignedAgentId: row.assignedAgentId || void 0,
           assigneeUserId: row.assigneeUserId || void 0,
           nodeId: row.nodeId || void 0,
+          effectiveNodeId: row.effectiveNodeId || void 0,
+          effectiveNodeSource: row.effectiveNodeSource || void 0,
           checkedOutBy: row.checkedOutBy || void 0,
           checkedOutAt: row.checkedOutAt || void 0
         };
@@ -30083,6 +30359,8 @@ ${recentText}` : void 0
           "assignedAgentId",
           "assigneeUserId",
           "nodeId",
+          "effectiveNodeId",
+          "effectiveNodeSource",
           "checkedOutBy",
           "checkedOutAt",
           // `log` is fetched in slim mode so the server can aggregate
@@ -30183,6 +30461,8 @@ ${outcome}`;
           "assignedAgentId",
           "assigneeUserId",
           "nodeId",
+          "effectiveNodeId",
+          "effectiveNodeSource",
           "checkedOutBy",
           "checkedOutAt"
         ];
@@ -30221,9 +30501,9 @@ ${outcome}`;
         dependencies, steps, log, attachments, steeringComments,
         comments, workflowStepResults, prInfo, issueInfo,
         sourceIssueProvider, sourceIssueRepository, sourceIssueExternalIssueId, sourceIssueNumber, sourceIssueUrl,
-        mergeDetails, breakIntoSubtasks, enabledWorkflowSteps, modifiedFiles, missionId, sliceId, assignedAgentId, assigneeUserId, nodeId, checkedOutBy, checkedOutAt
+        mergeDetails, breakIntoSubtasks, enabledWorkflowSteps, modifiedFiles, missionId, sliceId, assignedAgentId, assigneeUserId, nodeId, effectiveNodeId, effectiveNodeSource, checkedOutBy, checkedOutAt
       ) VALUES (
-        ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
+        ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
       )
       ON CONFLICT(id) DO UPDATE SET
         title = excluded.title,
@@ -30291,6 +30571,8 @@ ${outcome}`;
         assignedAgentId = excluded.assignedAgentId,
         assigneeUserId = excluded.assigneeUserId,
         nodeId = excluded.nodeId,
+        effectiveNodeId = excluded.effectiveNodeId,
+        effectiveNodeSource = excluded.effectiveNodeSource,
         checkedOutBy = excluded.checkedOutBy,
         checkedOutAt = excluded.checkedOutAt
     `).run(
@@ -30360,11 +30642,36 @@ ${outcome}`;
           task.assignedAgentId ?? null,
           task.assigneeUserId ?? null,
           task.nodeId ?? null,
+          task.effectiveNodeId ?? null,
+          task.effectiveNodeSource ?? null,
           task.checkedOutBy ?? null,
           task.checkedOutAt ?? null
         );
         this.db.bumpLastModified();
       }
+      upsertTaskWithFtsRecovery(task) {
+        try {
+          this.upsertTask(task);
+          return;
+        } catch (error) {
+          if (!this.db.isFts5CorruptionError(error)) {
+            throw error;
+          }
+          console.warn(`[fusion:store] FTS5 corruption detected during upsert for task ${task.id}; rebuilding index and retrying once`);
+          try {
+            this.db.rebuildFts5Index();
+          } catch (rebuildError) {
+            console.warn("[fusion:store] FTS5 rebuild failed; propagating original upsert error", rebuildError);
+            throw error;
+          }
+          try {
+            this.upsertTask(task);
+          } catch (retryError) {
+            console.warn("[fusion:store] Upsert retry after FTS5 rebuild failed; propagating original upsert error", retryError);
+            throw error;
+          }
+        }
+      }
       /**
        * Read a task from SQLite by ID.
        */
@@ -30583,7 +30890,7 @@ ${outcome}`;
        * for backward compatibility and debugging.
        */
       async atomicWriteTaskJson(dir, task) {
-        this.upsertTask(task);
+        this.upsertTaskWithFtsRecovery(task);
         await this.writeTaskJsonFile(dir, task);
       }
       /**
@@ -30596,7 +30903,7 @@ ${outcome}`;
        */
       async atomicWriteTaskJsonWithAudit(dir, task, auditInput) {
         this.db.transaction(() => {
-          this.upsertTask(task);
+          this.upsertTaskWithFtsRecovery(task);
           if (auditInput) {
             const eventId = randomUUID6();
             const timestamp = auditInput.timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
@@ -31544,6 +31851,14 @@ ${newTask.description}
           if (fromColumn === "in-review" && (toColumn === "todo" || toColumn === "in-progress") || fromColumn === "done" && (toColumn === "todo" || toColumn === "triage")) {
             task.workflowStepResults = void 0;
           }
+          if (fromColumn === "in-review" && toColumn === "todo") {
+            task.branch = void 0;
+            task.baseBranch = void 0;
+            task.baseCommitSha = void 0;
+            task.summary = void 0;
+            task.recoveryRetryCount = void 0;
+            task.nextRecoveryAt = void 0;
+          }
           await this.atomicWriteTaskJson(dir, task);
           if (this.isWatching) this.taskCache.set(id, { ...task });
           this.emit("task:moved", { task, from: fromColumn, to: toColumn });
@@ -31557,6 +31872,12 @@ ${newTask.description}
           }
           const dir = this.taskDir(id);
           const task = await this.readTaskJson(dir);
+          if (updates.nodeId !== void 0) {
+            const validation = validateNodeOverrideChange(task, updates.nodeId ?? null);
+            if (!validation.allowed) {
+              throw new Error(validation.message);
+            }
+          }
           if (!task.log) {
             task.log = [];
           }
@@ -31619,6 +31940,16 @@ ${newTask.description}
           } else if (updates.nodeId !== void 0) {
             task.nodeId = updates.nodeId;
           }
+          if (updates.effectiveNodeId === null) {
+            task.effectiveNodeId = void 0;
+          } else if (updates.effectiveNodeId !== void 0) {
+            task.effectiveNodeId = updates.effectiveNodeId;
+          }
+          if (updates.effectiveNodeSource === null) {
+            task.effectiveNodeSource = void 0;
+          } else if (updates.effectiveNodeSource !== void 0) {
+            task.effectiveNodeSource = updates.effectiveNodeSource;
+          }
           if (updates.checkedOutBy === null) {
             task.checkedOutBy = void 0;
             task.checkedOutAt = void 0;
@@ -33852,7 +34183,7 @@ ${stepsSection}`;
       healthCheck() {
         try {
           this.db.prepare("SELECT 1").get();
-          return true;
+          return this.db.checkFts5Integrity();
         } catch {
           return false;
         }
@@ -34474,6 +34805,10 @@ var init_board = __esm({
 
 // ../core/src/gh-cli.ts
 import { execFileSync, execFile as execFile2 } from "node:child_process";
+function normalizeRunGhOptions(opts) {
+  if (typeof opts === "string") return { cwd: opts };
+  return opts ?? {};
+}
 function isGhAvailable() {
   try {
     execFileSync("gh", ["--version"], {
@@ -34513,19 +34848,55 @@ function runGh(args, cwd) {
     throw error;
   }
 }
-function runGhAsync(args, cwd) {
+function runGhAsync(args, cwdOrOptions) {
+  const { cwd, signal: externalSignal, timeoutMs = DEFAULT_GH_TIMEOUT_MS } = normalizeRunGhOptions(cwdOrOptions);
   return new Promise((resolve17, reject) => {
+    if (externalSignal?.aborted) {
+      reject(makeGhError(`gh command aborted: ${describeAbortReason(externalSignal.reason)}`, "ABORT_ERR"));
+      return;
+    }
+    const controller = new AbortController();
+    let timedOut = false;
+    let externalAborted = false;
+    const onExternalAbort = () => {
+      externalAborted = true;
+      controller.abort();
+    };
+    if (externalSignal) {
+      externalSignal.addEventListener("abort", onExternalAbort, { once: true });
+    }
+    const timer = timeoutMs > 0 ? setTimeout(() => {
+      timedOut = true;
+      controller.abort();
+    }, timeoutMs) : void 0;
+    const cleanup = () => {
+      if (timer) clearTimeout(timer);
+      if (externalSignal) externalSignal.removeEventListener("abort", onExternalAbort);
+    };
     execFile2(
       "gh",
       args,
       {
         encoding: "utf-8",
-        cwd
+        cwd,
+        signal: controller.signal
       },
       (error, stdout, stderr) => {
+        cleanup();
         if (error) {
-          const ghError = new Error(`gh command failed: ${error.message}`);
-          ghError.code = error.code ?? null;
+          const isAbort = error.code === "ABORT_ERR" || error.name === "AbortError";
+          let message;
+          if (timedOut) {
+            message = `gh command timed out after ${timeoutMs}ms`;
+          } else if (isAbort && externalAborted) {
+            message = `gh command aborted: ${describeAbortReason(externalSignal?.reason)}`;
+          } else if (isAbort) {
+            message = "gh command aborted";
+          } else {
+            message = `gh command failed: ${error.message}`;
+          }
+          const ghError = new Error(message);
+          ghError.code = error.code ?? (isAbort ? "ABORT_ERR" : null);
           ghError.stdout = stdout ?? "";
           ghError.stderr = stderr ?? "";
           reject(ghError);
@@ -34536,6 +34907,18 @@ function runGhAsync(args, cwd) {
     );
   });
 }
+function makeGhError(message, code) {
+  const err = new Error(message);
+  err.code = code;
+  err.stdout = "";
+  err.stderr = "";
+  return err;
+}
+function describeAbortReason(reason) {
+  if (reason instanceof Error) return reason.message;
+  if (typeof reason === "string") return reason;
+  return "aborted";
+}
 function runGhJson(args, cwd) {
   const jsonArgs = args.includes("--json") ? args : [...args, "--json"];
   const output = runGh(jsonArgs, cwd);
@@ -34545,9 +34928,9 @@ function runGhJson(args, cwd) {
     throw new Error(`Failed to parse gh JSON output: ${err instanceof Error ? err.message : String(err)}`);
   }
 }
-async function runGhJsonAsync(args, cwd) {
+async function runGhJsonAsync(args, cwdOrOptions) {
   const jsonArgs = args.includes("--json") ? args : [...args, "--json"];
-  const output = await runGhAsync(jsonArgs, cwd);
+  const output = await runGhAsync(jsonArgs, cwdOrOptions);
   try {
     return JSON.parse(output);
   } catch (err) {
@@ -34605,9 +34988,11 @@ function getCurrentRepo(cwd) {
     return null;
   }
 }
+var DEFAULT_GH_TIMEOUT_MS;
 var init_gh_cli = __esm({
   "../core/src/gh-cli.ts"() {
     "use strict";
+    DEFAULT_GH_TIMEOUT_MS = 3e4;
   }
 });
 
@@ -35071,6 +35456,83 @@ var init_routine_store = __esm({
   }
 });
 
+// ../core/src/notification/dispatcher.ts
+var NotificationDispatcher;
+var init_dispatcher = __esm({
+  "../core/src/notification/dispatcher.ts"() {
+    "use strict";
+    NotificationDispatcher = class {
+      constructor(config = {}) {
+        this.config = config;
+      }
+      providers = /* @__PURE__ */ new Map();
+      registerProvider(provider) {
+        this.providers.set(provider.getProviderId(), provider);
+      }
+      unregisterProvider(providerId) {
+        this.providers.delete(providerId);
+      }
+      getProviders() {
+        return [...this.providers.values()];
+      }
+      async dispatch(event, payload) {
+        const providers = this.getProviders().filter(
+          (provider) => provider.isEventSupported(event)
+        );
+        const results = await Promise.all(
+          providers.map(async (provider) => {
+            const providerId = provider.getProviderId();
+            try {
+              return await provider.sendNotification(event, payload);
+            } catch (error) {
+              const message = error instanceof Error ? error.message : String(error);
+              console.warn(
+                `[notification-dispatcher] Provider ${providerId} failed for event ${event}: ${message}`
+              );
+              return { success: false, providerId, error: message };
+            }
+          })
+        );
+        return results;
+      }
+      async initializeAll() {
+        await Promise.all(
+          this.getProviders().map(async (provider) => {
+            if (!provider.initialize) {
+              return;
+            }
+            try {
+              await provider.initialize(this.config);
+            } catch (error) {
+              const message = error instanceof Error ? error.message : String(error);
+              console.warn(
+                `[notification-dispatcher] Provider ${provider.getProviderId()} initialization failed: ${message}`
+              );
+            }
+          })
+        );
+      }
+      async shutdownAll() {
+        await Promise.all(
+          this.getProviders().map(async (provider) => {
+            if (!provider.shutdown) {
+              return;
+            }
+            try {
+              await provider.shutdown();
+            } catch (error) {
+              const message = error instanceof Error ? error.message : String(error);
+              console.warn(
+                `[notification-dispatcher] Provider ${provider.getProviderId()} shutdown failed: ${message}`
+              );
+            }
+          })
+        );
+      }
+    };
+  }
+});
+
 // ../core/src/plugin-loader.ts
 import { basename as basename6, dirname as dirname5, extname, isAbsolute as isAbsolute5, resolve as resolve7 } from "node:path";
 import { copyFile, rm } from "node:fs/promises";
@@ -48046,6 +48508,7 @@ var init_chat_store = __esm({
           content: row.content,
           thinkingOutput: row.thinkingOutput ?? null,
           metadata: fromJson(row.metadata) ?? null,
+          attachments: fromJson(row.attachments) ?? void 0,
           createdAt: row.createdAt
         };
       }
@@ -48264,11 +48727,12 @@ var init_chat_store = __esm({
           content: input.content,
           thinkingOutput: input.thinkingOutput ?? null,
           metadata: input.metadata ?? null,
+          attachments: input.attachments,
           createdAt: now
         };
         this.db.prepare(`
-      INSERT INTO chat_messages (id, sessionId, role, content, thinkingOutput, metadata, createdAt)
-      VALUES (?, ?, ?, ?, ?, ?, ?)
+      INSERT INTO chat_messages (id, sessionId, role, content, thinkingOutput, metadata, attachments, createdAt)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
     `).run(
           message.id,
           message.sessionId,
@@ -48276,6 +48740,7 @@ var init_chat_store = __esm({
           message.content,
           message.thinkingOutput,
           toJsonNullable(message.metadata),
+          toJsonNullable(message.attachments),
           message.createdAt
         );
         this.db.prepare("UPDATE chat_sessions SET updatedAt = ? WHERE id = ?").run(now, sessionId);
@@ -48283,6 +48748,28 @@ var init_chat_store = __esm({
         this.emit("chat:message:added", message);
         return message;
       }
+      /**
+       * Append a file attachment metadata record to an existing message.
+       */
+      addMessageAttachment(sessionId, messageId, attachment) {
+        const message = this.getMessage(messageId);
+        if (!message || message.sessionId !== sessionId) {
+          throw new Error(`Message ${messageId} not found in session ${sessionId}`);
+        }
+        const updatedAttachments = [...message.attachments ?? [], attachment];
+        this.db.prepare(`
+      UPDATE chat_messages
+      SET attachments = ?
+      WHERE id = ?
+    `).run(toJsonNullable(updatedAttachments), messageId);
+        const updated = this.getMessage(messageId);
+        if (!updated) {
+          throw new Error(`Failed to update message ${messageId}`);
+        }
+        this.db.bumpLastModified();
+        this.emit("chat:message:updated", updated);
+        return updated;
+      }
       /**
        * Get messages for a chat session with optional filtering.
        *
@@ -48447,8 +48934,10 @@ __export(src_exports, {
   MessageStore: () => MessageStore,
   MigrationCoordinator: () => MigrationCoordinator,
   MissionStore: () => MissionStore,
+  NOTIFICATION_EVENTS: () => NOTIFICATION_EVENTS,
   NodeConnection: () => NodeConnection,
   NodeDiscovery: () => NodeDiscovery,
+  NotificationDispatcher: () => NotificationDispatcher,
   PROJECT_SETTINGS_KEYS: () => PROJECT_SETTINGS_KEYS,
   PROMPT_KEY_CATALOG: () => PROMPT_KEY_CATALOG,
   PluginLoader: () => PluginLoader,
@@ -48596,6 +49085,7 @@ __export(src_exports, {
   mergeInsights: () => mergeInsights,
   migrateFromLegacy: () => migrateFromLegacy,
   moveRoadmapFeature: () => moveRoadmapFeature,
+  normalizeMergeConflictStrategy: () => normalizeMergeConflictStrategy,
   normalizePermissions: () => normalizePermissions,
   normalizeRoadmapFeatureOrder: () => normalizeRoadmapFeatureOrder,
   normalizeRoadmapMilestoneOrder: () => normalizeRoadmapMilestoneOrder,
@@ -48635,12 +49125,20 @@ __export(src_exports, {
   renderMemoryAuditMarkdown: () => renderMemoryAuditMarkdown,
   resolveAgentPrompt: () => resolveAgentPrompt,
   resolveDependencyOrder: () => resolveDependencyOrder,
+  resolveExecutionSettingsModel: () => resolveExecutionSettingsModel,
   resolveGlobalDir: () => resolveGlobalDir,
   resolveMemoryBackend: () => resolveMemoryBackend,
   resolveMemoryInstructionContext: () => resolveMemoryInstructionContext,
   resolvePiExtensionProjectRoot: () => resolvePiExtensionProjectRoot,
+  resolvePlanningSettingsModel: () => resolvePlanningSettingsModel,
+  resolveProjectDefaultModel: () => resolveProjectDefaultModel,
   resolvePrompt: () => resolvePrompt,
   resolveRolePrompts: () => resolveRolePrompts,
+  resolveTaskExecutionModel: () => resolveTaskExecutionModel,
+  resolveTaskPlanningModel: () => resolveTaskPlanningModel,
+  resolveTaskValidatorModel: () => resolveTaskValidatorModel,
+  resolveTitleSummarizerSettingsModel: () => resolveTitleSummarizerSettingsModel,
+  resolveValidatorSettingsModel: () => resolveValidatorSettingsModel,
   runBackupCommand: () => runBackupCommand,
   runCommandAsync: () => runCommandAsync,
   runGh: () => runGh,
@@ -48670,6 +49168,7 @@ __export(src_exports, {
   validateDescription: () => validateDescription,
   validateImportData: () => validateImportData,
   validateMessageMetadata: () => validateMessageMetadata,
+  validateNodeOverrideChange: () => validateNodeOverrideChange,
   validatePluginManifest: () => validatePluginManifest,
   validateUnavailableNodePolicy: () => validateUnavailableNodePolicy,
   writeAgentMemoryFile: () => writeAgentMemoryFile,
@@ -48704,15 +49203,19 @@ var init_src = __esm({
     init_automation();
     init_automation_store();
     init_run_command();
+    init_node_override_guard();
     init_settings_validation();
     init_routine();
     init_routine_store();
+    init_dispatcher();
+    init_types();
     init_plugin_types();
     init_plugin_store();
     init_plugin_loader();
     init_backup();
     init_settings_export();
     init_ai_summarize();
+    init_model_resolution();
     init_memory_compaction();
     init_roadmap_ordering();
     init_task_priority();
@@ -50291,17 +50794,6 @@ var init_auth_storage = __esm({
 });
 
 // ../engine/src/pi.ts
-var pi_exports = {};
-__export(pi_exports, {
-  COMPACTION_FALLBACK_INSTRUCTIONS: () => COMPACTION_FALLBACK_INSTRUCTIONS,
-  compactSessionContext: () => compactSessionContext,
-  createFnAgent: () => createFnAgent2,
-  describeModel: () => describeModel,
-  getHostExtensionPaths: () => getHostExtensionPaths,
-  promptWithFallback: () => promptWithFallback,
-  setHostExtensionPaths: () => setHostExtensionPaths,
-  wrapToolsWithBoundary: () => wrapToolsWithBoundary
-});
 import { existsSync as existsSync20, readFileSync as readFileSync6 } from "node:fs";
 import { exec } from "node:child_process";
 import { promisify as promisify2 } from "node:util";
@@ -51225,16 +51717,14 @@ function wrapPluginRuntime(instance, runtimeId, runtimeName) {
       if (typeof adapter.promptWithFallback === "function") {
         return adapter.promptWithFallback(session, prompt, options);
       }
-      const { promptWithFallback: pwf } = await Promise.resolve().then(() => (init_pi(), pi_exports));
-      return pwf(session, prompt, options);
+      return promptWithFallback(session, prompt, options);
     },
     describeModel: (session) => {
       const adapter = instance;
       if (typeof adapter.describeModel === "function") {
         return adapter.describeModel(session);
       }
-      const { describeModel: dm } = (init_pi(), __toCommonJS(pi_exports));
-      return dm(session);
+      return describeModel(session);
     }
   };
 }
@@ -51305,36 +51795,19 @@ var init_runtime_resolution = __esm({
   "../engine/src/runtime-resolution.ts"() {
     "use strict";
     init_logger2();
+    init_pi();
     runtimeLog2 = createLogger2("runtime-resolver");
-    DefaultPiRuntime = class _DefaultPiRuntime {
+    DefaultPiRuntime = class {
       id = "pi";
       name = "Default PI Runtime";
-      // Synchronous cached describeModel function
-      static describeModelFn = null;
-      /**
-       * Create an agent session using the default pi implementation.
-       */
       async createSession(options) {
-        const { createFnAgent: createFnAgent5 } = await Promise.resolve().then(() => (init_pi(), pi_exports));
-        return createFnAgent5(options);
+        return createFnAgent2(options);
       }
-      /**
-       * Prompt with automatic retry and compaction.
-       * Delegates to the existing promptWithFallback implementation.
-       */
       async promptWithFallback(session, prompt, options) {
-        const { promptWithFallback: pwf } = await Promise.resolve().then(() => (init_pi(), pi_exports));
-        return pwf(session, prompt, options);
+        return promptWithFallback(session, prompt, options);
       }
-      /**
-       * Get model description from session.
-       */
       describeModel(session) {
-        if (!_DefaultPiRuntime.describeModelFn) {
-          const { describeModel: describeModel2 } = (init_pi(), __toCommonJS(pi_exports));
-          _DefaultPiRuntime.describeModelFn = describeModel2;
-        }
-        return _DefaultPiRuntime.describeModelFn(session);
+        return describeModel(session);
       }
     };
     defaultPiRuntimeInstance = null;
@@ -51378,12 +51851,10 @@ async function createResolvedAgentSession(options) {
   };
 }
 async function promptWithAutoRetry(session, prompt, options) {
-  const { promptWithFallback: pwf } = await Promise.resolve().then(() => (init_pi(), pi_exports));
-  return pwf(session, prompt, options);
+  return promptWithFallback(session, prompt, options);
 }
 async function describeAgentModel(session) {
-  const { describeModel: dm } = await Promise.resolve().then(() => (init_pi(), pi_exports));
-  return dm(session);
+  return describeModel(session);
 }
 var sessionLog;
 var init_agent_session_helpers = __esm({
@@ -51391,6 +51862,7 @@ var init_agent_session_helpers = __esm({
     "use strict";
     init_runtime_resolution();
     init_logger2();
+    init_pi();
     sessionLog = createLogger2("agent-session");
   }
 });
@@ -54967,21 +55439,31 @@ ${failureContext.output.slice(0, VERIFICATION_LOG_MAX_CHARS)}
     return false;
   }
 }
-async function amendMergeCommitWithFixes(rootDir, taskId, authorArg) {
+function resetMergeWithWarn(rootDir, taskId, label) {
+  try {
+    execSync("git reset --merge", { cwd: rootDir, stdio: "pipe" });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    mergerLog.warn(`${taskId}: git reset --merge cleanup failed during ${label}: ${msg}`);
+  }
+}
+function buildDeterministicMergeMessage(params) {
+  const { taskId, branch, commitLog, includeTaskId } = params;
+  const prefix = includeTaskId ? `feat(${taskId})` : "feat";
+  const subject = `${prefix}: merge ${branch}`;
+  const body = commitLog && commitLog.trim().length > 0 ? commitLog.trim() : `- merge ${branch}`;
+  const escape = (s) => s.replace(/(["\\$`])/g, "\\$1");
+  return {
+    subjectArg: `-m "${escape(subject)}"`,
+    bodyArg: `-m "${escape(body)}"`
+  };
+}
+async function commitOrAmendMergeWithFixes(rootDir, taskId, branch, commitLog, includeTaskId, preAttemptHeadSha, authorArg) {
   try {
-    const { stdout: stagedFiles } = await execAsync2("git diff --cached --name-only", {
-      cwd: rootDir,
-      encoding: "utf-8"
-    });
     const { stdout: unstagedFiles } = await execAsync2("git diff --name-only", {
       cwd: rootDir,
       encoding: "utf-8"
     });
-    const hasChanges = stagedFiles.trim().length > 0 || unstagedFiles.trim().length > 0;
-    if (!hasChanges) {
-      mergerLog.log(`${taskId}: no changes to amend after verification fix`);
-      return false;
-    }
     if (unstagedFiles.trim().length > 0) {
       await execAsync2("git add -A", { cwd: rootDir });
     }
@@ -54989,12 +55471,10 @@ async function amendMergeCommitWithFixes(rootDir, taskId, authorArg) {
       cwd: rootDir,
       encoding: "utf-8"
     });
-    const gitlinkPaths = [];
     for (const line of staged.split("\n")) {
       const match = line.match(/^:\d{6} 160000 [^\t]+\t(.+)$/);
-      if (match) gitlinkPaths.push(match[1]);
-    }
-    for (const path2 of gitlinkPaths) {
+      if (!match) continue;
+      const path2 = match[1];
       mergerLog.warn(`${taskId}: refusing to stage gitlink "${path2}" (project uses no submodules \u2014 likely a nested worktree). Unstaging.`);
       try {
         await execAsync2(`git reset HEAD -- "${path2}"`, { cwd: rootDir });
@@ -55007,15 +55487,43 @@ async function amendMergeCommitWithFixes(rootDir, taskId, authorArg) {
       cwd: rootDir,
       encoding: "utf-8"
     });
-    if (finalStaged.trim().length > 0) {
-      await execAsync2(`git commit --amend --no-edit${authorArg}`, { cwd: rootDir });
-      mergerLog.log(`${taskId}: amended merge commit with verification fixes`);
+    const hasStaged = finalStaged.trim().length > 0;
+    const { stdout: currentHeadOut } = await execAsync2("git rev-parse HEAD", {
+      cwd: rootDir,
+      encoding: "utf-8"
+    });
+    const currentHead = currentHeadOut.trim();
+    const headMoved = currentHead !== preAttemptHeadSha;
+    if (!hasStaged && !headMoved) {
+      mergerLog.warn(
+        `${taskId}: refusing to record merge \u2014 no commit was created and no changes are staged. This usually means the AI agent never ran git commit and the in-merge fix had nothing to add.`
+      );
+      return false;
+    }
+    const { subjectArg, bodyArg } = buildDeterministicMergeMessage({
+      taskId,
+      branch,
+      commitLog,
+      includeTaskId
+    });
+    const trailerArg = buildTaskIdTrailerArg(taskId);
+    if (!headMoved) {
+      await execAsync2(
+        `git commit ${subjectArg} ${bodyArg}${trailerArg}${authorArg}`,
+        { cwd: rootDir }
+      );
+      mergerLog.log(`${taskId}: created fresh merge commit after verification fix (no prior commit to amend)`);
       return true;
     }
-    return false;
+    await execAsync2(
+      `git commit --amend ${subjectArg} ${bodyArg}${trailerArg}${authorArg}`,
+      { cwd: rootDir }
+    );
+    mergerLog.log(`${taskId}: amended merge commit with verification fixes (deterministic message)`);
+    return true;
   } catch (err) {
     const errorMessage = err instanceof Error ? err.message : String(err);
-    mergerLog.warn(`${taskId}: failed to amend merge commit: ${errorMessage}`);
+    mergerLog.warn(`${taskId}: failed to finalize merge commit: ${errorMessage}`);
     return false;
   }
 }
@@ -55114,24 +55622,26 @@ async function resolveTaskDiffBaseRef({
   baseBranch,
   baseCommitSha
 }) {
-  const resolvedBaseBranch = baseBranch?.trim() || "main";
+  const resolvedBaseBranch = baseBranch?.trim() || (baseCommitSha ? void 0 : "main");
   const quotedHeadRef = quoteArg(headRef);
   let mergeBase;
-  try {
+  if (resolvedBaseBranch) {
     try {
-      const { stdout } = await execAsync2(`git merge-base ${quotedHeadRef} ${quoteArg(resolvedBaseBranch)}`, {
-        cwd,
-        encoding: "utf-8"
-      });
-      mergeBase = stdout.trim() || void 0;
+      try {
+        const { stdout } = await execAsync2(`git merge-base ${quotedHeadRef} ${quoteArg(resolvedBaseBranch)}`, {
+          cwd,
+          encoding: "utf-8"
+        });
+        mergeBase = stdout.trim() || void 0;
+      } catch {
+        const { stdout } = await execAsync2(`git merge-base ${quotedHeadRef} ${quoteArg(`origin/${resolvedBaseBranch}`)}`, {
+          cwd,
+          encoding: "utf-8"
+        });
+        mergeBase = stdout.trim() || void 0;
+      }
     } catch {
-      const { stdout } = await execAsync2(`git merge-base ${quotedHeadRef} ${quoteArg(`origin/${resolvedBaseBranch}`)}`, {
-        cwd,
-        encoding: "utf-8"
-      });
-      mergeBase = stdout.trim() || void 0;
     }
-  } catch {
   }
   if (mergeBase) {
     try {
@@ -55238,12 +55748,37 @@ async function resolveTrivialWhitespace(filePath, cwd) {
     throw new Error(`Failed to auto-resolve ${filePath} trivial conflict: ${error}`);
   }
 }
+function buildTaskIdTrailerArg(taskId) {
+  return ` -m "${FUSION_TASK_ID_TRAILER_KEY}: ${taskId}"`;
+}
+async function ensureTaskIdTrailerOnHead(rootDir, taskId) {
+  try {
+    const { stdout: existingMessage } = await execAsync2("git log -1 --pretty=%B", {
+      cwd: rootDir,
+      encoding: "utf-8"
+    });
+    const trailerLine = `${FUSION_TASK_ID_TRAILER_KEY}: ${taskId}`;
+    if (existingMessage.includes(trailerLine)) return;
+    await execAsync2(
+      `git -c trailer.ifExists=addIfDifferent commit --amend --no-edit --trailer "${trailerLine}"`,
+      { cwd: rootDir }
+    );
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    mergerLog.warn(`${taskId}: failed to add ${FUSION_TASK_ID_TRAILER_KEY} trailer to HEAD (${msg}) \u2014 relying on subject grep for recovery`);
+  }
+}
 function getCommitAuthorArg(settings) {
   if (settings.commitAuthorEnabled === false) return "";
   const name = settings.commitAuthorName || "Fusion";
   const email = settings.commitAuthorEmail || "noreply@runfusion.ai";
   return ` --author="${name} <${email}>"`;
 }
+function buildSourceIssueRef(sourceIssue) {
+  if (!sourceIssue || sourceIssue.provider !== "github") return "";
+  if (!sourceIssue.repository || !sourceIssue.issueNumber) return "";
+  return `${sourceIssue.repository}#${sourceIssue.issueNumber}`;
+}
 function buildMergeSystemPrompt(includeTaskId, agentPrompts, authorArg) {
   const commitFormat = includeTaskId ? `\`\`\`
 git commit -m "<type>(<scope>): <summary>" -m "<body>"${authorArg || ""}
@@ -55254,6 +55789,7 @@ Message format:
 - **Scope:** the task ID (e.g., KB-001)
 - **Summary:** one line describing what the squash brings in (imperative mood)
 - **Body:** 2-5 bullet points summarizing the key changes, each starting with "- "
+- **GitHub reference:** when the prompt includes a source issue reference, add \`Ref: owner/repo#N\` to the commit body
 ${authorArg ? `- **Author:** Always include the --author flag as shown in the example above.` : ""}
 
 Example:
@@ -55271,6 +55807,7 @@ Message format:
 - **Type:** feat, fix, refactor, docs, test, chore
 - **Summary:** one line describing what the squash brings in (imperative mood)
 - **Body:** 2-5 bullet points summarizing the key changes, each starting with "- "
+- **GitHub reference:** when the prompt includes a source issue reference, add \`Ref: owner/repo#N\` to the commit body
 ${authorArg ? `- **Author:** Always include the --author flag as shown in the example above.` : ""}
 Do NOT include a scope in the commit message type.
 
@@ -55654,6 +56191,7 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
     throw new Error(`Cannot merge ${taskId}: ${mergeBlocker}`);
   }
   const branch = task.branch || `fusion/${taskId.toLowerCase()}`;
+  const sourceIssueRef = buildSourceIssueRef(task.sourceIssue);
   const worktreePath = task.worktree;
   const result = {
     task,
@@ -55676,6 +56214,13 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
   const settings = await store.getSettings();
   const includeTaskId = settings.includeTaskIdInCommit !== false;
   const smartConflictResolution = (settings.smartConflictResolution ?? settings.autoResolveConflicts) !== false;
+  const mergeConflictStrategy = normalizeMergeConflictStrategy(
+    settings.mergeConflictStrategy
+  );
+  if (mergeConflictStrategy === "smart-prefer-main" || mergeConflictStrategy === "smart-prefer-branch") {
+    await tryFastForwardFromOrigin(rootDir, taskId);
+  }
+  let mergeWasEmpty = false;
   try {
     execSync(`git rev-parse --verify "${branch}"`, {
       cwd: rootDir,
@@ -55735,6 +56280,57 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
       mergerLog.warn(`${taskId}: unable to verify/checkout main branch \u2014 proceeding on current HEAD`);
     }
   }
+  let rebaseHappened = false;
+  let preferMainRebaseFailureMessage;
+  if (settings.worktreeRebaseBeforeMerge === false && settings.worktreeRebaseLocalBase === false && mergeConflictStrategy === "smart-prefer-main") {
+    throw new Error(
+      `Incompatible settings for ${taskId}: mergeConflictStrategy="smart-prefer-main" requires at least one of worktreeRebaseBeforeMerge or worktreeRebaseLocalBase to remain enabled. The strategy relies on rebasing the branch onto current main to preserve main's deletions; with both disabled it can silently re-introduce branch-only content. Re-enable a rebase stage or switch to "smart-prefer-branch" / "ai-only".`
+    );
+  }
+  async function runLocalBaseRebase(label) {
+    if (!worktreePath) return;
+    try {
+      const { stdout: localHeadOut } = await execAsync2("git rev-parse HEAD", {
+        cwd: rootDir,
+        encoding: "utf-8"
+      });
+      const localHead = localHeadOut.trim();
+      if (!localHead) return;
+      let alreadyContains = false;
+      try {
+        await execAsync2(`git merge-base --is-ancestor "${localHead}" HEAD`, { cwd: worktreePath });
+        alreadyContains = true;
+      } catch {
+      }
+      if (alreadyContains) {
+        rebaseHappened = true;
+        return;
+      }
+      throwIfAborted(options.signal, taskId);
+      await execAsync2(`git rebase "${localHead}"`, { cwd: worktreePath });
+      rebaseHappened = true;
+      mergerLog.log(`${taskId}: rebased ${branch} onto local HEAD ${localHead.slice(0, 8)}${label ? ` (${label})` : ""}`);
+      await store.appendAgentLog(
+        taskId,
+        `Pre-merge rebase: ${branch} \u2192 local HEAD ${localHead.slice(0, 8)}${label ? ` (${label})` : ""}`,
+        "text",
+        void 0,
+        "merger"
+      );
+    } catch (localRebaseErr) {
+      rethrowIfMergeAborted(localRebaseErr);
+      const lmsg = localRebaseErr instanceof Error ? localRebaseErr.message : String(localRebaseErr);
+      mergerLog.warn(`${taskId}: pre-merge rebase onto local HEAD failed (${lmsg}) \u2014 aborting and falling through`);
+      try {
+        await execAsync2("git rebase --abort", { cwd: worktreePath });
+      } catch (abortError) {
+        mergerLog.warn(`${taskId}: failed to abort local-HEAD rebase: ${getCommandErrorMessage(abortError)}`);
+      }
+      if (mergeConflictStrategy === "smart-prefer-main" && !preferMainRebaseFailureMessage) {
+        preferMainRebaseFailureMessage = `Pre-merge rebase onto local HEAD aborted (${lmsg})`;
+      }
+    }
+  }
   if (settings.worktreeRebaseBeforeMerge !== false) {
     try {
       let remote = settings.worktreeRebaseRemote?.trim();
@@ -55769,7 +56365,9 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
         }
       }
       if (!remote) {
-        mergerLog.log(`${taskId}: no remote resolvable \u2014 skipping pre-merge rebase`);
+        mergerLog.log(`${taskId}: no remote resolvable \u2014 skipping remote rebase stage (local-base stage may still run)`);
+      } else if (!worktreePath) {
+        mergerLog.warn(`${taskId}: no worktreePath \u2014 skipping remote rebase stage`);
       } else {
         throwIfAborted(options.signal, taskId);
         mergerLog.log(`${taskId}: fetching ${remote} before merge`);
@@ -55781,17 +56379,21 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
           );
           const mainBranch = mainBranchOut.trim();
           const remoteRef = `${remote}/${mainBranch}`;
-          if (worktreePath) {
-            throwIfAborted(options.signal, taskId);
-            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`);
-          }
+          throwIfAborted(options.signal, taskId);
+          await execAsync2(`git rebase "${remoteRef}"`, { cwd: worktreePath });
+          rebaseHappened = true;
+          mergerLog.log(`${taskId}: rebased ${branch} onto ${remoteRef}`);
+          await store.appendAgentLog(
+            taskId,
+            `Pre-merge rebase: ${branch} \u2192 ${remoteRef}`,
+            "text",
+            void 0,
+            "merger"
+          );
         } catch (rebaseErr) {
           rethrowIfMergeAborted(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`);
+          mergerLog.warn(`${taskId}: pre-merge rebase failed (${msg}) \u2014 aborting rebase and falling through`);
           if (worktreePath) {
             try {
               await execAsync2("git rebase --abort", { cwd: worktreePath });
@@ -55799,14 +56401,32 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
               mergerLog.warn(`${taskId}: failed to abort pre-merge rebase: ${getCommandErrorMessage(abortError)}`);
             }
           }
+          if (mergeConflictStrategy === "smart-prefer-main") {
+            preferMainRebaseFailureMessage = `Pre-merge rebase onto remote main aborted (${msg})`;
+          }
         }
       }
     } catch (err) {
       rethrowIfMergeAborted(err);
       const msg = err instanceof Error ? err.message : String(err);
-      mergerLog.warn(`${taskId}: pre-merge rebase pipeline failed (${msg}) \u2014 proceeding without rebase`);
+      mergerLog.warn(`${taskId}: pre-merge remote rebase pipeline failed (${msg}) \u2014 proceeding without remote rebase`);
     }
   }
+  if (settings.worktreeRebaseLocalBase !== false && !preferMainRebaseFailureMessage) {
+    await runLocalBaseRebase(
+      settings.worktreeRebaseBeforeMerge === false ? "remote rebase disabled" : ""
+    );
+  }
+  if (preferMainRebaseFailureMessage) {
+    throw new Error(
+      `${preferMainRebaseFailureMessage} for ${taskId}. Strategy "smart-prefer-main" requires a successful rebase to preserve main's deletions; falling through to a -X ours merge would silently re-introduce branch-only content. Resolve the rebase conflict manually, or switch mergeConflictStrategy to "smart-prefer-branch" / "ai-only".`
+    );
+  }
+  if (mergeConflictStrategy === "smart-prefer-main" && !rebaseHappened) {
+    mergerLog.warn(
+      `${taskId}: smart-prefer-main ran without a successful pre-merge rebase (${worktreePath ? "no remote resolvable or rebase disabled" : "no worktreePath"}). Main's deletions may not be preserved if the branch re-introduces them.`
+    );
+  }
   const diffBaseRef = await resolveTaskDiffBaseRef({
     cwd: rootDir,
     headRef: branch,
@@ -55867,6 +56487,25 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
   }
   const mergeAttempt = async (attemptNum) => {
     mergerLog.log(`${taskId}: merge attempt ${attemptNum}/3...`);
+    const attemptLabel = attemptNum === 1 ? "Attempt 1: AI merge" : attemptNum === 2 ? "Attempt 2: auto-resolve known conflicts, then AI" : `Attempt 3: ${mergeConflictStrategy === "smart-prefer-main" ? "-X ours" : "-X theirs"} fallback`;
+    await store.appendAgentLog(
+      taskId,
+      `Starting merge ${attemptLabel}`,
+      "text",
+      void 0,
+      "merger"
+    );
+    let preAttemptHeadSha = "";
+    try {
+      const { stdout } = await execAsync2("git rev-parse HEAD", {
+        cwd: rootDir,
+        encoding: "utf-8"
+      });
+      preAttemptHeadSha = stdout.trim();
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      mergerLog.warn(`${taskId}: failed to capture pre-attempt HEAD (${msg}) \u2014 verification-fix finalizer will fall back to amend`);
+    }
     try {
       const success = await executeMergeAttempt({
         store,
@@ -55876,7 +56515,9 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
         commitLog,
         diffStat,
         includeTaskId,
+        sourceIssueRef,
         smartConflictResolution,
+        mergeConflictStrategy,
         attemptNum,
         options,
         result,
@@ -55888,7 +56529,7 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
       }, aiTracker);
       if (success) {
         result.attemptsMade = attemptNum;
-        result.resolutionStrategy = getResolutionStrategy(attemptNum, smartConflictResolution);
+        result.resolutionStrategy = getResolutionStrategy(attemptNum, smartConflictResolution, mergeConflictStrategy);
         result.resolutionMethod = getResolutionMethod(result.resolutionStrategy, result.autoResolvedCount, aiTracker.aiWasInvoked);
         result.merged = true;
         return true;
@@ -55983,12 +56624,27 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
             }
             if (fixSuccess) {
               const authorArg = getCommitAuthorArg(settings);
-              await amendMergeCommitWithFixes(rootDir, taskId, authorArg);
+              const finalized = await commitOrAmendMergeWithFixes(
+                rootDir,
+                taskId,
+                branch,
+                commitLog,
+                includeTaskId,
+                preAttemptHeadSha,
+                authorArg
+              );
+              if (!finalized) {
+                resetMergeWithWarn(rootDir, taskId, "verification-fix finalize");
+                throw new Error(
+                  `${taskId}: verification fix succeeded but no merge commit could be created \u2014 refusing to mark merge complete.`
+                );
+              }
               return true;
             }
           }
         }
         mergerLog.error(`${taskId}: deterministic verification failed \u2014 aborting merge (in-merge fix exhausted or disabled)`);
+        resetMergeWithWarn(rootDir, taskId, "deterministic-verification rollback");
         throw error;
       }
       if (error.message?.includes("Build verification failed")) {
@@ -56059,7 +56715,21 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
           }
           if (fixSuccess) {
             const authorArg = getCommitAuthorArg(settings);
-            await amendMergeCommitWithFixes(rootDir, taskId, authorArg);
+            const finalized = await commitOrAmendMergeWithFixes(
+              rootDir,
+              taskId,
+              branch,
+              commitLog,
+              includeTaskId,
+              preAttemptHeadSha,
+              authorArg
+            );
+            if (!finalized) {
+              resetMergeWithWarn(rootDir, taskId, "build-verification fix finalize");
+              throw new Error(
+                `${taskId}: build verification fix succeeded but no merge commit could be created \u2014 refusing to mark merge complete.`
+              );
+            }
             return true;
           }
         }
@@ -56073,10 +56743,18 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
             await audit.git({ type: "reset:hard", target: branch, metadata: { purpose: "build-retry" } });
           } catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
-            mergerLog.warn(`${taskId}: git reset --merge cleanup failed (build-retry): ${msg}`);
+            mergerLog.warn(`${taskId}: git reset --merge cleanup failed during build-verification rollback (build-retry): ${msg}`);
           }
           return false;
         }
+        resetMergeWithWarn(rootDir, taskId, "build-verification rollback (no retries left)");
+        throw error;
+      }
+      if (error.name === "MergeNonConflictError") {
+        try {
+          execSync("git reset --merge", { cwd: rootDir, stdio: "pipe" });
+        } catch {
+        }
         throw error;
       }
       if (attemptNum < 3 && smartConflictResolution) {
@@ -56096,12 +56774,15 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
   const aiTracker = { aiWasInvoked: false };
   let merged = false;
   merged = await mergeAttempt(1);
-  if (!merged && smartConflictResolution) {
+  if (!merged && smartConflictResolution && mergeConflictStrategy !== "abort") {
     merged = await mergeAttempt(2);
   }
-  if (!merged && smartConflictResolution) {
+  if (!merged && smartConflictResolution && mergeConflictStrategy !== "ai-only" && mergeConflictStrategy !== "abort") {
     merged = await mergeAttempt(3);
   }
+  if (aiTracker.mergeWasEmpty) {
+    mergeWasEmpty = true;
+  }
   if (!merged) {
     try {
       execSync("git reset --merge", { cwd: rootDir, stdio: "pipe" });
@@ -56109,6 +56790,10 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
       const errorMessage = err instanceof Error ? err.message : String(err);
       mergerLog.warn(`${taskId}: git reset --merge cleanup failed: ${errorMessage}`);
     }
+    if (mergeConflictStrategy === "abort") {
+      result.resolutionStrategy = "abort";
+      throw new Error(`Merge conflict for ${taskId}: aborted per mergeConflictStrategy="abort" \u2014 manual resolution required`);
+    }
     throw new Error(`AI merge failed for ${taskId}: all 3 attempts exhausted`);
   }
   try {
@@ -56135,17 +56820,24 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
     } catch {
     }
     const isEmptyCommit = filesChanged === 0;
-    const recordedSha = isEmptyCommit ? void 0 : commitSha;
+    const recordedSha = isEmptyCommit || mergeWasEmpty ? void 0 : commitSha;
     if (isEmptyCommit) {
       mergerLog.warn(
         `${taskId}: local squash produced an empty commit (${commitSha?.slice(0, 8)}) \u2014 branch likely contained dupes of main. Skipping commitSha; recovery will backfill when real commit lands.`
       );
+    } else if (mergeWasEmpty) {
+      mergerLog.warn(
+        `${taskId}: merge succeeded without committing (branch already on main). Skipping commitSha; nothing new landed locally.`
+      );
     }
+    const recordedFilesChanged = mergeWasEmpty ? 0 : filesChanged;
+    const recordedInsertions = mergeWasEmpty ? 0 : insertions;
+    const recordedDeletions = mergeWasEmpty ? 0 : deletions;
     const mergeDetails = {
       commitSha: recordedSha,
-      filesChanged,
-      insertions,
-      deletions,
+      filesChanged: recordedFilesChanged,
+      insertions: recordedInsertions,
+      deletions: recordedDeletions,
       mergeCommitMessage: commitLog,
       mergedAt: (/* @__PURE__ */ new Date()).toISOString(),
       mergeConfirmed: true,
@@ -56156,6 +56848,26 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
     };
     await store.updateTask(taskId, { mergeDetails });
     mergerLog.log(`${taskId}: merge details stored (commitSha: ${recordedSha?.slice(0, 8) ?? "<deferred>"})`);
+    const summaryParts = [
+      `Merge completed via ${result.resolutionStrategy ?? "unknown"} (attempt ${result.attemptsMade ?? "?"}/3)`
+    ];
+    if (recordedSha) {
+      summaryParts.push(`commit ${recordedSha.slice(0, 8)}`);
+    } else if (mergeWasEmpty) {
+      summaryParts.push("no commit landed (branch already on main)");
+    } else if (isEmptyCommit) {
+      summaryParts.push("squash collapsed to empty (sha deferred)");
+    }
+    if (!mergeWasEmpty && filesChanged !== void 0) {
+      summaryParts.push(`${filesChanged} file${filesChanged === 1 ? "" : "s"} changed (+${insertions ?? 0}/-${deletions ?? 0})`);
+    }
+    await store.appendAgentLog(
+      taskId,
+      summaryParts.join(" \xB7 "),
+      "text",
+      void 0,
+      "merger"
+    );
   } catch (err) {
     mergerLog.warn(`${taskId}: failed to collect/store merge details: ${err.message}`);
   }
@@ -56250,6 +56962,27 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
       });
       if (pushResult.pushed) {
         mergerLog.log(`${taskId}: pushed merged result to remote`);
+        try {
+          const postPushSha = execSync("git rev-parse HEAD", {
+            cwd: rootDir,
+            stdio: "pipe",
+            encoding: "utf-8"
+          }).trim() || void 0;
+          if (postPushSha) {
+            const existingTask = await store.getTask(taskId).catch(() => null);
+            const existingDetails = existingTask?.mergeDetails;
+            if (existingDetails?.commitSha && existingDetails.commitSha !== postPushSha) {
+              await store.updateTask(taskId, {
+                mergeDetails: { ...existingDetails, commitSha: postPushSha }
+              });
+              mergerLog.log(
+                `${taskId}: post-push HEAD changed from ${existingDetails.commitSha.slice(0, 8)} to ${postPushSha.slice(0, 8)} \u2014 refreshed mergeDetails.commitSha`
+              );
+            }
+          }
+        } catch (refreshErr) {
+          mergerLog.warn(`${taskId}: failed to refresh mergeDetails after push: ${refreshErr.message}`);
+        }
       } else {
         mergerLog.warn(`${taskId}: push to remote failed: ${pushResult.error}`);
       }
@@ -56277,18 +57010,74 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
   await completeTask(store, taskId, result);
   return result;
 }
-function getResolutionStrategy(attemptNum, smartConflictResolution) {
+async function tryFastForwardFromOrigin(rootDir, taskId) {
+  let currentBranch;
+  try {
+    currentBranch = execSync("git rev-parse --abbrev-ref HEAD", {
+      cwd: rootDir,
+      encoding: "utf-8",
+      stdio: "pipe"
+    }).trim();
+  } catch {
+    return;
+  }
+  if (!currentBranch || currentBranch === "HEAD") return;
+  try {
+    await execAsync2(`git fetch origin "${currentBranch}"`, { cwd: rootDir });
+  } catch (err) {
+    mergerLog.log(`${taskId}: pre-merge fetch failed (continuing): ${err instanceof Error ? err.message : String(err)}`);
+    return;
+  }
+  let behind = 0;
+  let ahead = 0;
+  try {
+    const counts = execSync(`git rev-list --left-right --count "origin/${currentBranch}...HEAD"`, {
+      cwd: rootDir,
+      encoding: "utf-8",
+      stdio: "pipe"
+    }).trim();
+    const [b, a] = counts.split(/\s+/).map((n) => Number.parseInt(n, 10) || 0);
+    behind = b;
+    ahead = a;
+  } catch {
+    return;
+  }
+  if (behind === 0) return;
+  if (ahead > 0) {
+    mergerLog.log(`${taskId}: local ${currentBranch} has ${ahead} unpushed commit(s); skipping fast-forward`);
+    return;
+  }
+  try {
+    await execAsync2(`git merge --ff-only "origin/${currentBranch}"`, { cwd: rootDir });
+    mergerLog.log(`${taskId}: fast-forwarded ${currentBranch} by ${behind} commit(s) from origin`);
+  } catch (err) {
+    mergerLog.log(`${taskId}: fast-forward failed (continuing): ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+function getResolutionStrategy(attemptNum, smartConflictResolution, mergeConflictStrategy = "smart-prefer-main") {
   if (!smartConflictResolution || attemptNum === 1) {
     return "ai";
   }
   if (attemptNum === 2) {
     return "auto-resolve";
   }
-  return "theirs";
+  switch (mergeConflictStrategy) {
+    case "ai-only":
+      return "ai";
+    case "smart-prefer-main":
+      return "ours";
+    case "abort":
+      return "abort";
+    case "smart-prefer-branch":
+    default:
+      return "theirs";
+  }
 }
 function getResolutionMethod(strategy, autoResolvedCount, aiWasUsed) {
   if (strategy === "ai") return "ai";
   if (strategy === "theirs") return "theirs";
+  if (strategy === "ours") return "ours";
+  if (strategy === "abort") return "abort";
   if (strategy === "auto-resolve") {
     if (autoResolvedCount && autoResolvedCount > 0) {
       return aiWasUsed ? "mixed" : "auto";
@@ -56306,6 +57095,7 @@ async function executeMergeAttempt(params, aiTracker) {
     commitLog,
     diffStat,
     includeTaskId,
+    sourceIssueRef,
     smartConflictResolution,
     attemptNum,
     options,
@@ -56317,12 +57107,15 @@ async function executeMergeAttempt(params, aiTracker) {
     buildSource
   } = params;
   if (attemptNum === 3) {
-    return attemptWithTheirsStrategy(params);
+    if (params.mergeConflictStrategy === "smart-prefer-main") {
+      return attemptWithSideStrategy(params, "ours", aiTracker);
+    }
+    return attemptWithSideStrategy(params, "theirs", aiTracker);
   }
   let hasConflicts = false;
   try {
     if (attemptNum === 2 && smartConflictResolution) {
-      let mergeExitedWithConflicts = false;
+      let mergeError;
       try {
         await execAsync2(`git merge --squash "${branch}"`, {
           cwd: rootDir
@@ -56330,9 +57123,18 @@ async function executeMergeAttempt(params, aiTracker) {
         throwIfAborted(options.signal, taskId);
       } catch (error) {
         rethrowIfMergeAborted(error);
-        mergeExitedWithConflicts = true;
+        mergeError = error;
       }
       const conflictedFiles = await getConflictedFiles(rootDir);
+      if (mergeError && conflictedFiles.length === 0) {
+        const cause = mergeError instanceof Error ? mergeError.message : String(mergeError);
+        const fatal = new Error(
+          `${taskId}: git merge --squash failed without producing conflicts (${cause}) \u2014 refusing to treat as a no-op merge.`
+        );
+        fatal.name = "MergeNonConflictError";
+        throw fatal;
+      }
+      const mergeExitedWithConflicts = mergeError !== void 0;
       if (conflictedFiles.length > 0 || mergeExitedWithConflicts) {
         const classified = [];
         for (const file of conflictedFiles) {
@@ -56375,11 +57177,14 @@ async function executeMergeAttempt(params, aiTracker) {
             const escapedLog = commitLog.replace(/"/g, '\\"');
             const fallbackPrefix = includeTaskId ? `feat(${taskId})` : "feat";
             const authorArg = getCommitAuthorArg(settings);
+            const trailerArg = buildTaskIdTrailerArg(taskId);
             await execAsync2(
-              `git commit -m "${fallbackPrefix}: merge ${branch}" -m "${escapedLog}"${authorArg}`,
+              `git commit -m "${fallbackPrefix}: merge ${branch}" -m "${escapedLog}"${trailerArg}${authorArg}`,
               { cwd: rootDir }
             );
             mergerLog.log(`${taskId}: committed after auto-resolving all conflicts`);
+          } else {
+            aiTracker.mergeWasEmpty = true;
           }
           if (testCommand || buildCommand2) {
             throwIfAborted(options.signal, taskId);
@@ -56404,6 +57209,7 @@ async function executeMergeAttempt(params, aiTracker) {
         ).trim() === "0";
         if (squashIsEmpty) {
           mergerLog.log(`${taskId}: squash merge staged nothing \u2014 already merged`);
+          aiTracker.mergeWasEmpty = true;
           if (testCommand || buildCommand2) {
             throwIfAborted(options.signal, taskId);
             await runDeterministicVerification(
@@ -56431,6 +57237,7 @@ async function executeMergeAttempt(params, aiTracker) {
       ).trim() === "0";
       if (squashIsEmpty) {
         mergerLog.log(`${taskId}: squash merge staged nothing \u2014 already merged`);
+        aiTracker.mergeWasEmpty = true;
         if (testCommand || buildCommand2) {
           throwIfAborted(options.signal, taskId);
           await runDeterministicVerification(
@@ -56479,19 +57286,12 @@ async function executeMergeAttempt(params, aiTracker) {
       simplifiedContext: attemptNum === 2,
       options,
       testCommand,
-      buildCommand: buildCommand2
+      buildCommand: buildCommand2,
+      sourceIssueRef
     });
     if (!agentResult.success) {
       const errorMessage = agentResult.error || "Build verification failed";
       await store.logEntry(taskId, "Build verification failed during merge", errorMessage);
-      try {
-        execSync("git reset --merge", { cwd: rootDir, stdio: "pipe" });
-      } catch (resetErr) {
-        const msg = resetErr instanceof Error ? resetErr.message : String(resetErr);
-        mergerLog.warn(
-          `${taskId}: git reset --merge cleanup failed during build-verification rollback (build-verification reset, build-retry): ${msg}`
-        );
-      }
       throw new Error(`Build verification failed for ${taskId}: ${errorMessage}`);
     }
     if (testCommand || buildCommand2) {
@@ -56507,6 +57307,24 @@ async function executeMergeAttempt(params, aiTracker) {
         options.signal
       );
     }
+    try {
+      const authorArg = getCommitAuthorArg(params.settings);
+      const { subjectArg, bodyArg } = buildDeterministicMergeMessage({
+        taskId,
+        branch,
+        commitLog,
+        includeTaskId
+      });
+      const trailerArg = buildTaskIdTrailerArg(taskId);
+      await execAsync2(
+        `git commit --amend ${subjectArg} ${bodyArg}${trailerArg}${authorArg}`,
+        { cwd: rootDir }
+      );
+      mergerLog.log(`${taskId}: rewrote AI-authored merge commit message with deterministic body`);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      mergerLog.warn(`${taskId}: failed to canonicalize merge commit message (${msg}) \u2014 keeping AI-written message`);
+    }
     return true;
   } catch (error) {
     if (error instanceof Error && error.name === "MergeAbortedError") {
@@ -56528,12 +57346,12 @@ async function executeMergeAttempt(params, aiTracker) {
     throw error;
   }
 }
-async function attemptWithTheirsStrategy(params) {
-  const { rootDir, branch, commitLog, includeTaskId, taskId, store, settings, testCommand, buildCommand: buildCommand2, testSource, buildSource } = params;
-  mergerLog.log(`${taskId}: attempting merge with -X theirs strategy`);
+async function attemptWithSideStrategy(params, side = "theirs", aiTracker) {
+  const { rootDir, branch, commitLog, includeTaskId, sourceIssueRef, taskId, store, settings, testCommand, buildCommand: buildCommand2, testSource, buildSource } = params;
+  mergerLog.log(`${taskId}: attempting merge with -X ${side} strategy`);
   try {
     throwIfAborted(params.options.signal, taskId);
-    await execAsync2(`git merge -X theirs --squash "${branch}"`, {
+    await execAsync2(`git merge -X ${side} --squash "${branch}"`, {
       cwd: rootDir
     });
     const conflictedOutput = execSync("git diff --name-only --diff-filter=U", {
@@ -56541,7 +57359,7 @@ async function attemptWithTheirsStrategy(params) {
       encoding: "utf-8"
     }).trim();
     if (conflictedOutput.length > 0) {
-      mergerLog.warn(`${taskId}: -X theirs left unresolved conflicts: ${conflictedOutput}`);
+      mergerLog.warn(`${taskId}: -X ${side} left unresolved conflicts: ${conflictedOutput}`);
       return false;
     }
     const staged = execSync("git diff --cached --quiet 2>&1; echo $?", {
@@ -56549,6 +57367,7 @@ async function attemptWithTheirsStrategy(params) {
       encoding: "utf-8"
     }).trim();
     if (staged === "0") {
+      if (aiTracker) aiTracker.mergeWasEmpty = true;
       if (testCommand || buildCommand2) {
         throwIfAborted(params.options.signal, taskId);
         await runDeterministicVerification(
@@ -56568,11 +57387,13 @@ async function attemptWithTheirsStrategy(params) {
     const escapedLog = commitLog.replace(/"/g, '\\"');
     const fallbackPrefix = includeTaskId ? `feat(${taskId})` : "feat";
     const authorArg = getCommitAuthorArg(settings);
+    const trailerArg = buildTaskIdTrailerArg(taskId);
+    const issueRefBodyArg = sourceIssueRef ? ` -m "Ref: ${sourceIssueRef}"` : "";
     await execAsync2(
-      `git commit -m "${fallbackPrefix}: merge ${branch} (auto-resolved)" -m "${escapedLog}"${authorArg}`,
+      `git commit -m "${fallbackPrefix}: merge ${branch} (auto-resolved)" -m "${escapedLog}"${issueRefBodyArg}${trailerArg}${authorArg}`,
       { cwd: rootDir }
     );
-    mergerLog.log(`${taskId}: committed with -X theirs auto-resolution`);
+    mergerLog.log(`${taskId}: committed with -X ${side} auto-resolution`);
     if (testCommand || buildCommand2) {
       throwIfAborted(params.options.signal, taskId);
       await runDeterministicVerification(
@@ -56591,7 +57412,7 @@ async function attemptWithTheirsStrategy(params) {
     if (error instanceof Error && error.name === "MergeAbortedError") {
       throw error;
     }
-    mergerLog.error(`${taskId}: -X theirs merge failed: ${error}`);
+    mergerLog.error(`${taskId}: -X ${side} merge failed: ${error}`);
     return false;
   }
 }
@@ -56606,6 +57427,7 @@ async function runAiAgentForCommit(params) {
     includeTaskId,
     hasConflicts,
     simplifiedContext,
+    sourceIssueRef,
     options,
     testCommand,
     buildCommand: buildCommand2
@@ -56704,7 +57526,8 @@ async function runAiAgentForCommit(params) {
       simplifiedContext,
       testCommand,
       buildCommand: buildCommand2,
-      authorArg
+      authorArg,
+      sourceIssueRef
     });
     mergerLog.log(`${taskId}: starting fresh merge agent session`);
     try {
@@ -56736,7 +57559,8 @@ async function runAiAgentForCommit(params) {
           // Also skip detailed context
           testCommand,
           buildCommand: buildCommand2,
-          authorArg
+          authorArg,
+          sourceIssueRef
         });
         try {
           await withRateLimitRetry(async () => {
@@ -56777,13 +57601,17 @@ async function runAiAgentForCommit(params) {
         const escapedLog = commitLog.replace(/"/g, '\\"');
         const fallbackPrefix = includeTaskId ? `feat(${taskId})` : "feat";
         const authorArg2 = getCommitAuthorArg(settings);
+        const trailerArg = buildTaskIdTrailerArg(taskId);
+        const issueRefBodyArg = sourceIssueRef ? ` -m "Ref: ${sourceIssueRef}"` : "";
         await execAsync2(
-          `git commit -m "${fallbackPrefix}: merge ${branch}" -m "${escapedLog}"${authorArg2}`,
+          `git commit -m "${fallbackPrefix}: merge ${branch}" -m "${escapedLog}"${issueRefBodyArg}${trailerArg}${authorArg2}`,
           { cwd: rootDir }
         );
       } else {
         throw new Error(`Agent did not commit and did not report build failure for ${taskId}`);
       }
+    } else {
+      await ensureTaskIdTrailerOnHead(rootDir, taskId);
     }
     return { success: true };
   } catch (err) {
@@ -56799,7 +57627,7 @@ async function runAiAgentForCommit(params) {
   }
 }
 function buildMergePrompt(params) {
-  const { taskId, branch, commitLog, diffStat, hasConflicts, simplifiedContext, testCommand, buildCommand: buildCommand2, authorArg } = params;
+  const { taskId, branch, commitLog, diffStat, hasConflicts, simplifiedContext, sourceIssueRef, testCommand, buildCommand: buildCommand2, authorArg } = params;
   const truncatedCommitLog = truncateWithEllipsis(commitLog, MERGE_COMMIT_LOG_MAX_CHARS);
   const truncatedDiffStat = truncateWithEllipsis(diffStat, MERGE_DIFF_STAT_MAX_CHARS);
   const parts = [
@@ -56835,6 +57663,13 @@ function buildMergePrompt(params) {
       `Write and run the \`git commit\` command with a good message summarizing the work.${authorArg ? ` Be sure to include \`${authorArg.trim()}\` in the commit command.` : ""}`
     );
   }
+  if (sourceIssueRef) {
+    parts.push(
+      "",
+      "Include this in the commit message body:",
+      `- Ref: ${sourceIssueRef}`
+    );
+  }
   if (testCommand) {
     parts.push(
       "",
@@ -57011,8 +57846,9 @@ If issues are found that need attention, describe them clearly.`;
     agent: "merger"
   });
   try {
-    const stepProvider = workflowStep.modelProvider || settings.defaultProvider;
-    const stepModelId = workflowStep.modelId || settings.defaultModelId;
+    const defaultModel = resolveProjectDefaultModel(settings);
+    const stepProvider = workflowStep.modelProvider || defaultModel.provider;
+    const stepModelId = workflowStep.modelId || defaultModel.modelId;
     const useOverride = !!(workflowStep.modelProvider && workflowStep.modelId);
     let postMergeInstructions = "";
     if (mergeOptions.agentStore) {
@@ -57095,12 +57931,11 @@ async function completeTask(store, taskId, result) {
   result.task = task;
   store.emit("task:merged", result);
 }
-var execAsync2, LOCKFILE_PATTERNS, GENERATED_PATTERNS, DEPENDENCY_SYNC_TRIGGER_PATTERNS, VERIFICATION_COMMAND_MAX_BUFFER, VERIFICATION_COMMAND_TIMEOUT_MS, VERIFICATION_LOG_MAX_CHARS, WORKFLOW_SCRIPT_OUTPUT_MAX_CHARS, PULL_REBASE_TIMEOUT_MS, PUSH_TIMEOUT_MS, MERGE_COMMIT_LOG_MAX_CHARS, MERGE_DIFF_STAT_MAX_CHARS, VerificationError, MergeAbortedError;
+var execAsync2, LOCKFILE_PATTERNS, GENERATED_PATTERNS, DEPENDENCY_SYNC_TRIGGER_PATTERNS, VERIFICATION_COMMAND_MAX_BUFFER, VERIFICATION_COMMAND_TIMEOUT_MS, VERIFICATION_LOG_MAX_CHARS, WORKFLOW_SCRIPT_OUTPUT_MAX_CHARS, PULL_REBASE_TIMEOUT_MS, PUSH_TIMEOUT_MS, MERGE_COMMIT_LOG_MAX_CHARS, MERGE_DIFF_STAT_MAX_CHARS, VerificationError, MergeAbortedError, FUSION_TASK_ID_TRAILER_KEY;
 var init_merger = __esm({
   "../engine/src/merger.ts"() {
     "use strict";
     init_src();
-    init_src();
     init_pi();
     init_session_token_usage();
     init_agent_session_helpers();
@@ -57170,6 +58005,7 @@ var init_merger = __esm({
         this.name = "MergeAbortedError";
       }
     };
+    FUSION_TASK_ID_TRAILER_KEY = "Fusion-Task-Id";
   }
 });
 
@@ -58757,6 +59593,7 @@ function buildExecutionPrompt(task, rootDir, settings, worktreePath) {
   const reviewMatch = prompt.match(/##\s*Review Level[:\s]*(\d)/);
   const reviewLevel = reviewMatch ? parseInt(reviewMatch[1], 10) : 0;
   const authorArg = settings?.commitAuthorEnabled !== false ? ` --author="${settings?.commitAuthorName || "Fusion"} <${settings?.commitAuthorEmail || "noreply@runfusion.ai"}>"` : "";
+  const sourceIssueRef = task.sourceIssue?.provider === "github" && task.sourceIssue.repository && task.sourceIssue.issueNumber ? `${task.sourceIssue.repository}#${task.sourceIssue.issueNumber}` : "";
   const hasProgress = task.steps.length > 0 && task.steps.some((s) => s.status !== "pending");
   let progressSection = "";
   if (hasProgress) {
@@ -58859,7 +59696,7 @@ ${hasProgress ? `Resume from Step ${task.currentStep}. Do NOT redo completed ste
 Use \`fn_task_update\` to report progress on every step transition.
 Use \`fn_task_log\` for important actions and decisions.
 Use \`fn_task_create\` for truly separate follow-up work, not for fixes required to get tests, build, or typecheck back to green.
-Commit at step boundaries: \`git commit -m "feat(${task.id}): complete Step N \u2014 description"${authorArg}\`
+Commit at step boundaries: \`git commit -m "feat(${task.id}): complete Step N \u2014 description"${sourceIssueRef ? ` -m "Ref: ${sourceIssueRef}"` : ""}${authorArg}\`
 When all steps are complete: call \`fn_task_done()\`
 
 If a build command is configured, run that exact command in this worktree before calling \`fn_task_done()\`.
@@ -59045,6 +59882,7 @@ If the task's PROMPT.md includes a "Documentation Requirements" section listing
 ## Git discipline
 - Commit after completing each step (not after every file change)
 - Use conventional commit messages prefixed with the task ID
+- When the task has a GitHub issue reference, include \`Ref: owner/repo#N\` in the commit body
 - Do NOT commit broken or half-implemented code
 
 ## Worktree Boundaries
@@ -59138,7 +59976,10 @@ Lint, tests, and typecheck are also hard quality gates:
           executorLog.log(`[event:task:moved] ${task.id}: ${from} \u2192 ${to}`);
           if (to === "in-progress") {
             executorLog.log(`[event:task:moved] Initiating execute() for ${task.id}`);
-            this.execute(task).catch(
+            void (async () => {
+              const taskForExecution = await this.resetMergeStateIfNeeded(task, from);
+              await this.execute(taskForExecution);
+            })().catch(
               (err) => executorLog.error(`Failed to start ${task.id}:`, err)
             );
           } else if (from === "in-progress") {
@@ -59416,6 +60257,59 @@ Lint, tests, and typecheck are also hard quality gates:
         if (task.steps.length === 0) return false;
         return task.steps.every((s) => s.status === "done" || s.status === "skipped");
       }
+      async resetMergeStateIfNeeded(task, from) {
+        if (from !== "in-review" && from !== "done") {
+          return task;
+        }
+        const hasMergeEvidence = Boolean(task.mergeDetails) || (task.mergeRetries ?? 0) > 0 || (task.verificationFailureCount ?? 0) > 0 || task.status === "merging" || task.status === "merging-pr";
+        if (!hasMergeEvidence) {
+          return task;
+        }
+        return this.cleanupMergeStateForReverification(
+          task,
+          `Task returned to in-progress from ${from} column \u2014 resetting verification steps and merge state for re-verification`
+        );
+      }
+      async cleanupMergeStateForReverification(task, logMessage) {
+        await this.store.updateTask(task.id, {
+          mergeDetails: null,
+          mergeRetries: 0,
+          verificationFailureCount: 0,
+          workflowStepResults: []
+        });
+        const refreshedTask = await this.store.getTask(task.id);
+        const steps = refreshedTask.steps ?? [];
+        if (steps.length > 0) {
+          const allStepsComplete = this.isTaskWorkComplete(refreshedTask);
+          if (allStepsComplete) {
+            await this.reopenLastStepForRevision(task.id, refreshedTask);
+          } else {
+            const resetIndexes = /* @__PURE__ */ new Set();
+            for (let i = 0; i < steps.length; i++) {
+              const name = steps[i].name.toLowerCase();
+              if (/testing|verification/.test(name) || /documentation|delivery/.test(name)) {
+                resetIndexes.add(i);
+              }
+            }
+            if (resetIndexes.size === 0) {
+              const reopened = await this.reopenLastStepForRevision(task.id, refreshedTask);
+              if (reopened) {
+                resetIndexes.add(reopened.index);
+              }
+            } else {
+              for (const index of resetIndexes) {
+                if (steps[index].status !== "pending") {
+                  await this.store.updateStep(task.id, index, "pending");
+                }
+              }
+              const earliestIndex = Math.min(...Array.from(resetIndexes));
+              await this.store.updateTask(task.id, { currentStep: earliestIndex });
+            }
+          }
+        }
+        await this.store.logEntry(task.id, logMessage, void 0, this.currentRunContext);
+        return this.store.getTask(task.id);
+      }
       isNoProgressNoTaskDoneFailure(task) {
         return task.status === "failed" && task.error?.includes("without calling fn_task_done") === true && task.steps.every((step) => step.status === "pending");
       }
@@ -59637,7 +60531,7 @@ Lint, tests, and typecheck are also hard quality gates:
         if (inProgress.length === 0) return;
         executorLog.log(`Found ${inProgress.length} orphaned in-progress task(s)`);
         for (const task of inProgress) {
-          if (this.isTaskWorkComplete(task)) {
+          if (this.isTaskWorkComplete(task) && !task.mergeDetails) {
             if (this.recoveringCompleted.has(task.id)) {
               executorLog.log(`${task.id} completed-task recovery already running - skipping duplicate startup recovery`);
               continue;
@@ -59772,6 +60666,13 @@ Lint, tests, and typecheck are also hard quality gates:
             return;
           }
         }
+        if (task.column === "in-progress" && task.mergeDetails) {
+          executorLog.warn(`${task.id}: stale mergeDetails found while executing in-progress task \u2014 resetting merge state before continuing`);
+          task = await this.cleanupMergeStateForReverification(
+            task,
+            "Executor detected stale merge state while task was in-progress \u2014 reset verification steps and merge metadata before resuming"
+          );
+        }
         if (task.column === "in-progress" && !task.worktree) {
           executorLog.error(
             `${task.id}: drift detected \u2014 task is in-progress with no worktree. Recovering by creating a fresh worktree. This usually indicates a partial updateTask/moveTask sequence failed somewhere upstream.`
@@ -61776,10 +62677,19 @@ and show an appropriate message to the user.\`
             this.options.onAgentTool?.(taskId, toolName);
           }
         });
-        try {
-          const stepProvider = workflowStep.modelProvider || settings.defaultProvider;
-          const stepModelId = workflowStep.modelId || settings.defaultModelId;
-          const useOverride = !!(workflowStep.modelProvider && workflowStep.modelId);
+        const defaultModel = resolveProjectDefaultModel(settings);
+        const primaryProvider = workflowStep.modelProvider || defaultModel.provider;
+        const primaryModelId = workflowStep.modelId || defaultModel.modelId;
+        const useOverride = !!(workflowStep.modelProvider && workflowStep.modelId);
+        const fallbackCandidates = [
+          { provider: settings.validatorFallbackProvider, modelId: settings.validatorFallbackModelId, label: "validatorFallback" },
+          { provider: settings.fallbackProvider, modelId: settings.fallbackModelId, label: "globalFallback" }
+        ];
+        const fallback = fallbackCandidates.find(
+          (c) => c.provider && c.modelId && (c.provider !== primaryProvider || c.modelId !== primaryModelId)
+        );
+        const timeoutMs = Math.max(6e4, settings.workflowStepTimeoutMs ?? 36e4);
+        const runOnce = async (provider, modelId, attemptLabel) => {
           const stepInstructions = await this.resolveInstructionsForRole("executor");
           const stepSystemPrompt = buildSystemPromptWithInstructions(systemPrompt, stepInstructions);
           const skillContext = await buildSessionSkillContext({
@@ -61797,16 +62707,19 @@ and show an appropriate message to the user.\`
             cwd: worktreePath,
             systemPrompt: stepSystemPrompt,
             tools: toolMode,
-            defaultProvider: stepProvider,
-            defaultModelId: stepModelId,
+            defaultProvider: provider,
+            defaultModelId: modelId,
             fallbackProvider: settings.fallbackProvider,
             fallbackModelId: settings.fallbackModelId,
             defaultThinkingLevel: settings.defaultThinkingLevel,
             // Skill selection: use assigned agent skills if available, otherwise role fallback
             ...skillContext.skillSelectionContext ? { skillSelection: skillContext.skillSelectionContext } : {}
           });
-          executorLog.log(`${task.id}: workflow step '${workflowStep.name}' using model ${describeModel(session)}${useOverride ? " (workflow step override)" : ""}`);
-          await this.store.logEntry(task.id, `Workflow step '${workflowStep.name}' using model: ${describeModel(session)}${useOverride ? " (workflow step override)" : ""}`);
+          executorLog.log(`${task.id}: workflow step '${workflowStep.name}' using model ${describeModel(session)}${useOverride && attemptLabel === "primary" ? " (workflow step override)" : ""}${attemptLabel === "fallback" ? " (fallback after timeout)" : ""}`);
+          await this.store.logEntry(
+            task.id,
+            `Workflow step '${workflowStep.name}' using model: ${describeModel(session)}${useOverride && attemptLabel === "primary" ? " (workflow step override)" : ""}${attemptLabel === "fallback" ? " (fallback after timeout)" : ""}`
+          );
           let output = "";
           session.subscribe((event) => {
             if (event.type === "message_update") {
@@ -61825,33 +62738,75 @@ and show an appropriate message to the user.\`
               agentLogger.onToolEnd(event.toolName, event.isError, event.result);
             }
           });
-          await promptWithFallback(
-            session,
-            `Execute the workflow step "${workflowStep.name}" for task ${task.id}.
+          let timedOut = false;
+          let timeoutHandle;
+          const timeoutPromise = new Promise((resolveTimeout) => {
+            timeoutHandle = setTimeout(() => {
+              timedOut = true;
+              resolveTimeout("timeout");
+            }, timeoutMs);
+          });
+          try {
+            const promptPromise = promptWithFallback(
+              session,
+              `Execute the workflow step "${workflowStep.name}" for task ${task.id}.
 
 Review the work done in this worktree and evaluate it against the criteria in your instructions.`
-          );
-          checkSessionError(session);
-          await accumulateSessionTokenUsage(this.store, task.id, session);
-          session.dispose();
-          await agentLogger.flush();
-          const trimmedOutput = output.trim();
-          const revisionMatch = trimmedOutput.match(/^REQUEST REVISION\s*\n*/i);
-          if (revisionMatch) {
-            const feedbackStart = revisionMatch[0].length;
-            const feedback = trimmedOutput.slice(feedbackStart).trim();
-            return {
-              success: false,
-              revisionRequested: true,
-              output: feedback
-            };
+            );
+            const outcome = await Promise.race([
+              promptPromise.then(() => "completed"),
+              timeoutPromise
+            ]);
+            if (outcome === "timeout") {
+              executorLog.warn(`${task.id}: workflow step '${workflowStep.name}' (${attemptLabel}) timed out after ${timeoutMs}ms \u2014 disposing session`);
+              await this.store.logEntry(
+                task.id,
+                `Workflow step '${workflowStep.name}' ${attemptLabel === "primary" ? "primary" : "fallback"} model timed out after ${Math.round(timeoutMs / 1e3)}s \u2014 aborting session`
+              );
+              try {
+                session.dispose();
+              } catch {
+              }
+              await agentLogger.flush();
+              return { success: false, error: `workflow step timed out after ${timeoutMs}ms`, timedOut: true };
+            }
+            checkSessionError(session);
+            await accumulateSessionTokenUsage(this.store, task.id, session);
+            session.dispose();
+            await agentLogger.flush();
+            const trimmedOutput = output.trim();
+            const revisionMatch = trimmedOutput.match(/^REQUEST REVISION\s*\n*/i);
+            if (revisionMatch) {
+              const feedbackStart = revisionMatch[0].length;
+              const feedback = trimmedOutput.slice(feedbackStart).trim();
+              return { success: false, revisionRequested: true, output: feedback };
+            }
+            return { success: true, output };
+          } catch (err) {
+            await agentLogger.flush();
+            try {
+              session.dispose();
+            } catch {
+            }
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            return { success: false, error: errorMessage };
+          } finally {
+            if (timeoutHandle) clearTimeout(timeoutHandle);
+            void timedOut;
           }
-          return { success: true, output };
-        } catch (err) {
-          const errorMessage = err instanceof Error ? err.message : String(err);
-          await agentLogger.flush();
-          return { success: false, error: errorMessage };
+        };
+        const primaryOutcome = await runOnce(primaryProvider, primaryModelId, "primary");
+        if (!primaryOutcome.timedOut) return primaryOutcome;
+        if (!fallback) {
+          executorLog.warn(`${task.id}: workflow step '${workflowStep.name}' timed out and no fallback model is configured`);
+          await this.store.logEntry(
+            task.id,
+            `Workflow step '${workflowStep.name}' timed out \u2014 no fallback model configured (set settings.validatorFallbackProvider/Id or fallbackProvider/Id)`
+          );
+          return primaryOutcome;
         }
+        executorLog.log(`${task.id}: retrying workflow step '${workflowStep.name}' with fallback ${fallback.provider}/${fallback.modelId} (label=${fallback.label})`);
+        return runOnce(fallback.provider, fallback.modelId, "fallback");
       }
       MAX_WORKTREE_RETRIES = 3;
       WORKTREE_RETRY_DELAYS = [100, 500, 1e3];
@@ -61879,7 +62834,13 @@ Review the work done in this worktree and evaluate it against the criteria in yo
         }
         for (let attempt = 0; attempt < this.MAX_WORKTREE_RETRIES; attempt++) {
           try {
-            return await this.tryCreateWorktree(branch, currentPath, taskId, resolvedStartPoint, attempt);
+            const result = await this.tryCreateWorktree(branch, currentPath, taskId, resolvedStartPoint, attempt);
+            await this.rebaseNewWorktreeOntoRemote(result.path, result.branch, taskId).catch((err) => {
+              executorLog.warn(
+                `Post-create worktree rebase failed for ${taskId} (continuing): ${err instanceof Error ? err.message : String(err)}`
+              );
+            });
+            return result;
           } catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
             const isLastAttempt = attempt === this.MAX_WORKTREE_RETRIES - 1;
@@ -61900,6 +62861,84 @@ Review the work done in this worktree and evaluate it against the criteria in yo
         }
         throw new Error("Unexpected exit from worktree creation retry loop");
       }
+      quoteShellArg(value) {
+        return `'${value.replace(/'/g, "'\\''")}'`;
+      }
+      /**
+       * After creating a fresh task worktree, fetch the configured remote and
+       * rebase the task branch onto `<remote>/<defaultBranch>`. The result is a
+       * branch that contains origin's tip plus any local main commits, so the
+       * eventual merge has fewer surprises and the executor sees the freshest
+       * code its peers/CI may have published.
+       *
+       * No-op when `worktreeRebaseBeforeMerge` is disabled, no remote is
+       * configured/resolvable, or the rebase produces conflicts (we abort and
+       * leave the worktree as-is so the executor can still run).
+       */
+      async rebaseNewWorktreeOntoRemote(worktreePath, branch, taskId) {
+        let settings;
+        try {
+          settings = await this.store.getSettings();
+        } catch {
+          return;
+        }
+        if (settings.worktreeRebaseBeforeMerge === false) return;
+        let remote = settings.worktreeRebaseRemote?.trim() || "";
+        if (!remote) {
+          try {
+            const { stdout } = await execAsync5("git remote", { cwd: this.rootDir });
+            const remotes = stdout.split("\n").map((s) => s.trim()).filter(Boolean);
+            if (remotes.includes("origin")) remote = "origin";
+            else if (remotes.length === 1) remote = remotes[0];
+          } catch {
+          }
+        }
+        if (!remote) return;
+        let defaultBranch = "";
+        try {
+          const { stdout } = await execAsync5(`git rev-parse --abbrev-ref ${remote}/HEAD`, { cwd: this.rootDir });
+          defaultBranch = stdout.trim().replace(new RegExp(`^${remote}/`), "");
+        } catch {
+        }
+        if (!defaultBranch) {
+          try {
+            const { stdout } = await execAsync5("git rev-parse --abbrev-ref HEAD", { cwd: this.rootDir });
+            defaultBranch = stdout.trim();
+          } catch {
+            return;
+          }
+        }
+        if (!defaultBranch || defaultBranch === "HEAD") return;
+        const remoteRef = `${remote}/${defaultBranch}`;
+        try {
+          await execAsync5(`git fetch ${this.quoteShellArg(remote)} ${this.quoteShellArg(defaultBranch)}`, { cwd: this.rootDir });
+        } catch (err) {
+          executorLog.warn(
+            `Worktree rebase: fetch ${remote} ${defaultBranch} failed for ${taskId}: ${err instanceof Error ? err.message : String(err)}`
+          );
+          return;
+        }
+        try {
+          await execAsync5(`git rebase ${this.quoteShellArg(remoteRef)}`, { cwd: worktreePath });
+          await this.store.logEntry(
+            taskId,
+            `Rebased new worktree branch ${branch} onto ${remoteRef}`
+          );
+        } catch (rebaseErr) {
+          const msg = rebaseErr instanceof Error ? rebaseErr.message : String(rebaseErr);
+          executorLog.warn(
+            `Worktree rebase: rebase onto ${remoteRef} failed for ${taskId} \u2014 aborting and leaving local base intact: ${msg}`
+          );
+          try {
+            await execAsync5("git rebase --abort", { cwd: worktreePath });
+          } catch {
+          }
+          await this.store.logEntry(
+            taskId,
+            `Could not rebase new worktree onto ${remoteRef} \u2014 kept local base. The merge-time rebase will retry with conflict resolution.`
+          );
+        }
+      }
       /**
        * Resolve a stored baseBranch to a concrete commit SHA.
        *
@@ -62631,6 +63670,7 @@ Child agent: ${agent.id} (${name})`;
               });
               const parentAgent = childTask.assignedAgentId ? await this.options.agentStore.getAgent(childTask.assignedAgentId).catch(() => null) : null;
               const childRuntimeHint = extractRuntimeHint(agent.runtimeConfig) ?? extractRuntimeHint(parentAgent?.runtimeConfig);
+              const { provider: childExecutorProvider, modelId: childExecutorModelId } = resolveExecutorModelPair2(void 0, void 0, settings);
               const { session: childSession } = await createResolvedAgentSession({
                 sessionPurpose: "executor",
                 runtimeHint: childRuntimeHint,
@@ -62638,8 +63678,8 @@ Child agent: ${agent.id} (${name})`;
                 cwd: childWorktreePath,
                 systemPrompt: childSystemPrompt,
                 tools: "coding",
-                defaultProvider: settings.defaultProvider,
-                defaultModelId: settings.defaultModelId,
+                defaultProvider: childExecutorProvider,
+                defaultModelId: childExecutorModelId,
                 fallbackProvider: settings.fallbackProvider,
                 fallbackModelId: settings.fallbackModelId,
                 // Skill selection: use assigned agent skills if available, otherwise role fallback
@@ -62735,6 +63775,25 @@ var init_mission_feature_sync = __esm({
   }
 });
 
+// ../engine/src/effective-node.ts
+function isSetNodeId(nodeId) {
+  return typeof nodeId === "string" && nodeId.trim().length > 0;
+}
+function resolveEffectiveNode(task, settings) {
+  if (isSetNodeId(task.nodeId)) {
+    return { nodeId: task.nodeId, source: "task-override" };
+  }
+  if (isSetNodeId(settings.defaultNodeId)) {
+    return { nodeId: settings.defaultNodeId, source: "project-default" };
+  }
+  return { nodeId: void 0, source: "local" };
+}
+var init_effective_node = __esm({
+  "../engine/src/effective-node.ts"() {
+    "use strict";
+  }
+});
+
 // ../engine/src/scheduler.ts
 import { existsSync as existsSync26 } from "node:fs";
 import { readFile as readFile15 } from "node:fs/promises";
@@ -62793,6 +63852,7 @@ var init_scheduler = __esm({
     init_logger2();
     init_mission_feature_sync();
     init_spec_staleness();
+    init_effective_node();
     Scheduler = class {
       /**
        * Async listener guard convention:
@@ -63216,14 +64276,19 @@ var init_scheduler = __esm({
               schedulerLog.log(`Task ${task.id} is paused \u2014 skipping dispatch`);
               continue;
             }
+            const effectiveNode = resolveEffectiveNode(freshTask, settings);
+            schedulerLog.log(`Task ${task.id} routed to node=${effectiveNode.nodeId ?? "local"} (source=${effectiveNode.source})`);
             schedulerLog.log(`Starting ${task.id}: ${task.title || task.id} (deps satisfied)`);
             await this.store.updateTask(task.id, {
               status: null,
               blockedBy: null,
               baseBranch: baseBranch ?? void 0,
-              worktree: plannedWorktree
+              worktree: plannedWorktree,
+              effectiveNodeId: effectiveNode.nodeId ?? null,
+              effectiveNodeSource: effectiveNode.source
             });
             await this.store.moveTask(task.id, "in-progress");
+            await this.store.logEntry(task.id, `Node routing resolved: ${effectiveNode.nodeId ?? "local"} (source: ${effectiveNode.source})`);
             this.options.onSchedule?.(task);
             started++;
             if (settings.groupOverlappingFiles) {
@@ -65679,6 +66744,453 @@ Please review the PR comments and address any remaining issues.`;
   }
 });
 
+// ../engine/src/notification/ntfy-provider.ts
+var SUPPORTED_EVENTS, NtfyNotificationProvider;
+var init_ntfy_provider = __esm({
+  "../engine/src/notification/ntfy-provider.ts"() {
+    "use strict";
+    init_notifier();
+    SUPPORTED_EVENTS = /* @__PURE__ */ new Set([
+      "in-review",
+      "merged",
+      "failed",
+      "awaiting-approval",
+      "awaiting-user-review",
+      "planning-awaiting-input"
+    ]);
+    NtfyNotificationProvider = class {
+      config;
+      abortController = null;
+      getProviderId() {
+        return "ntfy";
+      }
+      async initialize(config) {
+        if (typeof config.topic !== "string" || config.topic.trim() === "") {
+          return;
+        }
+        this.config = config;
+        this.config.events = resolveNtfyEvents(this.config.events);
+        this.abortController = new AbortController();
+      }
+      async shutdown() {
+        this.abortController?.abort();
+        this.abortController = null;
+      }
+      isEventSupported(event) {
+        if (!SUPPORTED_EVENTS.has(event)) {
+          return false;
+        }
+        const enabledEvents = this.config?.events ?? [...DEFAULT_NTFY_EVENTS];
+        return enabledEvents.includes(event);
+      }
+      async sendNotification(event, payload) {
+        if (!this.config?.topic) {
+          return { success: false, providerId: this.getProviderId(), error: "ntfy topic not configured" };
+        }
+        if (!this.isEventSupported(event)) {
+          return {
+            success: false,
+            providerId: this.getProviderId(),
+            error: `unsupported event: ${event}`
+          };
+        }
+        const taskLike = {
+          id: payload.taskId,
+          title: payload.taskTitle,
+          description: payload.taskDescription ?? ""
+        };
+        const identifier = formatTaskIdentifier(taskLike);
+        const clickUrl = buildNtfyClickUrl({
+          dashboardHost: this.config.dashboardHost,
+          projectId: this.config.projectId,
+          taskId: payload.taskId
+        });
+        const contentByEvent = {
+          "in-review": {
+            title: `Task ${payload.taskId} completed`,
+            message: `Task "${identifier}" is ready for review`,
+            priority: "default"
+          },
+          merged: {
+            title: `Task ${payload.taskId} merged`,
+            message: `Task "${identifier}" has been merged to main`,
+            priority: "default"
+          },
+          failed: {
+            title: `Task ${payload.taskId} failed`,
+            message: `Task "${identifier}" has failed and needs attention`,
+            priority: "high"
+          },
+          "awaiting-approval": {
+            title: `Plan needs approval for ${payload.taskId}`,
+            message: `Task "${identifier}" needs your approval before it can proceed`,
+            priority: "high"
+          },
+          "awaiting-user-review": {
+            title: `User review needed for ${payload.taskId}`,
+            message: `Task "${identifier}" needs human review before it can proceed`,
+            priority: "high"
+          },
+          "planning-awaiting-input": {
+            title: `Planning input needed for ${payload.taskId}`,
+            message: `Task "${identifier}" is awaiting your input during planning`,
+            priority: "high"
+          }
+        };
+        const content = contentByEvent[event];
+        await sendNtfyNotification({
+          ntfyBaseUrl: this.config.ntfyBaseUrl,
+          topic: this.config.topic,
+          title: content.title,
+          message: content.message,
+          priority: content.priority,
+          clickUrl,
+          signal: this.abortController?.signal
+        });
+        return { success: true, providerId: this.getProviderId() };
+      }
+    };
+  }
+});
+
+// ../engine/src/notification/webhook-provider.ts
+var WebhookNotificationProvider;
+var init_webhook_provider = __esm({
+  "../engine/src/notification/webhook-provider.ts"() {
+    "use strict";
+    init_logger2();
+    WebhookNotificationProvider = class {
+      config = null;
+      abortController = null;
+      getProviderId() {
+        return "webhook";
+      }
+      async initialize(config) {
+        const webhookUrl = typeof config.webhookUrl === "string" ? config.webhookUrl.trim() : "";
+        if (!webhookUrl) {
+          throw new Error("webhookUrl is required");
+        }
+        let parsedUrl;
+        try {
+          parsedUrl = new URL(webhookUrl);
+        } catch {
+          throw new Error("webhookUrl must be a valid URL");
+        }
+        if (parsedUrl.protocol !== "http:" && parsedUrl.protocol !== "https:") {
+          throw new Error("webhookUrl must use http:// or https://");
+        }
+        const webhookFormat = config.webhookFormat === "slack" || config.webhookFormat === "discord" || config.webhookFormat === "generic" ? config.webhookFormat : "generic";
+        this.config = {
+          webhookUrl,
+          webhookFormat,
+          events: Array.isArray(config.events) ? config.events.filter((event) => typeof event === "string") : []
+        };
+        this.abortController?.abort();
+        this.abortController = new AbortController();
+      }
+      async shutdown() {
+        this.abortController?.abort();
+        this.abortController = null;
+        this.config = null;
+      }
+      isEventSupported(event) {
+        if (!this.config?.events || this.config.events.length === 0) {
+          return true;
+        }
+        return this.config.events.includes(event);
+      }
+      async sendNotification(event, payload) {
+        if (!this.config) {
+          return { success: false, providerId: this.getProviderId(), error: "Not initialized" };
+        }
+        if (!this.isEventSupported(event)) {
+          return {
+            success: false,
+            providerId: this.getProviderId(),
+            error: `unsupported event: ${event}`
+          };
+        }
+        try {
+          const message = this.formatMessage(event, payload);
+          const body = this.formatPayload(payload, message);
+          const response = await fetch(this.config.webhookUrl, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json"
+            },
+            body: JSON.stringify(body),
+            signal: this.abortController?.signal
+          });
+          if (!response.ok) {
+            const error = `Webhook notification failed: ${response.status} ${response.statusText}`;
+            schedulerLog.log(error);
+            return {
+              success: false,
+              providerId: this.getProviderId(),
+              error
+            };
+          }
+          return { success: true, providerId: this.getProviderId() };
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          schedulerLog.log(`Failed to send webhook notification: ${message}`);
+          return {
+            success: false,
+            providerId: this.getProviderId(),
+            error: message
+          };
+        }
+      }
+      formatMessage(event, payload) {
+        const identifier = this.formatTaskIdentifier(payload);
+        switch (event) {
+          case "in-review":
+            return `Task "${identifier}" is ready for review`;
+          case "merged":
+            return `Task "${identifier}" has been merged to main`;
+          case "failed":
+            return `Task "${identifier}" has failed and needs attention`;
+          case "awaiting-approval":
+            return `Task "${identifier}" needs your approval before it can proceed`;
+          case "awaiting-user-review":
+            return `Task "${identifier}" needs human review before it can proceed`;
+          case "planning-awaiting-input":
+            return `Task "${identifier}" is awaiting your input during planning`;
+          case "gridlock":
+            return "Pipeline gridlocked";
+          default:
+            return `Event "${event}" for task ${identifier}`;
+        }
+      }
+      formatTaskIdentifier(payload) {
+        if (payload.taskTitle?.trim()) {
+          return payload.taskTitle;
+        }
+        const description = payload.taskDescription ?? "";
+        const snippet = description.length > 200 ? `${description.slice(0, 200)}...` : description;
+        return `${payload.taskId}: ${snippet}`;
+      }
+      formatPayload(payload, message) {
+        if (!this.config) {
+          return {};
+        }
+        if (this.config.webhookFormat === "slack") {
+          return { text: message };
+        }
+        if (this.config.webhookFormat === "discord") {
+          return { content: message };
+        }
+        return {
+          event: payload.event,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          task: {
+            id: payload.taskId,
+            title: payload.taskTitle
+          },
+          metadata: payload.metadata
+        };
+      }
+    };
+  }
+});
+
+// ../engine/src/notification/notification-service.ts
+var NotificationService;
+var init_notification_service = __esm({
+  "../engine/src/notification/notification-service.ts"() {
+    "use strict";
+    init_src();
+    init_notifier();
+    init_logger2();
+    init_ntfy_provider();
+    init_webhook_provider();
+    NotificationService = class {
+      constructor(store, options = {}) {
+        this.store = store;
+        this.options = options;
+      }
+      dispatcher = new NotificationDispatcher();
+      notifiedEvents = /* @__PURE__ */ new Set();
+      started = false;
+      notificationsEnabled = false;
+      ntfyProvider;
+      webhookProvider;
+      registerProvider(provider) {
+        this.dispatcher.registerProvider(provider);
+      }
+      async start() {
+        if (this.started) {
+          return;
+        }
+        const settings = await this.store.getSettings();
+        this.setNotificationsEnabledFromSettings(settings);
+        await this.syncNtfyProvider(settings);
+        await this.syncWebhookProvider(settings);
+        await this.dispatcher.initializeAll();
+        this.store.on("task:moved", this.handleTaskMoved);
+        this.store.on("task:updated", this.handleTaskUpdated);
+        this.store.on("task:merged", this.handleTaskMerged);
+        this.store.on("settings:updated", this.handleSettingsUpdated);
+        this.started = true;
+        schedulerLog.log("NotificationService started");
+      }
+      async stop() {
+        if (!this.started) {
+          return;
+        }
+        if (typeof this.store.off === "function") {
+          this.store.off("task:moved", this.handleTaskMoved);
+          this.store.off("task:updated", this.handleTaskUpdated);
+          this.store.off("task:merged", this.handleTaskMerged);
+          this.store.off("settings:updated", this.handleSettingsUpdated);
+        }
+        await this.dispatcher.shutdownAll();
+        this.started = false;
+        schedulerLog.log("NotificationService stopped");
+      }
+      handleTaskMoved = (data) => {
+        if (!this.notificationsEnabled || data.to !== "in-review") {
+          return;
+        }
+        const payload = this.createTaskPayload(data.task, "in-review");
+        this.maybeNotify(data.task.id, "in-review", payload);
+      };
+      handleTaskUpdated = (task) => {
+        if (!this.notificationsEnabled) {
+          return;
+        }
+        if (task.status === "failed") {
+          this.maybeNotify(task.id, "failed", this.createTaskPayload(task, "failed"));
+        }
+        if (task.status === "awaiting-approval") {
+          this.maybeNotify(
+            task.id,
+            "awaiting-approval",
+            this.createTaskPayload(task, "awaiting-approval")
+          );
+        }
+        if (task.status === "awaiting-user-review") {
+          this.maybeNotify(
+            task.id,
+            "awaiting-user-review",
+            this.createTaskPayload(task, "awaiting-user-review")
+          );
+        }
+      };
+      handleTaskMerged = (result) => {
+        if (!this.notificationsEnabled || !result.merged) {
+          return;
+        }
+        this.maybeNotify(
+          result.task.id,
+          "merged",
+          this.createTaskPayload(result.task, "merged")
+        );
+      };
+      handleSettingsUpdated = async (data) => {
+        const { settings, previous } = data;
+        this.setNotificationsEnabledFromSettings(settings);
+        if (settings.ntfyEnabled !== previous.ntfyEnabled || settings.ntfyTopic !== previous.ntfyTopic || settings.ntfyBaseUrl !== previous.ntfyBaseUrl || settings.ntfyDashboardHost !== previous.ntfyDashboardHost || JSON.stringify(settings.ntfyEvents) !== JSON.stringify(previous.ntfyEvents)) {
+          const wasEnabled = Boolean(previous.ntfyEnabled && previous.ntfyTopic);
+          const isEnabled = Boolean(settings.ntfyEnabled && settings.ntfyTopic);
+          await this.syncNtfyProvider(settings);
+          if (isEnabled && !wasEnabled) {
+            schedulerLog.log("NotificationService ntfy enabled");
+          } else if (!isEnabled && wasEnabled) {
+            schedulerLog.log("NotificationService ntfy disabled");
+          } else if (settings.ntfyTopic !== previous.ntfyTopic) {
+            schedulerLog.log("NotificationService ntfy topic updated");
+          } else if (settings.ntfyBaseUrl !== previous.ntfyBaseUrl) {
+            schedulerLog.log("NotificationService ntfy base URL updated");
+          } else if (settings.ntfyDashboardHost !== previous.ntfyDashboardHost) {
+            schedulerLog.log("NotificationService ntfy dashboard host updated");
+          } else if (JSON.stringify(settings.ntfyEvents) !== JSON.stringify(previous.ntfyEvents)) {
+            schedulerLog.log("NotificationService ntfy events updated");
+          }
+        }
+        if (settings.webhookEnabled !== previous.webhookEnabled || settings.webhookUrl !== previous.webhookUrl || settings.webhookFormat !== previous.webhookFormat || JSON.stringify(settings.webhookEvents) !== JSON.stringify(previous.webhookEvents)) {
+          await this.syncWebhookProvider(settings);
+          schedulerLog.log("WebhookNotificationProvider config updated");
+        }
+      };
+      async syncNtfyProvider(settings) {
+        const enabled = Boolean(settings.ntfyEnabled && settings.ntfyTopic);
+        if (!enabled) {
+          if (this.ntfyProvider) {
+            await this.ntfyProvider.shutdown?.();
+            this.dispatcher.unregisterProvider(this.ntfyProvider.getProviderId());
+            this.ntfyProvider = void 0;
+          }
+          return;
+        }
+        if (!this.ntfyProvider) {
+          this.ntfyProvider = new NtfyNotificationProvider();
+          this.registerProvider(this.ntfyProvider);
+        }
+        await this.ntfyProvider.initialize?.({
+          topic: settings.ntfyTopic,
+          ntfyBaseUrl: settings.ntfyBaseUrl ?? this.options.ntfyBaseUrl,
+          dashboardHost: settings.ntfyDashboardHost,
+          events: settings.ntfyEvents ?? [...DEFAULT_NTFY_EVENTS],
+          projectId: this.options.projectId
+        });
+      }
+      async syncWebhookProvider(settings) {
+        const enabled = Boolean(settings.webhookEnabled && settings.webhookUrl);
+        if (!enabled) {
+          if (this.webhookProvider) {
+            await this.webhookProvider.shutdown?.();
+            this.dispatcher.unregisterProvider(this.webhookProvider.getProviderId());
+            this.webhookProvider = void 0;
+          }
+          return;
+        }
+        if (!this.webhookProvider) {
+          this.webhookProvider = new WebhookNotificationProvider();
+          this.registerProvider(this.webhookProvider);
+        }
+        await this.webhookProvider.initialize?.({
+          webhookUrl: settings.webhookUrl,
+          webhookFormat: settings.webhookFormat ?? "generic",
+          events: settings.webhookEvents ?? []
+        });
+      }
+      setNotificationsEnabledFromSettings(settings) {
+        this.notificationsEnabled = Boolean(
+          settings.ntfyEnabled && settings.ntfyTopic || settings.webhookEnabled && settings.webhookUrl
+        );
+      }
+      createTaskPayload(task, event) {
+        return {
+          taskId: task.id,
+          taskTitle: task.title,
+          taskDescription: task.description,
+          event
+        };
+      }
+      maybeNotify(taskId, eventType, payload) {
+        const key = `${taskId}:${eventType}`;
+        if (this.notifiedEvents.has(key)) {
+          return;
+        }
+        this.notifiedEvents.add(key);
+        this.dispatcher.dispatch(eventType, payload).catch(() => {
+        });
+      }
+    };
+  }
+});
+
+// ../engine/src/notification/index.ts
+var init_notification = __esm({
+  "../engine/src/notification/index.ts"() {
+    "use strict";
+    init_ntfy_provider();
+    init_webhook_provider();
+    init_notification_service();
+  }
+});
+
 // ../engine/src/notifier.ts
 function formatTaskIdentifier(task) {
   if (task.title) {
@@ -65757,6 +67269,7 @@ var init_notifier = __esm({
   "../engine/src/notifier.ts"() {
     "use strict";
     init_logger2();
+    init_notification();
     DEFAULT_NTFY_BASE_URL = "https://ntfy.sh";
     DEFAULT_NTFY_EVENTS = [
       "in-review",
@@ -65764,7 +67277,8 @@ var init_notifier = __esm({
       "failed",
       "awaiting-approval",
       "awaiting-user-review",
-      "planning-awaiting-input"
+      "planning-awaiting-input",
+      "gridlock"
     ];
     NtfyNotifier = class {
       constructor(store, options = {}) {
@@ -65772,6 +67286,10 @@ var init_notifier = __esm({
         this.defaultNtfyBaseUrl = resolveNtfyBaseUrl(options.ntfyBaseUrl);
         this.ntfyBaseUrl = this.defaultNtfyBaseUrl;
         this.projectId = options.projectId;
+        this.notificationService = new NotificationService(store, {
+          projectId: this.projectId,
+          ntfyBaseUrl: options.ntfyBaseUrl
+        });
       }
       config = {
         enabled: false,
@@ -65779,6 +67297,7 @@ var init_notifier = __esm({
         dashboardHost: void 0,
         events: [...DEFAULT_NTFY_EVENTS]
       };
+      notificationService;
       ntfyBaseUrl;
       defaultNtfyBaseUrl;
       projectId;
@@ -65788,154 +67307,23 @@ var init_notifier = __esm({
         this.abortController = new AbortController();
         const settings = await this.store.getSettings();
         this.loadConfig(settings);
-        this.store.on("task:moved", this.handleTaskMoved);
-        this.store.on("task:updated", this.handleTaskUpdated);
-        this.store.on("task:merged", this.handleTaskMerged);
         this.store.on("settings:updated", this.handleSettingsUpdated);
+        await this.notificationService.start();
         schedulerLog.log("NtfyNotifier started");
       }
       stop() {
         if (typeof this.store.off === "function") {
-          this.store.off("task:moved", this.handleTaskMoved);
-          this.store.off("task:updated", this.handleTaskUpdated);
-          this.store.off("task:merged", this.handleTaskMerged);
           this.store.off("settings:updated", this.handleSettingsUpdated);
         }
         if (this.abortController) {
           this.abortController.abort();
           this.abortController = null;
         }
+        void this.notificationService.stop();
         schedulerLog.log("NtfyNotifier stopped");
       }
-      handleTaskMoved = (data) => {
-        if (!this.config.enabled || !this.config.topic) return;
-        const { task, to } = data;
-        if (to === "in-review" && this.isEventEnabled("in-review")) {
-          const clickUrl = buildNtfyClickUrl({
-            dashboardHost: this.config.dashboardHost,
-            projectId: this.projectId,
-            taskId: task.id
-          });
-          this.maybeNotify(
-            task.id,
-            "in-review",
-            () => sendNtfyNotification({
-              ntfyBaseUrl: this.ntfyBaseUrl,
-              topic: this.config.topic,
-              title: `Task ${task.id} completed`,
-              message: `Task "${formatTaskIdentifier(task)}" is ready for review`,
-              priority: "default",
-              clickUrl,
-              signal: this.abortController?.signal
-            })
-          );
-        }
-      };
-      handleTaskUpdated = (task) => {
-        if (!this.config.enabled || !this.config.topic) return;
-        if (task.status === "failed" && this.isEventEnabled("failed")) {
-          const clickUrl = buildNtfyClickUrl({
-            dashboardHost: this.config.dashboardHost,
-            projectId: this.projectId,
-            taskId: task.id
-          });
-          this.maybeNotify(
-            task.id,
-            "failed",
-            () => sendNtfyNotification({
-              ntfyBaseUrl: this.ntfyBaseUrl,
-              topic: this.config.topic,
-              title: `Task ${task.id} failed`,
-              message: `Task "${formatTaskIdentifier(task)}" has failed and needs attention`,
-              priority: "high",
-              clickUrl,
-              signal: this.abortController?.signal
-            })
-          );
-        }
-        if (task.status === "awaiting-approval" && this.isEventEnabled("awaiting-approval")) {
-          const clickUrl = buildNtfyClickUrl({
-            dashboardHost: this.config.dashboardHost,
-            projectId: this.projectId,
-            taskId: task.id
-          });
-          this.maybeNotify(
-            task.id,
-            "awaiting-approval",
-            () => sendNtfyNotification({
-              ntfyBaseUrl: this.ntfyBaseUrl,
-              topic: this.config.topic,
-              title: `Plan needs approval for ${task.id}`,
-              message: `Task "${formatTaskIdentifier(task)}" needs your approval before it can proceed`,
-              priority: "high",
-              clickUrl,
-              signal: this.abortController?.signal
-            })
-          );
-        }
-        if (task.status === "awaiting-user-review" && this.isEventEnabled("awaiting-user-review")) {
-          const clickUrl = buildNtfyClickUrl({
-            dashboardHost: this.config.dashboardHost,
-            projectId: this.projectId,
-            taskId: task.id
-          });
-          this.maybeNotify(
-            task.id,
-            "awaiting-user-review",
-            () => sendNtfyNotification({
-              ntfyBaseUrl: this.ntfyBaseUrl,
-              topic: this.config.topic,
-              title: `User review needed for ${task.id}`,
-              message: `Task "${formatTaskIdentifier(task)}" needs human review before it can proceed`,
-              priority: "high",
-              clickUrl,
-              signal: this.abortController?.signal
-            })
-          );
-        }
-      };
-      handleTaskMerged = (result) => {
-        if (!this.config.enabled || !this.config.topic) return;
-        if (result.merged && this.isEventEnabled("merged")) {
-          const clickUrl = buildNtfyClickUrl({
-            dashboardHost: this.config.dashboardHost,
-            projectId: this.projectId,
-            taskId: result.task.id
-          });
-          this.maybeNotify(
-            result.task.id,
-            "merged",
-            () => sendNtfyNotification({
-              ntfyBaseUrl: this.ntfyBaseUrl,
-              topic: this.config.topic,
-              title: `Task ${result.task.id} merged`,
-              message: `Task "${formatTaskIdentifier(result.task)}" has been merged to main`,
-              priority: "default",
-              clickUrl,
-              signal: this.abortController?.signal
-            })
-          );
-        }
-      };
       handleSettingsUpdated = (data) => {
-        const { settings, previous } = data;
-        if (settings.ntfyEnabled !== previous.ntfyEnabled || settings.ntfyTopic !== previous.ntfyTopic || settings.ntfyBaseUrl !== previous.ntfyBaseUrl || settings.ntfyDashboardHost !== previous.ntfyDashboardHost || JSON.stringify(settings.ntfyEvents) !== JSON.stringify(previous.ntfyEvents)) {
-          const wasEnabled = this.config.enabled;
-          this.loadConfig(settings);
-          if (this.config.enabled && !wasEnabled) {
-            schedulerLog.log("NtfyNotifier enabled");
-          } else if (!this.config.enabled && wasEnabled) {
-            schedulerLog.log("NtfyNotifier disabled");
-          } else if (this.config.topic !== previous.ntfyTopic) {
-            schedulerLog.log("NtfyNotifier topic updated");
-          } else if (this.ntfyBaseUrl !== resolveNtfyBaseUrl(previous.ntfyBaseUrl)) {
-            schedulerLog.log("NtfyNotifier base URL updated");
-          } else if (this.config.dashboardHost !== previous.ntfyDashboardHost) {
-            schedulerLog.log("NtfyNotifier dashboard host updated");
-          } else if (JSON.stringify(this.config.events) !== JSON.stringify(previous.ntfyEvents)) {
-            schedulerLog.log("NtfyNotifier events updated");
-          }
-        }
+        this.loadConfig(data.settings);
       };
       loadConfig(settings) {
         this.config = {
@@ -65946,11 +67334,38 @@ var init_notifier = __esm({
         };
         this.ntfyBaseUrl = resolveNtfyBaseUrl(settings.ntfyBaseUrl, this.defaultNtfyBaseUrl);
       }
+      notifyGridlock(event) {
+        if (!this.config.enabled || !this.config.topic || !this.isEventEnabled("gridlock")) return;
+        const blockedTasks = event.blockedTaskIds.sort();
+        const reasonSummary = Object.values(event.reasons).reduce((acc, reason) => {
+          acc[reason] = (acc[reason] ?? 0) + 1;
+          return acc;
+        }, {});
+        const reasons = [];
+        if (reasonSummary.dependency) reasons.push(`${reasonSummary.dependency} dependency`);
+        if (reasonSummary.overlap) reasons.push(`${reasonSummary.overlap} overlap`);
+        const clickUrl = buildNtfyClickUrl({
+          dashboardHost: this.config.dashboardHost,
+          projectId: this.projectId
+        });
+        const dedupKey = `gridlock:${blockedTasks.join(",")}`;
+        this.maybeNotifyByKey(
+          dedupKey,
+          () => sendNtfyNotification({
+            ntfyBaseUrl: this.ntfyBaseUrl,
+            topic: this.config.topic,
+            title: "Pipeline gridlocked",
+            message: `${event.blockedTaskCount} todo tasks are blocked (${reasons.join(", ")}). Blocked: ${blockedTasks.join(", ")}. Blocking: ${event.blockingTaskIds.join(", ") || "none"}.`,
+            priority: "high",
+            clickUrl,
+            signal: this.abortController?.signal
+          })
+        );
+      }
       isEventEnabled(event) {
         return isNtfyEventEnabled(this.config.events, event);
       }
-      maybeNotify(taskId, eventType, notifyFn) {
-        const key = `${taskId}:${eventType}`;
+      maybeNotifyByKey(key, notifyFn) {
         if (this.notifiedEvents.has(key)) {
           return;
         }
@@ -65978,11 +67393,10 @@ var init_shell_utils = __esm({
 import { exec as exec6 } from "node:child_process";
 import { promisify as promisify7 } from "node:util";
 async function createAiPromptExecutor(cwd) {
-  const { createFnAgent: createFnAgent5, promptWithFallback: promptWithFallback2 } = await Promise.resolve().then(() => (init_pi(), pi_exports));
   const disposeLog = createLogger2("cron-runner");
   return async (prompt, modelProvider, modelId) => {
     let responseText = "";
-    const { session } = await createFnAgent5({
+    const { session } = await createFnAgent2({
       cwd,
       systemPrompt: AI_AUTOMATION_SYSTEM_PROMPT,
       tools: "readonly",
@@ -65993,7 +67407,7 @@ async function createAiPromptExecutor(cwd) {
       }
     });
     try {
-      await promptWithFallback2(session, prompt);
+      await promptWithFallback(session, prompt);
       return responseText;
     } finally {
       try {
@@ -66019,8 +67433,10 @@ var execAsync6, log6, DEFAULT_TIMEOUT_MS, MAX_BUFFER, MAX_OUTPUT_LENGTH, DEFAULT
 var init_cron_runner = __esm({
   "../engine/src/cron-runner.ts"() {
     "use strict";
+    init_src();
     init_logger2();
     init_shell_utils();
+    init_pi();
     execAsync6 = promisify7(exec6);
     log6 = createLogger2("cron-runner");
     DEFAULT_TIMEOUT_MS = 5 * 60 * 1e3;
@@ -66343,8 +67759,9 @@ var init_cron_runner = __esm({
           };
         }
         const settings = await this.store.getSettings();
-        const modelProvider = step.modelProvider?.trim() || settings.defaultProvider;
-        const modelId = step.modelId?.trim() || settings.defaultModelId;
+        const defaultModel = resolveProjectDefaultModel(settings);
+        const modelProvider = step.modelProvider?.trim() || defaultModel.provider;
+        const modelId = step.modelId?.trim() || defaultModel.modelId;
         const model = modelProvider && modelId ? `${modelProvider}/${modelId}` : "default";
         log6.log(`    AI prompt step "${step.name}" using model: ${model}`);
         log6.log(`    Prompt: ${step.prompt.slice(0, 100)}${step.prompt.length > 100 ? "\u2026" : ""}`);
@@ -67341,6 +68758,7 @@ var init_agent_heartbeat = __esm({
     init_agent_instructions();
     init_logger2();
     init_run_audit();
+    init_pi();
     HEARTBEAT_SYSTEM_PROMPT = `You are a heartbeat agent running in a short execution window.
 
 Your job:
@@ -68056,7 +69474,6 @@ When sending messages:
                 };
                 const previousBlockedState = await this.store.getLastBlockedState(agentId);
                 if (previousBlockedState && isBlockedStateDuplicate(currentBlockedState, previousBlockedState)) {
-                  heartbeatLog.log(`Task ${resolvedTaskId2} is still blocked by ${blockedBy} (duplicate state) \u2014 skipping comment`);
                   await this.completeRun(agentId, run.id, {
                     status: "completed",
                     resultJson: { reason: "blocked_duplicate", taskId: resolvedTaskId2, blockedBy }
@@ -68108,7 +69525,6 @@ When sending messages:
                 };
               }
             };
-            const { promptWithFallback: promptWithFallback2 } = await Promise.resolve().then(() => (init_pi(), pi_exports));
             const { createResolvedAgentSession: createResolvedAgentSession2, extractRuntimeHint: extractRuntimeHint2 } = await Promise.resolve().then(() => (init_agent_session_helpers(), agent_session_helpers_exports));
             const { buildSessionSkillContextSync: buildSessionSkillContextSync2 } = await Promise.resolve().then(() => (init_session_skill_context(), session_skill_context_exports));
             let heartbeatTools;
@@ -68302,7 +69718,7 @@ ${taskDetail.prompt}` : "No PROMPT.md available.",
                   "Review the task status and take appropriate action. Call fn_heartbeat_done when finished."
                 ].join("\n");
               }
-              await promptWithFallback2(session, executionPrompt);
+              await promptWithFallback(session, executionPrompt);
               let usageInput = 0;
               let usageOutput = Math.ceil(outputLength / 4);
               let usageCached = 0;
@@ -69155,13 +70571,40 @@ var init_self_healing = __esm({
         return Date.now() - updatedAt >= timeoutMs;
       }
       async findLandedTaskCommit(task) {
-        const readLog = async (range) => {
+        const storedSha = task.mergeDetails?.commitSha;
+        if (storedSha) {
+          try {
+            await execAsync8(
+              `git merge-base --is-ancestor ${shellQuote(storedSha)} HEAD`,
+              { cwd: this.options.rootDir }
+            );
+            const { stdout: stdout2 } = await execAsync8(
+              `git log -1 --format=%H%x1f%s ${shellQuote(storedSha)}`,
+              { cwd: this.options.rootDir, maxBuffer: 1024 * 1024 }
+            );
+            const [sha2, subject2] = stdout2.trim().split("");
+            if (sha2) {
+              const commit2 = { sha: sha2, subject: subject2 };
+              try {
+                const stats = await execAsync8(`git show --shortstat --format= ${shellQuote(sha2)}`, {
+                  cwd: this.options.rootDir,
+                  maxBuffer: 1024 * 1024
+                });
+                Object.assign(commit2, parseShortstat(stats.stdout));
+              } catch {
+              }
+              return commit2;
+            }
+          } catch {
+          }
+        }
+        const readLog = async (range, grepArg, fixedStrings) => {
           const command = [
             "git log",
             "--format=%H%x1f%s",
             "--max-count=20",
-            "--fixed-strings",
-            `--grep=${shellQuote(task.id)}`,
+            ...fixedStrings ? ["--fixed-strings"] : ["-E"],
+            `--grep=${grepArg}`,
             shellQuote(range)
           ].join(" ");
           return execAsync8(command, {
@@ -69169,22 +70612,34 @@ var init_self_healing = __esm({
             maxBuffer: 1024 * 1024
           });
         };
-        let stdout;
-        try {
-          const result = await readLog(task.baseCommitSha ? `${task.baseCommitSha}..HEAD` : "HEAD");
-          stdout = result.stdout;
-        } catch (err) {
-          const errorMessage = err instanceof Error ? err.message : String(err);
-          log8.warn(
-            `Failed to read git log for landed commit lookup (${task.id}): ${errorMessage} \u2014 retrying with HEAD range`
-          );
-          if (!task.baseCommitSha) return null;
-          const result = await readLog("HEAD");
-          stdout = result.stdout;
-        }
-        if (!stdout.trim() && task.baseCommitSha) {
-          const result = await readLog("HEAD");
-          stdout = result.stdout;
+        const search = async (grepArg, fixedStrings) => {
+          let out;
+          try {
+            const r = await readLog(
+              task.baseCommitSha ? `${task.baseCommitSha}..HEAD` : "HEAD",
+              grepArg,
+              fixedStrings
+            );
+            out = r.stdout;
+          } catch (err) {
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            log8.warn(
+              `Failed to read git log for landed commit lookup (${task.id}): ${errorMessage} \u2014 retrying with HEAD range`
+            );
+            if (!task.baseCommitSha) return "";
+            const r = await readLog("HEAD", grepArg, fixedStrings);
+            out = r.stdout;
+          }
+          if (!out.trim() && task.baseCommitSha) {
+            const r = await readLog("HEAD", grepArg, fixedStrings);
+            out = r.stdout;
+          }
+          return out;
+        };
+        const trailerPattern = `^Fusion-Task-Id: ${task.id}$`;
+        let stdout = await search(shellQuote(trailerPattern), false);
+        if (!stdout.trim()) {
+          stdout = await search(shellQuote(task.id), true);
         }
         const firstLine = stdout.trim().split("\n").find(Boolean);
         if (!firstLine) return null;
@@ -69564,7 +71019,7 @@ var init_self_healing = __esm({
           if (!timeoutMs || timeoutMs <= 0) return 0;
           const tasks = await this.store.listTasks({ column: "in-review", slim: true });
           const candidates = tasks.filter(
-            (task) => task.column === "in-review" && Boolean(task.status && ACTIVE_MERGE_STATUSES.has(task.status)) && this.isPastInterruptedMergeGrace(task, timeoutMs)
+            (task) => task.column === "in-review" && !task.paused && Boolean(task.status && ACTIVE_MERGE_STATUSES.has(task.status)) && this.isPastInterruptedMergeGrace(task, timeoutMs)
           );
           if (candidates.length === 0) return 0;
           log8.warn(`Found ${candidates.length} stale merging task(s) in in-review`);
@@ -69605,6 +71060,13 @@ var init_self_healing = __esm({
                 "Auto-recovered: stale merge status cleared; merge will be retried"
               );
               log8.log(`Recovered interrupted merge ${task.id}: cleared stale status for retry`);
+              try {
+                this.options.enqueueMerge?.(task.id);
+              } catch (enqueueErr) {
+                log8.warn(
+                  `Failed to re-enqueue ${task.id} after stale-merge recovery (will rely on polling sweep): ${enqueueErr instanceof Error ? enqueueErr.message : String(enqueueErr)}`
+                );
+              }
               recovered++;
             } catch (err) {
               const errorMessage = err instanceof Error ? err.message : String(err);
@@ -69635,7 +71097,7 @@ var init_self_healing = __esm({
         try {
           const tasks = await this.store.listTasks({ column: "in-review", slim: true });
           const mergedButNotDone = tasks.filter(
-            (t) => t.column === "in-review" && t.mergeDetails?.mergeConfirmed === true
+            (t) => t.column === "in-review" && !t.paused && t.mergeDetails?.mergeConfirmed === true
           );
           if (mergedButNotDone.length === 0) return 0;
           log8.warn(`Found ${mergedButNotDone.length} merged task(s) stuck in in-review`);
@@ -69683,7 +71145,7 @@ var init_self_healing = __esm({
         try {
           const tasks = await this.store.listTasks({ column: "in-review", slim: true });
           const misclassified = tasks.filter(
-            (t) => t.column === "in-review" && t.status === "failed" && t.error?.includes("without calling task_done") && t.steps.length > 0 && t.steps.every((s) => s.status === "done" || s.status === "skipped")
+            (t) => t.column === "in-review" && !t.paused && t.status === "failed" && t.error?.includes("without calling task_done") && t.steps.length > 0 && t.steps.every((s) => s.status === "done" || s.status === "skipped")
           );
           if (misclassified.length === 0) return 0;
           log8.warn(`Found ${misclassified.length} misclassified failure(s) with all steps done`);
@@ -70803,6 +72265,12 @@ var init_in_process_runtime = __esm({
       ephemeralCleanupTimers = /* @__PURE__ */ new Map();
       /** Listener for agent:stateChanged events to clean up terminated ephemeral agents */
       ephemeralTerminationListener;
+      /**
+       * Optional callback the runtime forwards to SelfHealingManager so that
+       * stale-merge recovery can re-enqueue tasks immediately. Set by ProjectEngine
+       * before `start()` via `setMergeEnqueuer`.
+       */
+      mergeEnqueuer;
       /**
        * Start the runtime and initialize all subsystems.
        *
@@ -70923,8 +72391,7 @@ var init_in_process_runtime = __esm({
               this.recordActivity();
               runtimeLog.log(`Scheduled task ${task.id}`);
             },
-            onBlocked: (task, blockedBy) => {
-              runtimeLog.log(`Task ${task.id} blocked by: ${blockedBy.join(", ")}`);
+            onBlocked: () => {
             }
           });
           this.stuckTaskDetector = new StuckTaskDetector(this.taskStore, {
@@ -71244,7 +72711,8 @@ var init_in_process_runtime = __esm({
             getExecutingTaskIds: () => this.executor.getExecutingTaskIds(),
             recoverApprovedTriageTask: (task) => this.triageProcessor?.recoverApprovedTask(task) ?? Promise.resolve(false),
             getPlanningTaskIds: () => this.triageProcessor?.getProcessingTaskIds() ?? /* @__PURE__ */ new Set(),
-            evictStaleTriageProcessing: () => this.triageProcessor?.evictStaleProcessing() ?? /* @__PURE__ */ new Set()
+            evictStaleTriageProcessing: () => this.triageProcessor?.evictStaleProcessing() ?? /* @__PURE__ */ new Set(),
+            enqueueMerge: this.mergeEnqueuer ? (taskId) => this.mergeEnqueuer?.(taskId) : void 0
           });
           this.selfHealingManager.start();
           this.stuckTaskDetector.start();
@@ -71421,6 +72889,14 @@ var init_in_process_runtime = __esm({
       getStatus() {
         return this.status;
       }
+      /**
+       * Register a callback used by SelfHealingManager to re-enqueue tasks for
+       * auto-merge after clearing a stale `merging` status. Must be called before
+       * `start()` because SelfHealingManager is constructed during startup.
+       */
+      setMergeEnqueuer(enqueueMerge) {
+        this.mergeEnqueuer = enqueueMerge;
+      }
       /**
        * Get the project's TaskStore instance.
        * @throws Error if runtime has not been started
@@ -73190,6 +74666,132 @@ var init_project_manager = __esm({
   }
 });
 
+// ../engine/src/gridlock-detector.ts
+var gridlockLog, GridlockDetector;
+var init_gridlock_detector = __esm({
+  "../engine/src/gridlock-detector.ts"() {
+    "use strict";
+    init_logger2();
+    init_scheduler();
+    gridlockLog = createLogger2("gridlock-detector");
+    GridlockDetector = class {
+      constructor(store, options = {}) {
+        this.store = store;
+        this.pollIntervalMs = options.pollIntervalMs ?? 3e4;
+        this.missionStore = options.missionStore;
+        this.onGridlock = options.onGridlock;
+      }
+      interval = null;
+      pollIntervalMs;
+      missionStore;
+      onGridlock;
+      lastGridlockKey = null;
+      start() {
+        if (this.interval) return;
+        this.interval = setInterval(() => {
+          this.detectGridlock().catch((error) => {
+            gridlockLog.error("Failed gridlock detection cycle:", error);
+          });
+        }, this.pollIntervalMs);
+        gridlockLog.log(`Started (poll interval: ${this.pollIntervalMs}ms)`);
+      }
+      stop() {
+        if (!this.interval) return;
+        clearInterval(this.interval);
+        this.interval = null;
+        gridlockLog.log("Stopped");
+      }
+      async detectGridlock() {
+        const [tasks, settings] = await Promise.all([
+          this.store.listTasks({ slim: true, includeArchived: false }),
+          this.store.getSettings()
+        ]);
+        const now = Date.now();
+        const schedulable = tasks.filter((task) => {
+          if (task.column !== "todo" || task.paused) return false;
+          if (task.nextRecoveryAt && new Date(task.nextRecoveryAt).getTime() > now) return false;
+          if (this.isMissionBlocked(task)) return false;
+          return true;
+        });
+        if (schedulable.length === 0) {
+          this.lastGridlockKey = null;
+          return null;
+        }
+        const active = tasks.filter((task) => task.column === "in-progress" || task.column === "in-review" && Boolean(task.worktree));
+        if (active.length === 0) {
+          this.lastGridlockKey = null;
+          return null;
+        }
+        const overlapIgnorePaths = settings.overlapIgnorePaths ?? [];
+        const activeScopes = /* @__PURE__ */ new Map();
+        if (settings.groupOverlappingFiles) {
+          for (const task of active) {
+            const scope = filterPathsByIgnoreList(await this.store.parseFileScopeFromPrompt(task.id), overlapIgnorePaths);
+            if (scope.length > 0) {
+              activeScopes.set(task.id, scope);
+            }
+          }
+        }
+        const reasons = {};
+        const blockingTaskIds = /* @__PURE__ */ new Set();
+        for (const task of schedulable) {
+          const unmetDeps = task.dependencies.filter((depId) => {
+            const dep = tasks.find((candidate) => candidate.id === depId);
+            return dep && dep.column !== "done" && dep.column !== "in-review" && dep.column !== "archived";
+          });
+          if (unmetDeps.length > 0) {
+            reasons[task.id] = "dependency";
+            for (const depId of unmetDeps) blockingTaskIds.add(depId);
+            continue;
+          }
+          if (!settings.groupOverlappingFiles) continue;
+          const taskScope = filterPathsByIgnoreList(await this.store.parseFileScopeFromPrompt(task.id), overlapIgnorePaths);
+          if (taskScope.length === 0) continue;
+          for (const [activeId, activeScope] of activeScopes) {
+            if (pathsOverlap2(taskScope, activeScope)) {
+              reasons[task.id] = "overlap";
+              blockingTaskIds.add(activeId);
+              break;
+            }
+          }
+        }
+        const blockedTaskIds = Object.keys(reasons).sort();
+        if (blockedTaskIds.length !== schedulable.length) {
+          this.lastGridlockKey = null;
+          return null;
+        }
+        const gridlockKey = blockedTaskIds.join(",");
+        const event = {
+          blockedTaskCount: blockedTaskIds.length,
+          reasons,
+          blockedTaskIds,
+          blockingTaskIds: Array.from(blockingTaskIds).sort()
+        };
+        if (this.lastGridlockKey !== gridlockKey) {
+          this.lastGridlockKey = gridlockKey;
+          gridlockLog.warn(`Gridlock detected: blocked=${event.blockedTaskIds.join(",")}; blocking=${event.blockingTaskIds.join(",")}`);
+          this.onGridlock?.(event);
+        }
+        return event;
+      }
+      isMissionBlocked(task) {
+        if (!this.missionStore || !task.sliceId) return false;
+        try {
+          const slice = this.missionStore.getSlice(task.sliceId);
+          if (!slice) return false;
+          const milestone = this.missionStore.getMilestone(slice.milestoneId);
+          if (!milestone) return false;
+          const mission = this.missionStore.getMission(milestone.missionId);
+          return mission?.status === "blocked";
+        } catch (error) {
+          gridlockLog.warn(`Mission lookup failed for ${task.id}:`, error);
+          return false;
+        }
+      }
+    };
+  }
+});
+
 // ../engine/src/remote-access/provider-adapters.ts
 import { accessSync, constants as fsConstants } from "node:fs";
 function isAbsoluteOrPathLike(input) {
@@ -73772,6 +75374,8 @@ var init_project_engine = __esm({
     init_pr_monitor();
     init_pr_comment_handler();
     init_notifier();
+    init_notification();
+    init_gridlock_detector();
     init_cron_runner();
     init_merger();
     init_concurrency();
@@ -73785,11 +75389,24 @@ var init_project_engine = __esm({
         this.options = options;
         const runtimeConfig = options.externalTaskStore ? { ...config, externalTaskStore: options.externalTaskStore } : config;
         this.runtime = new InProcessRuntime(runtimeConfig, centralCore);
+        this.runtime.setMergeEnqueuer?.((taskId) => {
+          if (this.activeMergeTaskId === taskId) {
+            this.mergeAbortController?.abort();
+            this.mergeAbortController = null;
+            this.activeMergeSession?.dispose();
+            this.activeMergeSession = null;
+            this.activeMergeTaskId = null;
+          }
+          this.mergeActive.delete(taskId);
+          this.internalEnqueueMerge(taskId);
+        });
       }
       runtime;
       prMonitor;
       prCommentHandler;
       notifier;
+      notificationService;
+      gridlockDetector;
       cronRunner;
       automationStore;
       remoteTunnelManager;
@@ -73854,12 +75471,21 @@ var init_project_engine = __esm({
           (taskId, prInfo, comments) => this.prCommentHandler.handleNewComments(taskId, prInfo, comments)
         );
         if (!this.options.skipNotifier) {
+          this.notificationService = new NotificationService(store, {
+            projectId: this.options.projectId,
+            ntfyBaseUrl: this.options.ntfyBaseUrl
+          });
+          await this.notificationService.start();
           this.notifier = new NtfyNotifier(store, {
             projectId: this.options.projectId,
             ntfyBaseUrl: this.options.ntfyBaseUrl
           });
           await this.notifier.start();
         }
+        this.gridlockDetector = new GridlockDetector(store, {
+          onGridlock: (event) => this.notifier?.notifyGridlock(event)
+        });
+        this.gridlockDetector.start();
         this.setAutomationSubsystemHealth(
           "initializing",
           "Initializing AutomationStore and CronRunner"
@@ -73990,7 +75616,9 @@ ${detail}`
           }
         } catch {
         }
+        this.notificationService?.stop();
         this.notifier?.stop();
+        this.gridlockDetector?.stop();
         this.cronRunner?.stop();
         this.setAutomationSubsystemHealth("not-initialized", "Automation subsystem stopped");
         const tunnelManager = this.remoteTunnelManager;
@@ -75809,6 +77437,8 @@ __export(src_exports2, {
   MissionAutopilot: () => MissionAutopilot,
   MissionExecutionLoop: () => MissionExecutionLoop,
   NodeHealthMonitor: () => NodeHealthMonitor,
+  NotificationService: () => NotificationService,
+  NtfyNotificationProvider: () => NtfyNotificationProvider,
   NtfyNotifier: () => NtfyNotifier,
   PRIORITY_EXECUTE: () => PRIORITY_EXECUTE,
   PRIORITY_MERGE: () => PRIORITY_MERGE,
@@ -75833,6 +77463,7 @@ __export(src_exports2, {
   TriageProcessor: () => TriageProcessor,
   TunnelProcessManager: () => TunnelProcessManager,
   UsageLimitPauser: () => UsageLimitPauser,
+  WebhookNotificationProvider: () => WebhookNotificationProvider,
   WorktreePool: () => WorktreePool,
   aiMergeTask: () => aiMergeTask,
   buildAgentChatPrompt: () => buildAgentChatPrompt,
@@ -75851,6 +77482,7 @@ __export(src_exports2, {
   createTaskLogTool: () => createTaskLogTool,
   describeAgentModel: () => describeAgentModel,
   describeModel: () => describeModel,
+  formatTaskIdentifier: () => formatTaskIdentifier,
   getDefaultPiRuntime: () => getDefaultPiRuntime,
   getHostExtensionPaths: () => getHostExtensionPaths,
   getTunnelProviderAdapter: () => getTunnelProviderAdapter,
@@ -75902,6 +77534,7 @@ var init_src2 = __esm({
     init_pr_monitor();
     init_pr_comment_handler();
     init_notifier();
+    init_notification();
     init_cron_runner();
     init_routine_runner();
     init_routine_scheduler();
@@ -76087,6 +77720,7 @@ async function ensureNtfyHelpersReady() {
   }
   try {
     const engine = await Promise.resolve().then(() => (init_src2(), src_exports2));
+    const hasNotificationService = "NotificationService" in engine && typeof engine.NotificationService === "function";
     const hasAllHelpers = "isNtfyEventEnabled" in engine && "buildNtfyClickUrl" in engine && "sendNtfyNotification" in engine && typeof engine.isNtfyEventEnabled === "function" && typeof engine.buildNtfyClickUrl === "function" && typeof engine.sendNtfyNotification === "function";
     if (!hasAllHelpers) {
       return;
@@ -76096,6 +77730,12 @@ async function ensureNtfyHelpersReady() {
       buildNtfyClickUrl: engine.buildNtfyClickUrl,
       sendNtfyNotification: engine.sendNtfyNotification
     };
+    if (hasNotificationService) {
+      diagnostics.info(
+        "NotificationService abstraction detected in engine",
+        { operation: "notification-service-detection" }
+      );
+    }
   } catch {
   }
 }
@@ -76118,6 +77758,11 @@ function cleanupInMemorySession(sessionId) {
   if (!session) {
     return false;
   }
+  const activeGeneration = activeGenerations.get(sessionId);
+  if (activeGeneration) {
+    clearTimeout(activeGeneration.timer);
+    activeGenerations.delete(sessionId);
+  }
   if (session.agent) {
     try {
       session.agent.session.dispose?.();
@@ -76451,109 +78096,157 @@ async function maybeNotifyPlanningAwaitingInput(session, question) {
     });
   }
 }
+function setSessionError(session, message) {
+  session.error = message;
+  session.updatedAt = /* @__PURE__ */ new Date();
+  persistSession(session, "error", message);
+  planningStreamManager.broadcast(session.id, {
+    type: "error",
+    data: message
+  });
+}
+function createAbortError() {
+  const error = new Error("Generation aborted");
+  error.name = "AbortError";
+  return error;
+}
+async function runGenerationWithTimeout(session, operation) {
+  const existing = activeGenerations.get(session.id);
+  if (existing) {
+    clearTimeout(existing.timer);
+    existing.abortController.abort();
+  }
+  const abortController = new AbortController();
+  let timeoutTriggered = false;
+  const timer = setTimeout(() => {
+    timeoutTriggered = true;
+    setSessionError(session, "AI generation timed out. You can retry or start a new session.");
+    abortController.abort();
+  }, GENERATION_TIMEOUT_MS);
+  activeGenerations.set(session.id, { abortController, timer });
+  const abortPromise = new Promise((_, reject) => {
+    abortController.signal.addEventListener(
+      "abort",
+      () => reject(createAbortError()),
+      { once: true }
+    );
+  });
+  try {
+    return await Promise.race([operation(), abortPromise]);
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      if (!timeoutTriggered && !session.error) {
+        setSessionError(session, "Generation stopped by user. You can retry or start a new session.");
+      }
+    }
+    throw error;
+  } finally {
+    clearTimeout(timer);
+    activeGenerations.delete(session.id);
+  }
+}
 async function continueAgentConversation(session, message) {
   if (!session.agent) {
     throw new InvalidSessionStateError("AI agent not initialized");
   }
   try {
-    session.thinkingOutput = "";
-    await session.agent.session.prompt(message);
-    const lastMessage = session.agent.session.state.messages.filter((m) => m.role === "assistant").pop();
-    let responseText = session.thinkingOutput;
-    if (lastMessage?.content) {
-      if (typeof lastMessage.content === "string") {
-        responseText = lastMessage.content;
-      } else if (Array.isArray(lastMessage.content)) {
-        responseText = lastMessage.content.filter((c) => c.type === "text").map((c) => c.text).join("");
+    await runGenerationWithTimeout(session, async () => {
+      session.thinkingOutput = "";
+      await session.agent.session.prompt(message);
+      const lastMessage = session.agent.session.state.messages.filter((m) => m.role === "assistant").pop();
+      let responseText = session.thinkingOutput;
+      if (lastMessage?.content) {
+        if (typeof lastMessage.content === "string") {
+          responseText = lastMessage.content;
+        } else if (Array.isArray(lastMessage.content)) {
+          responseText = lastMessage.content.filter((c) => c.type === "text").map((c) => c.text).join("");
+        }
       }
-    }
-    let parsed;
-    let lastError;
-    for (let attempt = 0; attempt <= MAX_PARSE_RETRIES; attempt++) {
-      try {
-        parsed = parseAgentResponse(responseText);
-        break;
-      } catch (err) {
-        lastError = err instanceof Error ? err : new Error(String(err));
-        if (attempt < MAX_PARSE_RETRIES) {
-          diagnostics.warn(
-            "Parse attempt failed, requesting reformat",
-            { sessionId: session.id, attempt: attempt + 1, operation: "parse-retry" }
-          );
-          try {
-            session.thinkingOutput = "";
-            await session.agent.session.prompt(
-              'Your previous response could not be parsed as JSON. Please respond with ONLY a valid JSON object: either {"type":"question","data":{...}} or {"type":"complete","data":{...}}. No markdown, no explanation, just the JSON.'
+      let parsed;
+      let lastError;
+      for (let attempt = 0; attempt <= MAX_PARSE_RETRIES; attempt++) {
+        try {
+          parsed = parseAgentResponse(responseText);
+          break;
+        } catch (err) {
+          lastError = err instanceof Error ? err : new Error(String(err));
+          if (attempt < MAX_PARSE_RETRIES) {
+            diagnostics.warn(
+              "Parse attempt failed, requesting reformat",
+              { sessionId: session.id, attempt: attempt + 1, operation: "parse-retry" }
             );
-            const retryMessage = session.agent.session.state.messages.filter((m) => m.role === "assistant").pop();
-            let retryText = session.thinkingOutput;
-            if (retryMessage?.content) {
-              if (typeof retryMessage.content === "string") {
-                retryText = retryMessage.content;
-              } else if (Array.isArray(retryMessage.content)) {
-                retryText = retryMessage.content.filter((c) => c.type === "text").map((c) => c.text).join("");
+            try {
+              session.thinkingOutput = "";
+              await session.agent.session.prompt(
+                'Your previous response could not be parsed as JSON. Please respond with ONLY a valid JSON object: either {"type":"question","data":{...}} or {"type":"complete","data":{...}}. No markdown, no explanation, just the JSON.'
+              );
+              const retryMessage = session.agent.session.state.messages.filter((m) => m.role === "assistant").pop();
+              let retryText = session.thinkingOutput;
+              if (retryMessage?.content) {
+                if (typeof retryMessage.content === "string") {
+                  retryText = retryMessage.content;
+                } else if (Array.isArray(retryMessage.content)) {
+                  retryText = retryMessage.content.filter((c) => c.type === "text").map((c) => c.text).join("");
+                }
               }
+              responseText = retryText;
+            } catch (retryErr) {
+              diagnostics.errorFromException(
+                "Retry prompt failed for session",
+                retryErr,
+                { sessionId: session.id, operation: "retry-prompt" }
+              );
+              break;
             }
-            responseText = retryText;
-          } catch (retryErr) {
-            diagnostics.errorFromException(
-              "Retry prompt failed for session",
-              retryErr,
-              { sessionId: session.id, operation: "retry-prompt" }
-            );
-            break;
           }
         }
       }
-    }
-    if (!parsed) {
-      const errorMsg = `${lastError?.message || "Failed to parse AI response"} You can try responding again or start a new planning session.`;
-      diagnostics.error(
-        "All parse attempts exhausted for session",
-        { sessionId: session.id, message: errorMsg, operation: "parse-exhausted" }
-      );
-      session.error = errorMsg;
-      session.updatedAt = /* @__PURE__ */ new Date();
-      persistSession(session, "error", errorMsg);
-      planningStreamManager.broadcast(session.id, {
-        type: "error",
-        data: errorMsg
-      });
+      if (!parsed) {
+        const errorMsg = `${lastError?.message || "Failed to parse AI response"} You can try responding again or start a new planning session.`;
+        diagnostics.error(
+          "All parse attempts exhausted for session",
+          { sessionId: session.id, message: errorMsg, operation: "parse-exhausted" }
+        );
+        session.error = errorMsg;
+        session.updatedAt = /* @__PURE__ */ new Date();
+        persistSession(session, "error", errorMsg);
+        planningStreamManager.broadcast(session.id, {
+          type: "error",
+          data: errorMsg
+        });
+        return;
+      }
+      if (parsed.type === "question") {
+        session.currentQuestion = parsed.data;
+        session.error = void 0;
+        session.lastGeneratedThinking = session.thinkingOutput;
+        session.updatedAt = /* @__PURE__ */ new Date();
+        persistSession(session, "awaiting_input");
+        void maybeNotifyPlanningAwaitingInput(session, parsed.data);
+        planningStreamManager.broadcast(session.id, {
+          type: "question",
+          data: parsed.data
+        });
+      } else if (parsed.type === "complete") {
+        session.summary = parsed.data;
+        session.currentQuestion = void 0;
+        session.error = void 0;
+        session.updatedAt = /* @__PURE__ */ new Date();
+        persistSession(session, "complete");
+        planningStreamManager.broadcast(session.id, {
+          type: "summary",
+          data: parsed.data
+        });
+        planningStreamManager.broadcast(session.id, { type: "complete" });
+      }
+    });
+  } catch (err) {
+    if (err instanceof Error && err.name === "AbortError") {
       return;
     }
-    if (parsed.type === "question") {
-      session.currentQuestion = parsed.data;
-      session.error = void 0;
-      session.lastGeneratedThinking = session.thinkingOutput;
-      session.updatedAt = /* @__PURE__ */ new Date();
-      persistSession(session, "awaiting_input");
-      void maybeNotifyPlanningAwaitingInput(session, parsed.data);
-      planningStreamManager.broadcast(session.id, {
-        type: "question",
-        data: parsed.data
-      });
-    } else if (parsed.type === "complete") {
-      session.summary = parsed.data;
-      session.currentQuestion = void 0;
-      session.error = void 0;
-      session.updatedAt = /* @__PURE__ */ new Date();
-      persistSession(session, "complete");
-      planningStreamManager.broadcast(session.id, {
-        type: "summary",
-        data: parsed.data
-      });
-      planningStreamManager.broadcast(session.id, { type: "complete" });
-    }
-  } catch (err) {
     const errorMessage = err instanceof Error ? err.message : "AI processing failed";
     diagnostics.errorFromException("Agent conversation error for session", err, { sessionId: session.id, operation: "conversation" });
-    session.error = errorMessage;
-    session.updatedAt = /* @__PURE__ */ new Date();
-    persistSession(session, "error", errorMessage);
-    planningStreamManager.broadcast(session.id, {
-      type: "error",
-      data: errorMessage
-    });
+    setSessionError(session, errorMessage);
   }
 }
 function extractJsonCandidate(text) {
@@ -76825,7 +78518,7 @@ function getSession(sessionId) {
     return void 0;
   }
 }
-var createFnAgent4, planningNtfyHelpers, diagnostics, PLANNING_SYSTEM_PROMPT, SESSION_TTL_MS, CLEANUP_INTERVAL_MS2, MAX_SESSIONS_PER_IP_PER_HOUR, RATE_LIMIT_WINDOW_MS2, sessions, rateLimits2, _aiSessionStore, cleanupInterval2, PlanningStreamManager, planningStreamManager, MAX_PARSE_RETRIES, RateLimitError2, SessionNotFoundError, InvalidSessionStateError;
+var createFnAgent4, planningNtfyHelpers, diagnostics, PLANNING_SYSTEM_PROMPT, SESSION_TTL_MS, CLEANUP_INTERVAL_MS2, MAX_SESSIONS_PER_IP_PER_HOUR, RATE_LIMIT_WINDOW_MS2, GENERATION_TIMEOUT_MS, sessions, rateLimits2, activeGenerations, _aiSessionStore, cleanupInterval2, PlanningStreamManager, planningStreamManager, MAX_PARSE_RETRIES, RateLimitError2, SessionNotFoundError, InvalidSessionStateError;
 var init_planning = __esm({
   "../dashboard/src/planning.ts"() {
     "use strict";
@@ -76896,8 +78589,10 @@ For completion:
     CLEANUP_INTERVAL_MS2 = 5 * 60 * 1e3;
     MAX_SESSIONS_PER_IP_PER_HOUR = 5;
     RATE_LIMIT_WINDOW_MS2 = 60 * 60 * 1e3;
+    GENERATION_TIMEOUT_MS = 12e4;
     sessions = /* @__PURE__ */ new Map();
     rateLimits2 = /* @__PURE__ */ new Map();
+    activeGenerations = /* @__PURE__ */ new Map();
     cleanupInterval2 = setInterval(cleanupExpiredSessions, CLEANUP_INTERVAL_MS2);
     cleanupInterval2.unref?.();
     process.on("beforeExit", () => {
@@ -77035,6 +78730,108 @@ var init_ai_session_store = __esm({
   }
 });
 
+// ../dashboard/src/ai-session-timeout.ts
+function createAbortError2() {
+  const error = new Error("Generation aborted");
+  error.name = "AbortError";
+  return error;
+}
+function isAbortError(err) {
+  return err instanceof Error && err.name === "AbortError";
+}
+var GenerationGuard;
+var init_ai_session_timeout = __esm({
+  "../dashboard/src/ai-session-timeout.ts"() {
+    "use strict";
+    GenerationGuard = class {
+      active = /* @__PURE__ */ new Map();
+      /**
+       * Tracks the cause of a pending abort so the original `run()` can
+       * distinguish a user-initiated stop from re-entrant displacement. The flag
+       * is consumed (deleted) by the catch block of the displaced `run()`.
+       */
+      abortCause = /* @__PURE__ */ new Map();
+      /**
+       * Wrap `op` with a timeout + abort. If a previous generation is still
+       * registered for the same id, it is aborted first (the prior `run()`
+       * rejects with `AbortError`, marked as `displaced` so its `onUserStop`
+       * handler does NOT fire).
+       */
+      async run(sessionId, timeoutMs, handlers, op) {
+        this.cancelInternal(sessionId, "displaced");
+        const abort = new AbortController();
+        const timer = setTimeout(() => {
+          this.abortCause.set(abort, "timeout");
+          try {
+            handlers.onTimeout();
+          } catch {
+          }
+          abort.abort();
+        }, timeoutMs);
+        const entry = { abort, timer };
+        this.active.set(sessionId, entry);
+        const abortPromise = new Promise((_, reject) => {
+          abort.signal.addEventListener(
+            "abort",
+            () => reject(createAbortError2()),
+            { once: true }
+          );
+        });
+        try {
+          return await Promise.race([op(), abortPromise]);
+        } catch (err) {
+          if (isAbortError(err)) {
+            const cause = this.abortCause.get(abort) ?? "user-stop";
+            if (cause === "user-stop") {
+              try {
+                handlers.onUserStop?.();
+              } catch {
+              }
+            }
+          }
+          throw err;
+        } finally {
+          clearTimeout(timer);
+          this.abortCause.delete(abort);
+          if (this.active.get(sessionId) === entry) {
+            this.active.delete(sessionId);
+          }
+        }
+      }
+      /** AbortSignal of the in-flight generation, if any — for tools that honor it. */
+      signal(sessionId) {
+        return this.active.get(sessionId)?.abort.signal;
+      }
+      has(sessionId) {
+        return this.active.has(sessionId);
+      }
+      /**
+       * Manually abort the active generation. Returns true if there was one.
+       * The wrapped operation will reject with `AbortError`, and the `onUserStop`
+       * handler from the original `run()` call will fire.
+       */
+      stop(sessionId) {
+        return this.cancelInternal(sessionId, "user-stop");
+      }
+      /** Reset all in-flight generations (test/shutdown only). */
+      reset() {
+        for (const sessionId of [...this.active.keys()]) {
+          this.cancelInternal(sessionId, "user-stop");
+        }
+      }
+      cancelInternal(sessionId, cause) {
+        const entry = this.active.get(sessionId);
+        if (!entry) return false;
+        clearTimeout(entry.timer);
+        this.abortCause.set(entry.abort, cause);
+        entry.abort.abort();
+        this.active.delete(sessionId);
+        return true;
+      }
+    };
+  }
+});
+
 // ../dashboard/src/subtask-breakdown.ts
 import { EventEmitter as EventEmitter24 } from "node:events";
 function cleanupInMemorySubtaskSession(sessionId) {
@@ -77042,6 +78839,7 @@ function cleanupInMemorySubtaskSession(sessionId) {
   if (!session) {
     return false;
   }
+  generationGuard.stop(sessionId);
   try {
     session.agent?.session?.dispose?.();
   } catch {
@@ -77058,17 +78856,19 @@ function cleanupExpiredSessions2() {
     }
   }
 }
-var diagnostics3, SESSION_TTL_MS2, CLEANUP_INTERVAL_MS3, sessions2, cleanupInterval3, SubtaskStreamManager, subtaskStreamManager;
+var diagnostics3, SESSION_TTL_MS2, CLEANUP_INTERVAL_MS3, generationGuard, sessions2, cleanupInterval3, SubtaskStreamManager, subtaskStreamManager;
 var init_subtask_breakdown = __esm({
   "../dashboard/src/subtask-breakdown.ts"() {
     "use strict";
     init_src();
     init_sse_buffer();
     init_ai_session_diagnostics();
+    init_ai_session_timeout();
     init_src2();
     diagnostics3 = createSessionDiagnostics("subtask-breakdown");
     SESSION_TTL_MS2 = 7 * 24 * 60 * 60 * 1e3;
     CLEANUP_INTERVAL_MS3 = 5 * 60 * 1e3;
+    generationGuard = new GenerationGuard();
     sessions2 = /* @__PURE__ */ new Map();
     cleanupInterval3 = setInterval(cleanupExpiredSessions2, CLEANUP_INTERVAL_MS3);
     cleanupInterval3.unref?.();
@@ -77143,6 +78943,7 @@ function cleanupInMemoryMissionSession(sessionId) {
   if (!session) {
     return false;
   }
+  generationGuard2.stop(sessionId);
   if (session.agent) {
     try {
       session.agent.session.dispose?.();
@@ -77167,18 +78968,20 @@ function cleanupExpiredSessions3() {
     }
   }
 }
-var diagnostics4, SESSION_TTL_MS3, CLEANUP_INTERVAL_MS4, RATE_LIMIT_WINDOW_MS3, sessions3, rateLimits3, cleanupInterval4, MissionInterviewStreamManager, missionInterviewStreamManager;
+var diagnostics4, SESSION_TTL_MS3, CLEANUP_INTERVAL_MS4, RATE_LIMIT_WINDOW_MS3, generationGuard2, sessions3, rateLimits3, cleanupInterval4, MissionInterviewStreamManager, missionInterviewStreamManager;
 var init_mission_interview = __esm({
   "../dashboard/src/mission-interview.ts"() {
     "use strict";
     init_src();
     init_sse_buffer();
     init_ai_session_diagnostics();
+    init_ai_session_timeout();
     init_src2();
     diagnostics4 = createSessionDiagnostics("mission-interview");
     SESSION_TTL_MS3 = 7 * 24 * 60 * 60 * 1e3;
     CLEANUP_INTERVAL_MS4 = 5 * 60 * 1e3;
     RATE_LIMIT_WINDOW_MS3 = 60 * 60 * 1e3;
+    generationGuard2 = new GenerationGuard();
     sessions3 = /* @__PURE__ */ new Map();
     rateLimits3 = /* @__PURE__ */ new Map();
     cleanupInterval4 = setInterval(cleanupExpiredSessions3, CLEANUP_INTERVAL_MS4);
@@ -77258,6 +79061,7 @@ function cleanupInMemorySession2(sessionId) {
   if (!session) {
     return false;
   }
+  generationGuard3.stop(sessionId);
   if (session.agent) {
     try {
       session.agent.session.dispose?.();
@@ -77282,19 +79086,21 @@ function cleanupExpiredSessions4() {
     }
   }
 }
-var diagnostics5, SESSION_TTL_MS4, CLEANUP_INTERVAL_MS5, RATE_LIMIT_WINDOW_MS4, sessions4, rateLimits4, cleanupInterval5, MilestoneSliceInterviewStreamManager, milestoneSliceInterviewStreamManager;
+var diagnostics5, SESSION_TTL_MS4, CLEANUP_INTERVAL_MS5, RATE_LIMIT_WINDOW_MS4, generationGuard3, sessions4, rateLimits4, cleanupInterval5, MilestoneSliceInterviewStreamManager, milestoneSliceInterviewStreamManager;
 var init_milestone_slice_interview = __esm({
   "../dashboard/src/milestone-slice-interview.ts"() {
     "use strict";
     init_sse_buffer();
     init_mission_interview();
     init_ai_session_diagnostics();
+    init_ai_session_timeout();
     init_mission_interview();
     init_src2();
     diagnostics5 = createSessionDiagnostics("milestone-slice-interview");
     SESSION_TTL_MS4 = 7 * 24 * 60 * 60 * 1e3;
     CLEANUP_INTERVAL_MS5 = 5 * 60 * 1e3;
     RATE_LIMIT_WINDOW_MS4 = 60 * 60 * 1e3;
+    generationGuard3 = new GenerationGuard();
     sessions4 = /* @__PURE__ */ new Map();
     rateLimits4 = /* @__PURE__ */ new Map();
     cleanupInterval5 = setInterval(cleanupExpiredSessions4, CLEANUP_INTERVAL_MS5);
@@ -78139,6 +79945,7 @@ var init_register_task_workflow_routes = __esm({
 var init_register_planning_subtask_routes = __esm({
   "../dashboard/src/routes/register-planning-subtask-routes.ts"() {
     "use strict";
+    init_src();
     init_api_error();
     init_sse_buffer();
   }
@@ -78153,12 +79960,14 @@ var init_rate_limit = __esm({
 });
 
 // ../dashboard/src/routes/register-chat-routes.ts
+var CHAT_MAX_ATTACHMENT_SIZE;
 var init_register_chat_routes = __esm({
   "../dashboard/src/routes/register-chat-routes.ts"() {
     "use strict";
     init_api_error();
     init_rate_limit();
     init_sse_buffer();
+    CHAT_MAX_ATTACHMENT_SIZE = 5 * 1024 * 1024;
   }
 });
 
@@ -80381,16 +82190,26 @@ var init_register_agents_projects_nodes = __esm({
   }
 });
 
-// ../dashboard/src/routes/register-project-routes.ts
+// ../dashboard/src/exec-file.ts
 import { execFile as execFile5 } from "node:child_process";
-import * as fsPromises from "node:fs/promises";
 import { promisify as promisify12 } from "node:util";
-var access3, stat6, mkdir12, readdir8, rm2, execFileAsync3;
+var execFileAsync3;
+var init_exec_file = __esm({
+  "../dashboard/src/exec-file.ts"() {
+    "use strict";
+    execFileAsync3 = promisify12(execFile5);
+  }
+});
+
+// ../dashboard/src/routes/register-project-routes.ts
+import * as fsPromises from "node:fs/promises";
+var access3, stat6, mkdir12, readdir8, rm2;
 var init_register_project_routes = __esm({
   "../dashboard/src/routes/register-project-routes.ts"() {
     "use strict";
     init_src();
     init_api_error();
+    init_exec_file();
     init_project_store_resolver();
     ({
       access: access3,
@@ -80399,7 +82218,6 @@ var init_register_project_routes = __esm({
       readdir: readdir8,
       rm: rm2
     } = fsPromises);
-    execFileAsync3 = promisify12(execFile5);
   }
 });
 
@@ -85738,12 +87556,29 @@ var init_project_context = __esm({
   }
 });
 
+// src/commands/node.ts
+import { createInterface } from "node:readline/promises";
+async function findNodeByNameOrId(central, nameOrId) {
+  const byId = await central.getNode(nameOrId);
+  if (byId) {
+    return byId;
+  }
+  return central.getNodeByName(nameOrId);
+}
+var init_node = __esm({
+  "src/commands/node.ts"() {
+    "use strict";
+    init_src();
+  }
+});
+
 // src/commands/task.ts
 var task_exports = {};
 __export(task_exports, {
   fetchGitHubIssues: () => fetchGitHubIssues,
   runTaskArchive: () => runTaskArchive,
   runTaskAttach: () => runTaskAttach,
+  runTaskClearNode: () => runTaskClearNode,
   runTaskComment: () => runTaskComment,
   runTaskComments: () => runTaskComments,
   runTaskCreate: () => runTaskCreate,
@@ -85761,13 +87596,14 @@ __export(task_exports, {
   runTaskPrCreate: () => runTaskPrCreate,
   runTaskRefine: () => runTaskRefine,
   runTaskRetry: () => runTaskRetry,
+  runTaskSetNode: () => runTaskSetNode,
   runTaskShow: () => runTaskShow,
   runTaskSteer: () => runTaskSteer,
   runTaskUnarchive: () => runTaskUnarchive,
   runTaskUnpause: () => runTaskUnpause,
   runTaskUpdate: () => runTaskUpdate
 });
-import { createInterface } from "node:readline/promises";
+import { createInterface as createInterface2 } from "node:readline/promises";
 import { watchFile, unwatchFile, statSync as statSync6, existsSync as existsSync30, readFileSync as readFileSync9 } from "node:fs";
 import { join as join37 } from "node:path";
 function asLocalProjectContext(store) {
@@ -85832,11 +87668,28 @@ async function getProjectContext(projectName) {
 async function getProjectPath(projectName) {
   return (await getCommandContext(projectName)).projectPath;
 }
-async function runTaskCreate(descriptionArg, attachFiles, depends, projectName) {
+async function resolveNodeByNameOrId(nodeNameOrId) {
+  const central = new CentralCore();
+  await central.init();
+  try {
+    const looksLikeNodeId = nodeNameOrId.includes("-") && nodeNameOrId.length > 20;
+    let node = looksLikeNodeId ? await central.getNode(nodeNameOrId) : await central.getNodeByName(nodeNameOrId);
+    if (!node) {
+      node = await findNodeByNameOrId(central, nodeNameOrId);
+    }
+    if (!node) {
+      throw new Error(`Node not found: ${nodeNameOrId}`);
+    }
+    return { id: node.id, name: node.name };
+  } finally {
+    await central.close();
+  }
+}
+async function runTaskCreate(descriptionArg, attachFiles, depends, projectName, nodeName) {
   let description = descriptionArg;
   const projectContext = await getProjectContext(projectName);
   if (!description) {
-    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const rl = createInterface2({ input: process.stdin, output: process.stdout });
     description = await rl.question("Task description: ");
     rl.close();
   }
@@ -85846,6 +87699,16 @@ async function runTaskCreate(descriptionArg, attachFiles, depends, projectName)
   }
   const store = projectContext?.store ?? await getStore(projectName);
   const task = await store.createTask({ description: description.trim(), dependencies: depends });
+  let resolvedNode;
+  if (nodeName) {
+    try {
+      resolvedNode = await resolveNodeByNameOrId(nodeName);
+      await store.updateTask(task.id, { nodeId: resolvedNode.id });
+    } catch (error) {
+      console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+      process.exit(1);
+    }
+  }
   const label = task.description.length > 60 ? task.description.slice(0, 60) + "\u2026" : task.description;
   console.log();
   if (projectContext) {
@@ -85856,6 +87719,9 @@ async function runTaskCreate(descriptionArg, attachFiles, depends, projectName)
   if (task.dependencies.length > 0) {
     console.log(`    Dependencies: ${task.dependencies.join(", ")}`);
   }
+  if (resolvedNode) {
+    console.log(`    Node: ${resolvedNode.name || resolvedNode.id}`);
+  }
   console.log(`    Path:   .fusion/tasks/${task.id}/`);
   if (attachFiles && attachFiles.length > 0) {
     const { readFile: readFile19 } = await import("node:fs/promises");
@@ -86047,15 +87913,62 @@ async function runTaskLogs(id, options = {}, projectName) {
     });
   }
 }
+async function runTaskSetNode(id, nodeNameOrId, projectName) {
+  const store = await getStore(projectName);
+  const task = await store.getTask(id);
+  if (task.column === "in-progress") {
+    console.error(`Cannot change node override: task ${id} is in progress`);
+    process.exit(1);
+  }
+  let resolvedNode;
+  try {
+    resolvedNode = await resolveNodeByNameOrId(nodeNameOrId);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+    return;
+  }
+  await store.updateTask(id, { nodeId: resolvedNode.id });
+  console.log(`\u2713 Set node override for ${id}: ${resolvedNode.name || resolvedNode.id}`);
+}
+async function runTaskClearNode(id, projectName) {
+  const store = await getStore(projectName);
+  const task = await store.getTask(id);
+  if (task.column === "in-progress") {
+    console.error(`Cannot change node override: task ${id} is in progress`);
+    process.exit(1);
+  }
+  await store.updateTask(id, { nodeId: null });
+  console.log(`\u2713 Cleared node override for ${id}`);
+}
 async function runTaskShow(id, projectName) {
   const store = await getStore(projectName);
   const task = await store.getTask(id);
+  const settings = "getSettings" in store ? await store.getSettings() : {};
+  let nodeSummary = "(default local)";
+  if (task.nodeId) {
+    let nodeName;
+    const central = new CentralCore();
+    await central.init();
+    try {
+      nodeName = (await central.getNode(task.nodeId))?.name;
+    } finally {
+      await central.close();
+    }
+    nodeSummary = nodeName ? `${nodeName} (${task.nodeId})` : task.nodeId;
+  } else if (settings.defaultNodeId) {
+    nodeSummary = `project default: ${settings.defaultNodeId}`;
+  }
   console.log();
   console.log(`  ${task.id}: ${task.title || task.description}`);
   console.log(`  Column: ${COLUMN_LABELS[task.column]}${task.size ? ` \xB7 Size: ${task.size}` : ""}${task.reviewLevel !== void 0 ? ` \xB7 Review: ${task.reviewLevel}` : ""}`);
   if (task.dependencies.length) {
     console.log(`  Dependencies: ${task.dependencies.join(", ")}`);
   }
+  console.log(`  Node: ${nodeSummary}`);
+  if (settings.unavailableNodePolicy) {
+    console.log(`  Unavailable Node Policy: ${settings.unavailableNodePolicy}`);
+  }
   console.log();
   if (task.steps.length > 0) {
     console.log(`  Steps (${task.steps.filter((s) => s.status === "done").length}/${task.steps.length}):`);
@@ -86172,7 +88085,7 @@ async function runTaskRefine(id, feedbackArg, projectName) {
   const store = await getStore(projectName);
   let feedback = feedbackArg;
   if (feedback === void 0) {
-    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const rl = createInterface2({ input: process.stdin, output: process.stdout });
     feedback = await rl.question("What needs to be refined? ");
     rl.close();
   }
@@ -86243,7 +88156,7 @@ async function runTaskDelete(id, force, projectName) {
     return;
   }
   if (!force) {
-    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const rl = createInterface2({ input: process.stdin, output: process.stdout });
     const answer = await rl.question(`Are you sure you want to delete ${id}? [y/N] `);
     rl.close();
     const trimmed = answer.trim().toLowerCase();
@@ -86307,7 +88220,7 @@ async function runTaskImportGitHubInteractive(ownerRepo, options = {}, projectNa
     console.log(`  ${i + 1}. #${issue.number} ${issue.title.slice(0, 80)}${issue.title.length > 80 ? "\u2026" : ""}${status}`);
   }
   console.log();
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const rl = createInterface2({ input: process.stdin, output: process.stdout });
   let selectedIndices = [];
   let validInput = false;
   while (!validInput) {
@@ -86464,7 +88377,7 @@ async function runTaskComment(id, message, author = "user", projectName) {
   const store = await getStore(projectName);
   let text = message;
   if (text === void 0) {
-    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const rl = createInterface2({ input: process.stdin, output: process.stdout });
     text = await rl.question("Comment: ");
     rl.close();
   }
@@ -86507,7 +88420,7 @@ async function runTaskSteer(id, message, projectName) {
   const store = await getStore(projectName);
   let text = message;
   if (text === void 0) {
-    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const rl = createInterface2({ input: process.stdin, output: process.stdout });
     text = await rl.question("Message: ");
     rl.close();
   }
@@ -86638,7 +88551,7 @@ async function promptText(question) {
     console.log(`  ${question.description}`);
   }
   console.log("  (Enter your response. Type DONE on its own line when finished):\n");
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const rl = createInterface2({ input: process.stdin, output: process.stdout });
   const lines = [];
   return new Promise((resolve17) => {
     const askLine = () => {
@@ -86672,7 +88585,7 @@ async function promptSingleSelect(question) {
       console.log(`     ${opt.description}`);
     }
   }
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const rl = createInterface2({ input: process.stdin, output: process.stdout });
   while (true) {
     const answer = await rl.question("\n  Select (1-" + question.options.length + "): ");
     const num = parseInt(answer.trim(), 10);
@@ -86700,7 +88613,7 @@ async function promptMultiSelect(question) {
       console.log(`     ${opt.description}`);
     }
   }
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const rl = createInterface2({ input: process.stdin, output: process.stdout });
   while (true) {
     const answer = await rl.question("\n  Select (comma-separated): ");
     const nums = answer.split(",").map((s) => parseInt(s.trim(), 10)).filter((n) => !isNaN(n));
@@ -86723,7 +88636,7 @@ async function promptConfirm(question) {
   if (question.description) {
     console.log(`  ${question.description}`);
   }
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const rl = createInterface2({ input: process.stdin, output: process.stdout });
   const answer = await rl.question("\n  [Y/n]: ");
   rl.close();
   const trimmed = answer.trim().toLowerCase();
@@ -86788,7 +88701,7 @@ function wrapText(text, width) {
 async function runTaskPlan(initialPlanArg, yesFlag = false, projectName) {
   let initialPlan = initialPlanArg;
   if (!initialPlan) {
-    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const rl = createInterface2({ input: process.stdin, output: process.stdout });
     console.log("\n  Let's plan your task. What would you like to accomplish?\n");
     initialPlan = await rl.question("  Describe your idea: ");
     rl.close();
@@ -86889,7 +88802,7 @@ async function runTaskPlan(initialPlanArg, yesFlag = false, projectName) {
         displaySummary(result.data);
         let confirmed = yesFlag;
         if (!yesFlag) {
-          const rl = createInterface({ input: process.stdin, output: process.stdout });
+          const rl = createInterface2({ input: process.stdin, output: process.stdout });
           const answer = await rl.question("  Create this task? [Y/n]: ");
           rl.close();
           const trimmed = answer.trim().toLowerCase();
@@ -86931,6 +88844,7 @@ var init_task = __esm({
     init_src4();
     init_gh_cli();
     init_project_context();
+    init_node();
     STEP_STATUSES2 = ["pending", "in-progress", "done", "skipped"];
     ANSI = {
       reset: "\x1B[0m",
@@ -87143,17 +89057,17 @@ async function fetchGitHubIssuesViaGh(owner, repo, options = {}) {
   }
   const path2 = `repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/issues?${queryParams.toString()}`;
   try {
-    const issues = await runGhJsonAsync(["api", path2]);
+    const issues = await runGhJsonAsync(["api", path2], { signal: options.signal });
     return issues.filter((issue) => !issue.pull_request);
   } catch (error) {
     throw new Error(getGhErrorMessage(error));
   }
 }
-async function fetchGitHubIssueViaGh(owner, repo, issueNumber) {
+async function fetchGitHubIssueViaGh(owner, repo, issueNumber, options = {}) {
   ensureGhCliAuth();
   const path2 = `repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/issues/${issueNumber}`;
   try {
-    return await runGhJsonAsync(["api", path2]);
+    return await runGhJsonAsync(["api", path2], { signal: options.signal });
   } catch (error) {
     throw new Error(getGhErrorMessage(error));
   }
@@ -87234,12 +89148,18 @@ Column: triage
         ], {
           description: "Agent ID to assign this task to, or null to clear (e.g. 'agent-abc123')"
         })
+      ),
+      nodeId: Type7.Optional(
+        Type7.Union([Type7.String(), Type7.Null()], {
+          description: "Node ID override for this task, or null to clear"
+        })
       )
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
       const store = await getStore2(ctx.cwd);
+      let task;
       try {
-        await store.getTask(params.id);
+        task = await store.getTask(params.id);
       } catch {
         return {
           content: [{ type: "text", text: `Task ${params.id} not found` }],
@@ -87265,9 +89185,21 @@ Column: triage
         updates.assignedAgentId = params.agentId;
         updatedFields.push("agentId");
       }
+      if (params.nodeId !== void 0) {
+        const validation = validateNodeOverrideChange(task, params.nodeId ?? null);
+        if (!validation.allowed) {
+          return {
+            content: [{ type: "text", text: validation.message ?? "Node override change blocked" }],
+            isError: true,
+            details: { error: validation.reason }
+          };
+        }
+        updates.nodeId = params.nodeId;
+        updatedFields.push("nodeId");
+      }
       if (updatedFields.length === 0) {
         return {
-          content: [{ type: "text", text: "No fields to update. Provide at least one of: title, description, depends, agentId." }],
+          content: [{ type: "text", text: "No fields to update. Provide at least one of: title, description, depends, agentId, nodeId." }],
           isError: true,
           details: { error: "No fields provided" }
         };
@@ -87648,11 +89580,11 @@ Path: .fusion/tasks/${params.id}/attachments/${attachment.filename}`
         })
       )
     }),
-    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+    async execute(_toolCallId, params, signal, _onUpdate, ctx) {
       const [owner, repo] = params.ownerRepo.split("/");
       const limit = params.limit ?? 30;
       const labels = params.labels;
-      const issues = await fetchGitHubIssuesViaGh(owner, repo, { limit, labels });
+      const issues = await fetchGitHubIssuesViaGh(owner, repo, { limit, labels, signal });
       if (issues.length === 0) {
         return {
           content: [{ type: "text", text: `No open issues found in ${owner}/${repo}.` }],
@@ -87727,9 +89659,9 @@ ${createdTasks.map((task) => `  ${task.id}: ${task.title}`).join("\n") || "  Non
         minimum: 1
       })
     }),
-    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+    async execute(_toolCallId, params, signal, _onUpdate, ctx) {
       const { owner, repo, issueNumber } = params;
-      const issue = await fetchGitHubIssueViaGh(owner, repo, issueNumber);
+      const issue = await fetchGitHubIssueViaGh(owner, repo, issueNumber, { signal });
       if (issue.pull_request) {
         throw new Error(`#${issueNumber} is a pull request, not an issue`);
       }
@@ -87813,9 +89745,9 @@ ${sourceUrl}`
         })
       )
     }),
-    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+    async execute(_toolCallId, params, signal, _onUpdate, ctx) {
       const { owner, repo, limit = 30, labels } = params;
-      const issues = await fetchGitHubIssuesViaGh(owner, repo, { limit, labels });
+      const issues = await fetchGitHubIssuesViaGh(owner, repo, { limit, labels, signal });
       if (issues.length === 0) {
         return {
           content: [{ type: "text", text: `No open issues found in ${owner}/${repo}.` }],