@runfusion/fusion 0.9.3 → 0.9.4

package/dist/extension.js

@@ -101,7 +101,23 @@ var init_settings_schema = __esm({
       dashboardCurrentProjectIdByNode: void 0,
       // Dashboard TUI memory guard
       vitestAutoKillEnabled: true,
-      vitestKillThresholdPct: 90
+      vitestKillThresholdPct: 90,
+      researchGlobalEnabled: true,
+      researchGlobalMaxConcurrentRuns: 3,
+      researchGlobalDefaultTimeout: 3e5,
+      researchGlobalMaxSourcesPerRun: 20,
+      researchGlobalMaxSynthesisRounds: 2,
+      researchWebSearchProvider: "none",
+      researchSearxngUrl: void 0,
+      researchBraveApiKey: void 0,
+      researchGoogleSearchApiKey: void 0,
+      researchGoogleSearchCx: void 0,
+      researchTavilyApiKey: void 0,
+      researchGitHubEnabled: false,
+      researchLocalDocsEnabled: true,
+      researchMaxSearchResults: 10,
+      researchFetchTimeoutMs: 3e4,
+      researchUserAgent: "FusionResearchBot/1.0"
     };
     DEFAULT_PROJECT_SETTINGS = {
       globalPause: false,
@@ -184,7 +200,7 @@ var init_settings_schema = __esm({
       autoBackupRetention: 7,
       autoBackupDir: ".fusion/backups",
       autoSummarizeTitles: false,
-      useAiMergeCommitSummary: false,
+      useAiMergeCommitSummary: true,
       titleSummarizerProvider: void 0,
       titleSummarizerModelId: void 0,
       titleSummarizerFallbackProvider: void 0,
@@ -248,6 +264,11 @@ var init_settings_schema = __esm({
       reflectionAfterTask: true,
       reviewHandoffPolicy: "disabled",
       showQuickChatFAB: false,
+      researchEnabled: true,
+      researchMaxConcurrentRuns: 3,
+      researchDefaultTimeout: 3e5,
+      researchMaxSourcesPerRun: 20,
+      researchMaxSynthesisRounds: 2,
       experimentalFeatures: {}
     };
     DEFAULT_SETTINGS = {
@@ -6754,9 +6775,9 @@ var init_global_settings = __esm({
        * Serialize operations via promise chain to prevent lost-update races.
        */
       withLock(fn) {
-        let resolve18;
+        let resolve19;
         const next = new Promise((r) => {
-          resolve18 = r;
+          resolve19 = r;
         });
         const prev = this.lock;
         this.lock = next;
@@ -6764,7 +6785,7 @@ var init_global_settings = __esm({
           try {
             return await fn();
           } finally {
-            resolve18();
+            resolve19();
           }
         });
       }
@@ -11989,7 +12010,7 @@ var init_research_store = __esm({
         }
         return deleted;
       }
-      appendEvent(runId, event) {
+      addEvent(runId, event) {
         const run = this.getRun(runId);
         if (!run) throw new Error(`Research run not found: ${runId}`);
         const created = {
@@ -12000,13 +12021,18 @@ var init_research_store = __esm({
           metadata: event.metadata
         };
         this.updateRun(runId, { events: [...run.events, created] });
+        this.emit("event:added", { runId, event: created });
         return created;
       }
+      appendEvent(runId, event) {
+        return this.addEvent(runId, event);
+      }
       addSource(runId, source) {
         const run = this.getRun(runId);
         if (!run) throw new Error(`Research run not found: ${runId}`);
         const created = { ...source, id: generateId("RSRC") };
         this.updateRun(runId, { sources: [...run.sources, created] });
+        this.emit("source:added", { runId, source: created });
         return created;
       }
       updateSource(runId, sourceId, updates) {
@@ -28419,9 +28445,9 @@ var init_automation_store = __esm({
        */
       withScheduleLock(id, fn) {
         const prev = this.scheduleLocks.get(id) ?? Promise.resolve();
-        let resolve18;
+        let resolve19;
         const next = new Promise((r) => {
-          resolve18 = r;
+          resolve19 = r;
         });
         this.scheduleLocks.set(id, next);
         return prev.then(async () => {
@@ -28431,7 +28457,7 @@ var init_automation_store = __esm({
             if (this.scheduleLocks.get(id) === next) {
               this.scheduleLocks.delete(id);
             }
-            resolve18();
+            resolve19();
           }
         });
       }
@@ -30220,7 +30246,7 @@ var init_project_memory = __esm({
 // ../core/src/run-command.ts
 import { spawn } from "node:child_process";
 function runCommandAsync(command, options = {}) {
-  return new Promise((resolve18) => {
+  return new Promise((resolve19) => {
     const maxBuffer = options.maxBuffer ?? DEFAULT_MAX_BUFFER;
     let stdout = "";
     let stderr = "";
@@ -30279,7 +30305,7 @@ function runCommandAsync(command, options = {}) {
         clearTimeout(forceKillTimer);
         forceKillTimer = null;
       }
-      resolve18({
+      resolve19({
         stdout,
         stderr,
         exitCode: null,
@@ -30297,7 +30323,7 @@ function runCommandAsync(command, options = {}) {
       }
       signalProcessGroup("SIGTERM");
       scheduleForceKill(NORMAL_CLEANUP_FORCE_KILL_DELAY_MS);
-      resolve18({
+      resolve19({
         stdout,
         stderr,
         exitCode: code,
@@ -31035,10 +31061,10 @@ ${recentText}` : void 0
        * report the same total-execution figure that the task detail Stats panel
        * computes from the full log.
        */
-      computeTimedExecutionMs(log9) {
-        if (!log9 || log9.length === 0) return 0;
+      computeTimedExecutionMs(log17) {
+        if (!log17 || log17.length === 0) return 0;
         let total = 0;
-        for (const entry of log9) {
+        for (const entry of log17) {
           const action = typeof entry.action === "string" ? entry.action : "";
           const outcome = typeof entry.outcome === "string" ? entry.outcome : "";
           if (!action.includes("[timing]") && !outcome.includes("[timing]")) continue;
@@ -31512,9 +31538,9 @@ ${outcome}`;
        * lost-update races on the nextId counter.
        */
       withConfigLock(fn) {
-        let resolve18;
+        let resolve19;
         const next = new Promise((r) => {
-          resolve18 = r;
+          resolve19 = r;
         });
         const prev = this.configLock;
         this.configLock = next;
@@ -31522,7 +31548,7 @@ ${outcome}`;
           try {
             return await fn();
           } finally {
-            resolve18();
+            resolve19();
           }
         });
       }
@@ -31532,9 +31558,9 @@ ${outcome}`;
        */
       withTaskLock(id, fn) {
         const prev = this.taskLocks.get(id) ?? Promise.resolve();
-        let resolve18;
+        let resolve19;
         const next = new Promise((r) => {
-          resolve18 = r;
+          resolve19 = r;
         });
         this.taskLocks.set(id, next);
         return prev.then(async () => {
@@ -31544,7 +31570,7 @@ ${outcome}`;
             if (this.taskLocks.get(id) === next) {
               this.taskLocks.delete(id);
             }
-            resolve18();
+            resolve19();
           }
         });
       }
@@ -33025,13 +33051,13 @@ ${task.description}
           if (row.column === "archived") {
             throw new Error(`Task ${id} is archived \u2014 logging is read-only`);
           }
-          const log9 = fromJson(row.log) || [];
-          log9.push(entry);
-          if (log9.length > TASK_ACTIVITY_LOG_ENTRY_LIMIT) {
-            log9.splice(0, log9.length - TASK_ACTIVITY_LOG_ENTRY_LIMIT);
+          const log17 = fromJson(row.log) || [];
+          log17.push(entry);
+          if (log17.length > TASK_ACTIVITY_LOG_ENTRY_LIMIT) {
+            log17.splice(0, log17.length - TASK_ACTIVITY_LOG_ENTRY_LIMIT);
           }
           const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-          this.db.prepare("UPDATE tasks SET log = ?, updatedAt = ? WHERE id = ?").run(toJson(log9), updatedAt, id);
+          this.db.prepare("UPDATE tasks SET log = ?, updatedAt = ? WHERE id = ?").run(toJson(log17), updatedAt, id);
           this.db.bumpLastModified();
           const current = this.readTaskFromDb(id);
           if (current) {
@@ -33042,7 +33068,7 @@ ${task.description}
             this.emit("task:updated", current);
             return current;
           }
-          const emittedTask = { id, log: log9, updatedAt };
+          const emittedTask = { id, log: log17, updatedAt };
           this.emit("task:updated", emittedTask);
           return emittedTask;
         });
@@ -33796,7 +33822,7 @@ ${task.description}
               }
             }
           }
-          await new Promise((resolve18) => setImmediate(resolve18));
+          await new Promise((resolve19) => setImmediate(resolve19));
           const selectClause = this.getTaskSelectClause(true);
           const changedRows = this.lastPollTime ? this.db.prepare(`SELECT ${selectClause} FROM tasks WHERE updatedAt > ? OR columnMovedAt > ?`).all(this.lastPollTime, this.lastPollTime) : this.db.prepare(`SELECT ${selectClause} FROM tasks`).all();
           this.lastPollTime = (/* @__PURE__ */ new Date()).toISOString();
@@ -33816,7 +33842,7 @@ ${task.description}
               this.emit("task:updated", task);
             }
             if (i > 0 && i % 50 === 0) {
-              await new Promise((resolve18) => setImmediate(resolve18));
+              await new Promise((resolve19) => setImmediate(resolve19));
             }
           }
           const elapsed = Date.now() - startTime;
@@ -35672,7 +35698,7 @@ function runGh(args, cwd) {
 }
 function runGhAsync(args, cwdOrOptions) {
   const { cwd, signal: externalSignal, timeoutMs = DEFAULT_GH_TIMEOUT_MS } = normalizeRunGhOptions(cwdOrOptions);
-  return new Promise((resolve18, reject) => {
+  return new Promise((resolve19, reject) => {
     if (externalSignal?.aborted) {
       reject(makeGhError(`gh command aborted: ${describeAbortReason(externalSignal.reason)}`, "ABORT_ERR"));
       return;
@@ -35723,7 +35749,7 @@ function runGhAsync(args, cwdOrOptions) {
           ghError.stderr = stderr ?? "";
           reject(ghError);
         } else {
-          resolve18(stdout ?? "");
+          resolve19(stdout ?? "");
         }
       }
     );
@@ -36011,9 +36037,9 @@ var init_routine_store = __esm({
        */
       withRoutineLock(id, fn) {
         const prev = this.routineLocks.get(id) ?? Promise.resolve();
-        let resolve18;
+        let resolve19;
         const next = new Promise((r) => {
-          resolve18 = r;
+          resolve19 = r;
         });
         this.routineLocks.set(id, next);
         return prev.then(async () => {
@@ -36023,7 +36049,7 @@ var init_routine_store = __esm({
             if (this.routineLocks.get(id) === next) {
               this.routineLocks.delete(id);
             }
-            resolve18();
+            resolve19();
           }
         });
       }
@@ -36622,13 +36648,13 @@ var init_plugin_loader = __esm({
        * Execute a promise with a timeout.
        */
       withTimeout(promise, ms, timeoutMessage) {
-        return new Promise((resolve18, reject) => {
+        return new Promise((resolve19, reject) => {
           const timer = setTimeout(() => {
             reject(new Error(timeoutMessage));
           }, ms);
           promise.then((result) => {
             clearTimeout(timer);
-            resolve18(result);
+            resolve19(result);
           }).catch((err) => {
             clearTimeout(timer);
             reject(err);
@@ -39051,7 +39077,7 @@ var init_memory_insights = __esm({
 });
 
 // ../core/src/research-types.ts
-var RESEARCH_RUN_STATUSES, RESEARCH_SOURCE_STATUSES, RESEARCH_EXPORT_FORMATS, RESEARCH_SOURCE_TYPES, RESEARCH_EVENT_TYPES;
+var RESEARCH_RUN_STATUSES, RESEARCH_SOURCE_STATUSES, RESEARCH_EXPORT_FORMATS, RESEARCH_SOURCE_TYPES, RESEARCH_EVENT_TYPES, RESEARCH_ORCHESTRATION_PHASES, RESEARCH_ORCHESTRATION_STEP_STATUSES;
 var init_research_types = __esm({
   "../core/src/research-types.ts"() {
     "use strict";
@@ -39078,6 +39104,17 @@ var init_research_types = __esm({
       "result_updated",
       "progress"
     ];
+    RESEARCH_ORCHESTRATION_PHASES = [
+      "planning",
+      "searching",
+      "fetching",
+      "synthesizing",
+      "finalizing",
+      "completed",
+      "failed",
+      "cancelled"
+    ];
+    RESEARCH_ORCHESTRATION_STEP_STATUSES = ["pending", "running", "completed", "failed", "skipped"];
   }
 });
 
@@ -39669,7 +39706,7 @@ var require_node = __commonJS({
     var tty = __require("tty");
     var util = __require("util");
     exports.init = init;
-    exports.log = log9;
+    exports.log = log17;
     exports.formatArgs = formatArgs;
     exports.save = save;
     exports.load = load;
@@ -39804,7 +39841,7 @@ var require_node = __commonJS({
       }
       return (/* @__PURE__ */ new Date()).toISOString() + " ";
     }
-    function log9(...args) {
+    function log17(...args) {
       return process.stderr.write(util.formatWithOptions(exports.inspectOpts, ...args) + "\n");
     }
     function save(namespaces) {
@@ -40015,9 +40052,9 @@ var require_pump = __commonJS({
     "use strict";
     var once = require_once();
     var eos = require_end_of_stream();
-    var fs;
+    var fs2;
     try {
-      fs = __require("fs");
+      fs2 = __require("fs");
     } catch (e) {
     }
     var noop = function() {
@@ -40028,8 +40065,8 @@ var require_pump = __commonJS({
     };
     var isFS = function(stream) {
       if (!ancient) return false;
-      if (!fs) return false;
-      return (stream instanceof (fs.ReadStream || noop) || stream instanceof (fs.WriteStream || noop)) && isFn(stream.close);
+      if (!fs2) return false;
+      return (stream instanceof (fs2.ReadStream || noop) || stream instanceof (fs2.WriteStream || noop)) && isFn(stream.close);
     };
     var isRequest = function(stream) {
       return stream.setHeader && isFn(stream.abort);
@@ -40153,7 +40190,7 @@ var require_get_stream = __commonJS({
       };
       const { maxBuffer } = options;
       let stream;
-      await new Promise((resolve18, reject) => {
+      await new Promise((resolve19, reject) => {
         const rejectPromise = (error) => {
           if (error && stream.getBufferedLength() <= BufferConstants.MAX_LENGTH) {
             error.bufferedData = stream.getBufferedValue();
@@ -40165,7 +40202,7 @@ var require_get_stream = __commonJS({
             rejectPromise(error);
             return;
           }
-          resolve18();
+          resolve19();
         });
         stream.on("data", () => {
           if (stream.getBufferedLength() > maxBuffer) {
@@ -40243,7 +40280,7 @@ var require_pend = __commonJS({
 var require_fd_slicer = __commonJS({
   "../../node_modules/.pnpm/fd-slicer@1.1.0/node_modules/fd-slicer/index.js"(exports) {
     "use strict";
-    var fs = __require("fs");
+    var fs2 = __require("fs");
     var util = __require("util");
     var stream = __require("stream");
     var Readable = stream.Readable;
@@ -40268,7 +40305,7 @@ var require_fd_slicer = __commonJS({
     FdSlicer.prototype.read = function(buffer, offset, length, position, callback) {
       var self = this;
       self.pend.go(function(cb) {
-        fs.read(self.fd, buffer, offset, length, position, function(err, bytesRead, buffer2) {
+        fs2.read(self.fd, buffer, offset, length, position, function(err, bytesRead, buffer2) {
           cb();
           callback(err, bytesRead, buffer2);
         });
@@ -40277,7 +40314,7 @@ var require_fd_slicer = __commonJS({
     FdSlicer.prototype.write = function(buffer, offset, length, position, callback) {
       var self = this;
       self.pend.go(function(cb) {
-        fs.write(self.fd, buffer, offset, length, position, function(err, written, buffer2) {
+        fs2.write(self.fd, buffer, offset, length, position, function(err, written, buffer2) {
           cb();
           callback(err, written, buffer2);
         });
@@ -40298,7 +40335,7 @@ var require_fd_slicer = __commonJS({
       if (self.refCount > 0) return;
       if (self.refCount < 0) throw new Error("invalid unref");
       if (self.autoClose) {
-        fs.close(self.fd, onCloseDone);
+        fs2.close(self.fd, onCloseDone);
       }
       function onCloseDone(err) {
         if (err) {
@@ -40335,7 +40372,7 @@ var require_fd_slicer = __commonJS({
       self.context.pend.go(function(cb) {
         if (self.destroyed) return cb();
         var buffer = new Buffer(toRead);
-        fs.read(self.context.fd, buffer, 0, toRead, self.pos, function(err, bytesRead) {
+        fs2.read(self.context.fd, buffer, 0, toRead, self.pos, function(err, bytesRead) {
           if (err) {
             self.destroy(err);
           } else if (bytesRead === 0) {
@@ -40382,7 +40419,7 @@ var require_fd_slicer = __commonJS({
       }
       self.context.pend.go(function(cb) {
         if (self.destroyed) return cb();
-        fs.write(self.context.fd, buffer, 0, buffer.length, self.pos, function(err2, bytes) {
+        fs2.write(self.context.fd, buffer, 0, buffer.length, self.pos, function(err2, bytes) {
           if (err2) {
             self.destroy();
             cb();
@@ -40811,7 +40848,7 @@ var require_buffer_crc32 = __commonJS({
 var require_yauzl = __commonJS({
   "../../node_modules/.pnpm/yauzl@2.10.0/node_modules/yauzl/index.js"(exports) {
     "use strict";
-    var fs = __require("fs");
+    var fs2 = __require("fs");
     var zlib = __require("zlib");
     var fd_slicer = require_fd_slicer();
     var crc32 = require_buffer_crc32();
@@ -40841,10 +40878,10 @@ var require_yauzl = __commonJS({
       if (options.validateEntrySizes == null) options.validateEntrySizes = true;
       if (options.strictFileNames == null) options.strictFileNames = false;
       if (callback == null) callback = defaultCallback;
-      fs.open(path2, "r", function(err, fd) {
+      fs2.open(path2, "r", function(err, fd) {
         if (err) return callback(err);
         fromFd(fd, options, function(err2, zipfile) {
-          if (err2) fs.close(fd, defaultCallback);
+          if (err2) fs2.close(fd, defaultCallback);
           callback(err2, zipfile);
         });
       });
@@ -40861,7 +40898,7 @@ var require_yauzl = __commonJS({
       if (options.validateEntrySizes == null) options.validateEntrySizes = true;
       if (options.strictFileNames == null) options.strictFileNames = false;
       if (callback == null) callback = defaultCallback;
-      fs.fstat(fd, function(err, stats) {
+      fs2.fstat(fd, function(err, stats) {
         if (err) return callback(err);
         var reader = fd_slicer.createFromFd(fd, { autoClose: true });
         fromRandomAccessReader(reader, stats.size, options, callback);
@@ -41442,7 +41479,7 @@ var require_extract_zip = __commonJS({
   "../../node_modules/.pnpm/extract-zip@2.0.1/node_modules/extract-zip/index.js"(exports, module) {
     "use strict";
     var debug = require_src()("extract-zip");
-    var { createWriteStream, promises: fs } = __require("fs");
+    var { createWriteStream, promises: fs2 } = __require("fs");
     var getStream = require_get_stream();
     var path2 = __require("path");
     var { promisify: promisify13 } = __require("util");
@@ -41459,7 +41496,7 @@ var require_extract_zip = __commonJS({
         debug("opening", this.zipPath, "with opts", this.opts);
         this.zipfile = await openZip(this.zipPath, { lazyEntries: true });
         this.canceled = false;
-        return new Promise((resolve18, reject) => {
+        return new Promise((resolve19, reject) => {
           this.zipfile.on("error", (err) => {
             this.canceled = true;
             reject(err);
@@ -41468,7 +41505,7 @@ var require_extract_zip = __commonJS({
           this.zipfile.on("close", () => {
             if (!this.canceled) {
               debug("zip extraction complete");
-              resolve18();
+              resolve19();
             }
           });
           this.zipfile.on("entry", async (entry) => {
@@ -41483,8 +41520,8 @@ var require_extract_zip = __commonJS({
             }
             const destDir = path2.dirname(path2.join(this.opts.dir, entry.fileName));
             try {
-              await fs.mkdir(destDir, { recursive: true });
-              const canonicalDestDir = await fs.realpath(destDir);
+              await fs2.mkdir(destDir, { recursive: true });
+              const canonicalDestDir = await fs2.realpath(destDir);
               const relativeDestDir = path2.relative(this.opts.dir, canonicalDestDir);
               if (relativeDestDir.split(path2.sep).includes("..")) {
                 throw new Error(`Out of bound path "${canonicalDestDir}" found while processing file ${entry.fileName}`);
@@ -41528,14 +41565,14 @@ var require_extract_zip = __commonJS({
           mkdirOptions.mode = procMode;
         }
         debug("mkdir", { dir: destDir, ...mkdirOptions });
-        await fs.mkdir(destDir, mkdirOptions);
+        await fs2.mkdir(destDir, mkdirOptions);
         if (isDir) return;
         debug("opening read stream", dest);
         const readStream = await promisify13(this.zipfile.openReadStream.bind(this.zipfile))(entry);
         if (symlink) {
           const link = await getStream(readStream);
           debug("creating symlink", link, dest);
-          await fs.symlink(link, dest);
+          await fs2.symlink(link, dest);
         } else {
           await pipeline(readStream, createWriteStream(dest, { mode: procMode }));
         }
@@ -41567,8 +41604,8 @@ var require_extract_zip = __commonJS({
       if (!path2.isAbsolute(opts.dir)) {
         throw new Error("Target directory is expected to be absolute");
       }
-      await fs.mkdir(opts.dir, { recursive: true });
-      opts.dir = await fs.realpath(opts.dir);
+      await fs2.mkdir(opts.dir, { recursive: true });
+      opts.dir = await fs2.realpath(opts.dir);
       return new Extractor(zipPath, opts).extract();
     };
   }
@@ -43289,7 +43326,7 @@ var require_merge = __commonJS({
 var require_addPairToJSMap = __commonJS({
   "../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/nodes/addPairToJSMap.js"(exports) {
     "use strict";
-    var log9 = require_log();
+    var log17 = require_log();
     var merge = require_merge();
     var stringify = require_stringify();
     var identity = require_identity();
@@ -43338,7 +43375,7 @@ var require_addPairToJSMap = __commonJS({
           let jsonStr = JSON.stringify(strKey);
           if (jsonStr.length > 40)
             jsonStr = jsonStr.substring(0, 36) + '..."';
-          log9.warn(ctx.doc.options.logLevel, `Keys with collection values will be stringified due to JS Object restrictions: ${jsonStr}. Set mapAsMap: true to use object keys.`);
+          log17.warn(ctx.doc.options.logLevel, `Keys with collection values will be stringified due to JS Object restrictions: ${jsonStr}. Set mapAsMap: true to use object keys.`);
           ctx.mapKeyWarned = true;
         }
         return strKey;
@@ -48427,14 +48464,14 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs = this.flowScalar(this.type);
+              const fs2 = this.flowScalar(this.type);
               if (atNextItem || it.value) {
-                map.items.push({ start, key: fs, sep: [] });
+                map.items.push({ start, key: fs2, sep: [] });
                 this.onKeyLine = true;
               } else if (it.sep) {
-                this.stack.push(fs);
+                this.stack.push(fs2);
               } else {
-                Object.assign(it, { key: fs, sep: [] });
+                Object.assign(it, { key: fs2, sep: [] });
                 this.onKeyLine = true;
               }
               return;
@@ -48562,13 +48599,13 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs = this.flowScalar(this.type);
+              const fs2 = this.flowScalar(this.type);
               if (!it || it.value)
-                fc.items.push({ start: [], key: fs, sep: [] });
+                fc.items.push({ start: [], key: fs2, sep: [] });
               else if (it.sep)
-                this.stack.push(fs);
+                this.stack.push(fs2);
               else
-                Object.assign(it, { key: fs, sep: [] });
+                Object.assign(it, { key: fs2, sep: [] });
               return;
             }
             case "flow-map-end":
@@ -48734,7 +48771,7 @@ var require_public_api = __commonJS({
     var composer = require_composer();
     var Document = require_Document();
     var errors = require_errors();
-    var log9 = require_log();
+    var log17 = require_log();
     var identity = require_identity();
     var lineCounter = require_line_counter();
     var parser = require_parser();
@@ -48786,7 +48823,7 @@ var require_public_api = __commonJS({
       const doc = parseDocument(src, options);
       if (!doc)
         return null;
-      doc.warnings.forEach((warning) => log9.warn(doc.options.logLevel, warning));
+      doc.warnings.forEach((warning) => log17.warn(doc.options.logLevel, warning));
       if (doc.errors.length > 0) {
         if (doc.options.logLevel !== "silent")
           throw doc.errors[0];
@@ -50098,6 +50135,8 @@ __export(src_exports, {
   QmdMemoryBackend: () => QmdMemoryBackend,
   RESEARCH_EVENT_TYPES: () => RESEARCH_EVENT_TYPES,
   RESEARCH_EXPORT_FORMATS: () => RESEARCH_EXPORT_FORMATS,
+  RESEARCH_ORCHESTRATION_PHASES: () => RESEARCH_ORCHESTRATION_PHASES,
+  RESEARCH_ORCHESTRATION_STEP_STATUSES: () => RESEARCH_ORCHESTRATION_STEP_STATUSES,
   RESEARCH_RUN_STATUSES: () => RESEARCH_RUN_STATUSES,
   RESEARCH_SOURCE_STATUSES: () => RESEARCH_SOURCE_STATUSES,
   RESEARCH_SOURCE_TYPES: () => RESEARCH_SOURCE_TYPES,
@@ -51568,12 +51607,12 @@ var init_concurrency = __esm({
           this._active++;
           return Promise.resolve();
         }
-        return new Promise((resolve18) => {
+        return new Promise((resolve19) => {
           this._waiters.push({
             priority,
             resolve: () => {
               this._active++;
-              resolve18();
+              resolve19();
             }
           });
         });
@@ -54195,20 +54234,20 @@ async function withRateLimitRetry(fn, options = {}) {
   throw lastError ?? new Error("withRateLimitRetry: unexpected state");
 }
 function sleep(ms, signal) {
-  return new Promise((resolve18, reject) => {
+  return new Promise((resolve19, reject) => {
     if (signal?.aborted) {
       reject(signal.reason ?? new Error("Aborted"));
       return;
     }
-    const timer = setTimeout(resolve18, ms);
+    const timer = setTimeout(resolve19, ms);
     if (signal) {
       const onAbort = () => {
         clearTimeout(timer);
         reject(signal.reason ?? new Error("Aborted"));
       };
       signal.addEventListener("abort", onAbort, { once: true });
-      const origResolve = resolve18;
-      resolve18 = () => {
+      const origResolve = resolve19;
+      resolve19 = () => {
         signal.removeEventListener("abort", onAbort);
         origResolve();
       };
@@ -54288,9 +54327,9 @@ async function readAttachmentContents(rootDir, taskId, attachments) {
     return { attachmentContents, imageContents };
   }
   const { readFile: readFile19 } = await import("node:fs/promises");
-  const { join: join40 } = await import("node:path");
+  const { join: join41 } = await import("node:path");
   for (const att of attachments) {
-    const filePath = join40(
+    const filePath = join41(
       rootDir,
       ".fusion",
       "tasks",
@@ -55828,9 +55867,9 @@ Remove or replace these ids and call fn_task_create again.`
             }
             try {
               const { readFile: readFile19 } = await import("node:fs/promises");
-              const { join: join40 } = await import("node:path");
+              const { join: join41 } = await import("node:path");
               const promptContent = await readFile19(
-                join40(rootDir, promptPath),
+                join41(rootDir, promptPath),
                 "utf-8"
               ).catch((err) => {
                 const msg = err instanceof Error ? err.message : String(err);
@@ -56201,7 +56240,7 @@ import { existsSync as existsSync22 } from "node:fs";
 import { join as join28 } from "node:path";
 import { Type as Type3 } from "typebox";
 async function execWithProcessGroup(command, options) {
-  return new Promise((resolve18, reject) => {
+  return new Promise((resolve19, reject) => {
     if (options.signal?.aborted) {
       reject(Object.assign(
         new Error(`Command aborted before start: ${command}`),
@@ -56294,7 +56333,7 @@ async function execWithProcessGroup(command, options) {
         return;
       }
       if (code === 0) {
-        resolve18({ stdout, stderr, bufferOverflow: stdoutOverflow || stderrOverflow });
+        resolve19({ stdout, stderr, bufferOverflow: stdoutOverflow || stderrOverflow });
         return;
       }
       reject(Object.assign(
@@ -56885,10 +56924,27 @@ async function generateAiMergeSummary(commitLog, diffStat, settings, rootDir) {
     return null;
   }
 }
+async function generateAiMergeSubject(commitLog, diffStat, settings, rootDir, branch, taskId, signal) {
+  try {
+    const resolved = resolveTitleSummarizerSettingsModel(settings);
+    return await summarizeCommitSubject(
+      diffStat,
+      rootDir,
+      resolved.provider,
+      resolved.modelId,
+      { branch, taskId, commitLog, signal }
+    );
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    mergerLog.warn(`AI merge subject failed; using deterministic fallback (${message})`);
+    return null;
+  }
+}
 async function buildDeterministicMergeMessage(params) {
-  const { taskId, branch, commitLog, diffStat, includeTaskId, aiSummary } = params;
+  const { taskId, branch, commitLog, diffStat, includeTaskId, aiSummary, aiSubject } = params;
   const prefix = includeTaskId ? `feat(${taskId})` : "feat";
-  const subject = `${prefix}: merge ${branch}`;
+  const subjectSummary = aiSubject?.trim().length ? aiSubject.trim() : `merge ${branch}`;
+  const subject = `${prefix}: ${subjectSummary}`;
   const trimmedCommitLog = commitLog?.trim() ?? "";
   const trimmedDiffStat = diffStat?.trim() ?? "";
   const commitsSection = trimmedCommitLog.length > 0 ? trimmedCommitLog : `- merge ${branch}`;
@@ -56904,7 +56960,7 @@ ${trimmedDiffStat}` : ""
     bodyArg: `-m "${escape(body)}"`
   };
 }
-async function commitOrAmendMergeWithFixes(rootDir, taskId, branch, commitLog, includeTaskId, preAttemptHeadSha, authorArg, diffStat, settings, signal, aiSummary) {
+async function commitOrAmendMergeWithFixes(rootDir, taskId, branch, commitLog, includeTaskId, preAttemptHeadSha, authorArg, diffStat, settings, signal, aiSummary, aiSubject) {
   try {
     const { stdout: unstagedFiles } = await execAsync2("git diff --name-only", {
       cwd: rootDir,
@@ -56959,7 +57015,8 @@ async function commitOrAmendMergeWithFixes(rootDir, taskId, branch, commitLog, i
       commitLog: messageCommitLog,
       diffStat: messageDiffStat,
       includeTaskId,
-      aiSummary
+      aiSummary,
+      aiSubject
     });
     const trailerArg = buildTaskIdTrailerArg(taskId);
     if (!headMoved) {
@@ -58200,6 +58257,7 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
     diffStat = "(unable to read diff)";
   }
   const aiMergeSummary = settings.useAiMergeCommitSummary ? await generateAiMergeSummary(commitLog, diffStat, settings, rootDir) : null;
+  const aiMergeSubject = settings.useAiMergeCommitSummary ? await generateAiMergeSubject(commitLog, diffStat, settings, rootDir, branch, taskId, options.signal) : null;
   try {
     const scopeResult = await validateDiffScope(store, taskId, diffStat, settings.strictScopeEnforcement);
     for (const warning of scopeResult.warnings) {
@@ -58261,6 +58319,7 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
         commitLog,
         diffStat,
         aiSummary: aiMergeSummary,
+        aiSubject: aiMergeSubject,
         includeTaskId,
         sourceIssueRef,
         smartConflictResolution,
@@ -58383,7 +58442,8 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
                 diffStat,
                 settings,
                 options.signal,
-                aiMergeSummary
+                aiMergeSummary,
+                aiMergeSubject
               );
               if (!finalized) {
                 resetMergeWithWarn(rootDir, taskId, "verification-fix finalize");
@@ -58478,7 +58538,8 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
               diffStat,
               settings,
               options.signal,
-              aiMergeSummary
+              aiMergeSummary,
+              aiMergeSubject
             );
             if (!finalized) {
               resetMergeWithWarn(rootDir, taskId, "build-verification fix finalize");
@@ -58857,6 +58918,7 @@ async function executeMergeAttempt(params, aiTracker) {
     commitLog,
     diffStat,
     aiSummary,
+    aiSubject,
     includeTaskId,
     sourceIssueRef,
     smartConflictResolution,
@@ -59102,7 +59164,8 @@ async function executeMergeAttempt(params, aiTracker) {
         commitLog: actualContext.commitLog || commitLog,
         diffStat: actualContext.diffStat || diffStat,
         includeTaskId,
-        aiSummary
+        aiSummary,
+        aiSubject
       });
       const trailerArg = buildTaskIdTrailerArg(taskId);
       await execAsync2(
@@ -60684,7 +60747,7 @@ function resolveExecutorModelPair(taskModelProvider, taskModelId, settings) {
   return { provider: void 0, modelId: void 0 };
 }
 function sleep2(ms) {
-  return new Promise((resolve18) => setTimeout(resolve18, ms));
+  return new Promise((resolve19) => setTimeout(resolve19, ms));
 }
 var execAsync4, stepExecLog, MAX_STEP_RETRIES, RETRY_DELAYS_MS, NOOP_TASK_STORE, StepSessionExecutor;
 var init_step_session_executor = __esm({
@@ -64909,7 +64972,7 @@ Review the work done in this worktree and evaluate it against the criteria in yo
               );
             }
             const delay2 = this.WORKTREE_RETRY_DELAYS[attempt] || 1e3;
-            await new Promise((resolve18) => setTimeout(resolve18, delay2));
+            await new Promise((resolve19) => setTimeout(resolve19, delay2));
           }
         }
         throw new Error("Unexpected exit from worktree creation retry loop");
@@ -65552,8 +65615,8 @@ Review the work done in this worktree and evaluate it against the criteria in yo
           executorLog.warn(`${taskId}: recoverApprovedStepsOnResume getTask failed: ${err instanceof Error ? err.message : String(err)}`);
           return;
         }
-        const log9 = detail.log ?? [];
-        if (log9.length === 0) return;
+        const log17 = detail.log ?? [];
+        if (log17.length === 0) return;
         let recovered = 0;
         for (let i = 0; i < detail.steps.length; i++) {
           if (detail.steps[i].status !== "in-progress") continue;
@@ -65562,8 +65625,8 @@ Review the work done in this worktree and evaluate it against the criteria in yo
           const stepName = detail.steps[i].name;
           const transitionPrefix = `Step ${i} (${stepName}) \u2192 `;
           const approvePrefix = `code review Step ${i}:`;
-          for (let j = 0; j < log9.length; j++) {
-            const action = log9[j].action || "";
+          for (let j = 0; j < log17.length; j++) {
+            const action = log17[j].action || "";
             if (action.startsWith(transitionPrefix)) {
               const status = action.slice(transitionPrefix.length).trim();
               if (status === "pending") lastPendingAt = j;
@@ -70492,6 +70555,1651 @@ ${taskDetail.prompt}` : "No PROMPT.md available.",
   }
 });
 
+// ../engine/src/research-orchestrator.ts
+var log6, ResearchOrchestrator;
+var init_research_orchestrator = __esm({
+  "../engine/src/research-orchestrator.ts"() {
+    "use strict";
+    init_concurrency();
+    init_logger2();
+    log6 = createLogger2("research-orchestrator");
+    ResearchOrchestrator = class {
+      store;
+      stepRunner;
+      semaphore;
+      activeRuns = /* @__PURE__ */ new Map();
+      cancellation = /* @__PURE__ */ new Map();
+      constructor(options) {
+        this.store = options.store;
+        this.stepRunner = options.stepRunner;
+        this.semaphore = new AgentSemaphore(options.maxConcurrentRuns ?? 3);
+      }
+      createRun(config) {
+        const run = this.store.createRun({
+          query: "",
+          providerConfig: config,
+          metadata: {
+            orchestration: {
+              phase: "planning",
+              stepIndex: 0,
+              totalSteps: this.computeTotalSteps(config)
+            }
+          }
+        });
+        return run.id;
+      }
+      async startRun(runId, query, options = {}) {
+        const run = this.store.getRun(runId);
+        if (!run) throw new Error(`Research run not found: ${runId}`);
+        const config = run.providerConfig ?? {};
+        const controller = new AbortController();
+        if (options.abortSignal) {
+          options.abortSignal.addEventListener("abort", () => controller.abort(options.abortSignal?.reason), { once: true });
+        }
+        const totalSteps = this.computeTotalSteps(config);
+        this.activeRuns.set(runId, {
+          controller,
+          phase: "planning",
+          stepIndex: 0,
+          totalSteps,
+          config
+        });
+        await this.semaphore.run(async () => {
+          this.store.updateRun(runId, { query, status: "running", startedAt: (/* @__PURE__ */ new Date()).toISOString(), error: null });
+          await this.runPhases(runId, query, config, controller.signal);
+        });
+        const updated = this.store.getRun(runId);
+        if (!updated) throw new Error(`Research run not found after start: ${runId}`);
+        return updated;
+      }
+      cancelRun(runId) {
+        const active = this.activeRuns.get(runId);
+        if (!active) return false;
+        const state = {
+          runId,
+          controller: active.controller,
+          requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          gracefulShutdown: true,
+          reason: "Cancelled by user"
+        };
+        this.cancellation.set(runId, state);
+        active.controller.abort(new Error("Research run cancelled"));
+        return true;
+      }
+      retryRun(runId) {
+        const run = this.store.getRun(runId);
+        if (!run) throw new Error(`Research run not found: ${runId}`);
+        if (run.status !== "failed" && run.status !== "cancelled") {
+          throw new Error(`Research run ${runId} is not retryable (status=${run.status})`);
+        }
+        const next = this.store.createRun({
+          query: run.query,
+          topic: run.topic,
+          providerConfig: run.providerConfig,
+          tags: [...run.tags],
+          metadata: {
+            ...run.metadata ?? {},
+            retryOfRunId: run.id
+          }
+        });
+        this.store.addEvent(next.id, {
+          type: "info",
+          message: `Retry run created from ${run.id}`,
+          metadata: { retryOfRunId: run.id }
+        });
+        return next.id;
+      }
+      getRunStatus(runId) {
+        const run = this.store.getRun(runId);
+        if (!run) throw new Error(`Research run not found: ${runId}`);
+        const active = this.activeRuns.get(runId);
+        const metadata = run.metadata?.orchestration ?? {};
+        const phase = active?.phase ?? metadata.phase ?? this.statusToPhase(run.status);
+        const stepIndex = active?.stepIndex ?? Number(metadata.stepIndex ?? 0);
+        const totalSteps = active?.totalSteps ?? Number(metadata.totalSteps ?? 0);
+        return {
+          runId,
+          status: run.status,
+          phase,
+          stepIndex,
+          totalSteps,
+          progress: totalSteps > 0 ? Math.min(1, stepIndex / totalSteps) : 0,
+          active: this.activeRuns.has(runId)
+        };
+      }
+      async runPhases(runId, query, config, signal) {
+        try {
+          await this.runPlanning(runId, query, config, signal);
+          const sources = await this.runSearching(runId, query, config, signal);
+          const fetchedSources = await this.runFetching(runId, sources, config, signal);
+          const synthesis = await this.runSynthesis(runId, query, fetchedSources, config, signal);
+          await this.runFinalizing(runId, synthesis.output, synthesis.citations, synthesis.confidence, signal);
+          this.store.updateStatus(runId, "completed");
+          this.transitionPhase(runId, "completed", "Research run completed");
+        } catch (err) {
+          if (signal.aborted) {
+            this.onCancelled(runId);
+          } else {
+            const { message, detail } = formatError(err);
+            this.store.addEvent(runId, {
+              type: "error",
+              message: `Research run failed: ${message}`,
+              metadata: { detail }
+            });
+            this.store.updateStatus(runId, "failed", { error: message });
+            this.transitionPhase(runId, "failed", "Research run failed", { error: message });
+          }
+        } finally {
+          this.activeRuns.delete(runId);
+          this.cancellation.delete(runId);
+        }
+      }
+      async runPlanning(runId, query, config, _signal) {
+        this.transitionPhase(runId, "planning", "Planning research execution");
+        this.stepStarted(runId, {
+          id: `${runId}-planning`,
+          type: "synthesis-pass",
+          phase: "planning",
+          status: "running",
+          order: 0,
+          name: "Create plan",
+          input: { query, providerCount: config.providers.length },
+          startedAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        this.stepCompleted(runId, `${runId}-planning`, { query });
+      }
+      async runSearching(runId, query, config, signal) {
+        this.throwIfAborted(signal);
+        this.transitionPhase(runId, "searching", "Searching sources");
+        const allSources = [];
+        for (const provider of config.providers) {
+          this.throwIfAborted(signal);
+          const step = this.createStep(runId, "source-query", "searching", `Search with ${provider.type}`, {
+            query,
+            provider: provider.type
+          });
+          this.stepStarted(runId, step);
+          const result = await this.stepRunner.runSourceQuery(query, provider.type, provider.config, signal);
+          if (!result.ok || !result.data) {
+            this.stepFailed(runId, step.id, result.error?.message ?? `Provider ${provider.type} returned no data`, result.error);
+            continue;
+          }
+          for (const source of result.data.slice(0, Math.max(0, config.maxSources - allSources.length))) {
+            const saved = this.store.addSource(runId, source);
+            allSources.push(saved);
+            this.store.addEvent(runId, {
+              type: "source_added",
+              message: `Source found: ${saved.reference}`,
+              metadata: { sourceId: saved.id, provider: provider.type }
+            });
+          }
+          this.stepCompleted(runId, step.id, { sourceCount: result.data.length });
+          if (allSources.length >= config.maxSources) break;
+        }
+        if (allSources.length === 0) {
+          throw new Error("No sources discovered during search phase");
+        }
+        return allSources;
+      }
+      async runFetching(runId, sources, config, signal) {
+        this.throwIfAborted(signal);
+        this.transitionPhase(runId, "fetching", "Fetching source content");
+        const fetched = [];
+        const provider = config.providers[0];
+        for (const source of sources.slice(0, config.maxSources)) {
+          this.throwIfAborted(signal);
+          const step = this.createStep(runId, "content-fetch", "fetching", `Fetch ${source.reference}`, {
+            sourceId: source.id
+          });
+          this.stepStarted(runId, step);
+          const result = await this.stepRunner.runContentFetch(source.reference, provider?.config, signal);
+          if (!result.ok || !result.data) {
+            this.stepFailed(runId, step.id, result.error?.message ?? "Failed to fetch source content", result.error);
+            continue;
+          }
+          const updated = {
+            ...source,
+            content: result.data.content,
+            metadata: {
+              ...source.metadata ?? {},
+              ...result.data.metadata ?? {}
+            },
+            status: "completed",
+            fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          this.store.updateSource(runId, source.id, updated);
+          fetched.push(updated);
+          this.stepCompleted(runId, step.id, { fetched: true });
+        }
+        if (fetched.length === 0) {
+          throw new Error("No source content fetched");
+        }
+        return fetched;
+      }
+      async runSynthesis(runId, query, sources, config, signal) {
+        this.throwIfAborted(signal);
+        this.transitionPhase(runId, "synthesizing", "Synthesizing findings");
+        let final;
+        for (let round = 1; round <= Math.max(1, config.maxSynthesisRounds); round++) {
+          this.throwIfAborted(signal);
+          const step = this.createStep(runId, "synthesis-pass", "synthesizing", `Synthesis round ${round}`, {
+            round
+          });
+          this.stepStarted(runId, step);
+          const request2 = {
+            query,
+            sources,
+            round,
+            desiredFormat: "markdown"
+          };
+          const result = await this.stepRunner.runSynthesis(request2, config.synthesisModel, signal);
+          if (!result.ok || !result.data) {
+            this.stepFailed(runId, step.id, result.error?.message ?? "Synthesis failed", result.error);
+            continue;
+          }
+          final = result.data;
+          this.store.addEvent(runId, {
+            type: "progress",
+            message: `Synthesis round ${round} completed`,
+            metadata: { round, confidence: result.data.confidence }
+          });
+          this.stepCompleted(runId, step.id, { round, citations: result.data.citations.length });
+        }
+        if (!final) {
+          throw new Error("All synthesis rounds failed");
+        }
+        return final;
+      }
+      async runFinalizing(runId, output, citations, confidence, signal) {
+        this.throwIfAborted(signal);
+        this.transitionPhase(runId, "finalizing", "Finalizing research results");
+        this.store.setResults(runId, {
+          summary: output,
+          findings: [
+            {
+              heading: "Synthesis",
+              content: output,
+              sources: citations,
+              confidence
+            }
+          ],
+          citations,
+          synthesizedOutput: output
+        });
+      }
+      onCancelled(runId) {
+        const cancellation = this.cancellation.get(runId);
+        this.store.addEvent(runId, {
+          type: "warning",
+          message: "Research run cancelled",
+          metadata: {
+            requestedAt: cancellation?.requestedAt,
+            reason: cancellation?.reason
+          }
+        });
+        this.store.updateStatus(runId, "cancelled", {
+          cancelledAt: (/* @__PURE__ */ new Date()).toISOString(),
+          error: cancellation?.reason
+        });
+        this.transitionPhase(runId, "cancelled", "Research run cancelled");
+      }
+      transitionPhase(runId, phase, message, metadata) {
+        const active = this.activeRuns.get(runId);
+        if (active) {
+          active.phase = phase;
+        }
+        this.store.updateRun(runId, {
+          metadata: {
+            orchestration: {
+              phase,
+              stepIndex: active?.stepIndex ?? 0,
+              totalSteps: active?.totalSteps ?? 0
+            }
+          }
+        });
+        this.store.addEvent(runId, {
+          type: "progress",
+          message,
+          metadata: {
+            orchestrationEventType: "phase-changed",
+            phase,
+            ...metadata ?? {}
+          }
+        });
+        log6.log(`${runId}: phase changed -> ${phase}`);
+      }
+      stepStarted(runId, step) {
+        this.bumpStep(runId, step.order);
+        this.store.addEvent(runId, {
+          type: "progress",
+          message: `${step.name} started`,
+          metadata: {
+            orchestrationEventType: "step-started",
+            step
+          }
+        });
+      }
+      stepCompleted(runId, stepId, output) {
+        this.store.addEvent(runId, {
+          type: "progress",
+          message: `${stepId} completed`,
+          metadata: {
+            orchestrationEventType: "step-completed",
+            stepId,
+            output
+          }
+        });
+      }
+      stepFailed(runId, stepId, errorMessage, errorMeta) {
+        this.store.addEvent(runId, {
+          type: "error",
+          message: `${stepId} failed: ${errorMessage}`,
+          metadata: {
+            orchestrationEventType: "step-failed",
+            stepId,
+            ...errorMeta ?? {}
+          }
+        });
+      }
+      bumpStep(runId, stepIndex) {
+        const active = this.activeRuns.get(runId);
+        if (!active) return;
+        active.stepIndex = stepIndex;
+        this.store.updateRun(runId, {
+          metadata: {
+            orchestration: {
+              phase: active.phase,
+              stepIndex: active.stepIndex,
+              totalSteps: active.totalSteps
+            }
+          }
+        });
+      }
+      createStep(runId, type, phase, name, input) {
+        const active = this.activeRuns.get(runId);
+        const order = (active?.stepIndex ?? 0) + 1;
+        return {
+          id: `${runId}-${phase}-${order}`,
+          type,
+          phase,
+          status: "running",
+          order,
+          name,
+          input,
+          startedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      }
+      computeTotalSteps(config) {
+        const providers = Math.max(1, config.providers.length);
+        return 1 + providers + Math.max(1, config.maxSources) + Math.max(1, config.maxSynthesisRounds) + 1;
+      }
+      statusToPhase(status) {
+        if (status === "completed") return "completed";
+        if (status === "failed") return "failed";
+        if (status === "cancelled") return "cancelled";
+        return "planning";
+      }
+      throwIfAborted(signal) {
+        if (signal.aborted) {
+          throw signal.reason ?? new Error("Research run aborted");
+        }
+      }
+    };
+  }
+});
+
+// ../engine/src/research-step-runner.ts
+var log7, DEFAULT_QUERY_TIMEOUT_MS, DEFAULT_FETCH_TIMEOUT_MS, DEFAULT_SYNTHESIS_TIMEOUT_MS, ResearchStepTimeoutError, ResearchStepAbortError, ResearchStepProviderError, ResearchStepRunner;
+var init_research_step_runner = __esm({
+  "../engine/src/research-step-runner.ts"() {
+    "use strict";
+    init_logger2();
+    log7 = createLogger2("research-step-runner");
+    DEFAULT_QUERY_TIMEOUT_MS = 3e4;
+    DEFAULT_FETCH_TIMEOUT_MS = 6e4;
+    DEFAULT_SYNTHESIS_TIMEOUT_MS = 12e4;
+    ResearchStepTimeoutError = class extends Error {
+      constructor(step, timeoutMs) {
+        super(`${step} timed out after ${timeoutMs}ms`);
+        this.name = "ResearchStepTimeoutError";
+      }
+    };
+    ResearchStepAbortError = class extends Error {
+      constructor(step) {
+        super(`${step} aborted`);
+        this.name = "ResearchStepAbortError";
+      }
+    };
+    ResearchStepProviderError = class extends Error {
+      constructor(step, message) {
+        super(`${step} provider error: ${message}`);
+        this.name = "ResearchStepProviderError";
+      }
+    };
+    ResearchStepRunner = class {
+      providers;
+      synthesisRunner;
+      constructor(options = {}) {
+        this.providers = new Map((options.providers ?? []).map((provider) => [provider.type, provider]));
+        this.synthesisRunner = options.synthesisRunner;
+      }
+      async runSourceQuery(query, providerType, config = {}, signal) {
+        const provider = this.providers.get(providerType);
+        if (!provider || !provider.isConfigured()) {
+          return this.unconfigured(`provider ${providerType} is not configured`);
+        }
+        try {
+          const data = await this.withTimeout(
+            `source-query:${providerType}`,
+            provider.search(query, config, signal),
+            config.timeoutMs ?? DEFAULT_QUERY_TIMEOUT_MS,
+            signal
+          );
+          return { ok: true, data };
+        } catch (error) {
+          return this.classifyError("source-query", error);
+        }
+      }
+      async runContentFetch(url, config = {}, signal) {
+        const provider = this.findFirstConfiguredProvider();
+        if (!provider) {
+          return this.unconfigured("no configured provider available for content fetch");
+        }
+        try {
+          const data = await this.withTimeout(
+            `content-fetch:${provider.type}`,
+            provider.fetchContent(url, config, signal),
+            config.timeoutMs ?? DEFAULT_FETCH_TIMEOUT_MS,
+            signal
+          );
+          return { ok: true, data };
+        } catch (error) {
+          return this.classifyError("content-fetch", error);
+        }
+      }
+      async runSynthesis(request2, modelSettings = {}, signal) {
+        if (!this.synthesisRunner) {
+          return this.unconfigured("synthesis provider is not configured");
+        }
+        try {
+          const timeoutMs = modelSettings.timeoutMs ?? DEFAULT_SYNTHESIS_TIMEOUT_MS;
+          const data = await this.withTimeout(
+            "synthesis",
+            this.synthesisRunner(request2, modelSettings, signal),
+            timeoutMs,
+            signal
+          );
+          return { ok: true, data };
+        } catch (error) {
+          return this.classifyError("synthesis", error);
+        }
+      }
+      findFirstConfiguredProvider() {
+        for (const provider of this.providers.values()) {
+          if (provider.isConfigured()) return provider;
+        }
+        return void 0;
+      }
+      classifyError(step, error) {
+        if (error instanceof ResearchStepTimeoutError) {
+          return { ok: false, error: { code: "timeout", message: error.message, retryable: true } };
+        }
+        if (error instanceof ResearchStepAbortError) {
+          return { ok: false, error: { code: "aborted", message: error.message, retryable: false } };
+        }
+        const { message, detail } = formatError(error);
+        log7.warn(`${step} failed`, detail);
+        return {
+          ok: false,
+          error: {
+            code: "provider_error",
+            message,
+            retryable: true
+          }
+        };
+      }
+      unconfigured(message) {
+        return {
+          ok: false,
+          error: {
+            code: "provider_not_configured",
+            message,
+            retryable: false
+          }
+        };
+      }
+      async withTimeout(step, promise, timeoutMs, signal) {
+        if (signal?.aborted) {
+          throw new ResearchStepAbortError(step);
+        }
+        let timeoutId;
+        let abortListener;
+        const abortPromise = new Promise((_, reject) => {
+          if (!signal) return;
+          abortListener = () => reject(new ResearchStepAbortError(step));
+          signal.addEventListener("abort", abortListener, { once: true });
+        });
+        const timeoutPromise = new Promise((_, reject) => {
+          timeoutId = setTimeout(() => reject(new ResearchStepTimeoutError(step, timeoutMs)), timeoutMs);
+        });
+        try {
+          return await Promise.race([promise, timeoutPromise, abortPromise]);
+        } finally {
+          if (timeoutId) clearTimeout(timeoutId);
+          if (signal && abortListener) {
+            signal.removeEventListener("abort", abortListener);
+          }
+        }
+      }
+    };
+  }
+});
+
+// ../engine/src/research/types.ts
+var ResearchProviderError;
+var init_types2 = __esm({
+  "../engine/src/research/types.ts"() {
+    "use strict";
+    ResearchProviderError = class extends Error {
+      providerType;
+      code;
+      retryable;
+      constructor(options) {
+        super(options.message, options.cause ? { cause: options.cause } : void 0);
+        this.name = "ResearchProviderError";
+        this.providerType = options.providerType;
+        this.code = options.code;
+        this.retryable = options.retryable ?? false;
+      }
+    };
+  }
+});
+
+// ../engine/src/research/providers/github-provider.ts
+function isGhError(value) {
+  return value instanceof Error && "stderr" in value && "stdout" in value && "code" in value;
+}
+function parseGitHubUrl(url) {
+  let parsedUrl;
+  try {
+    parsedUrl = new URL(url);
+  } catch {
+    return null;
+  }
+  if (!/(^|\.)github\.com$/i.test(parsedUrl.hostname)) {
+    return null;
+  }
+  const segments = parsedUrl.pathname.split("/").filter(Boolean);
+  if (segments.length < 2) return null;
+  const [owner, repo, section, ...rest] = segments;
+  if (!section) {
+    return { owner, repo, kind: "repo" };
+  }
+  if (section === "issues" && rest[0]) {
+    return { owner, repo, kind: "issue", number: rest[0] };
+  }
+  if (section === "pull" && rest[0]) {
+    return { owner, repo, kind: "pr", number: rest[0] };
+  }
+  if (section === "blob" && rest.length >= 2) {
+    return { owner, repo, kind: "file", ref: rest[0], filePath: rest.slice(1).join("/") };
+  }
+  return null;
+}
+var log8, DEFAULT_TIMEOUT_MS, GitHubProvider;
+var init_github_provider = __esm({
+  "../engine/src/research/providers/github-provider.ts"() {
+    "use strict";
+    init_src();
+    init_logger2();
+    init_types2();
+    log8 = createLogger2("research:github");
+    DEFAULT_TIMEOUT_MS = 3e4;
+    GitHubProvider = class {
+      type = "github";
+      async search(query, config = {}, signal) {
+        const timeoutMs = Number(config.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+        const maxResults = Number(config.maxResults ?? 10);
+        const searchType = config.metadata?.searchType ?? "both";
+        const sources = [];
+        try {
+          if (searchType === "repos" || searchType === "both") {
+            const repos = await runGhJsonAsync(
+              [
+                "search",
+                "repos",
+                query,
+                "--json",
+                "fullName,description,htmlUrl,stargazersCount,language,updatedAt",
+                "--limit",
+                String(maxResults)
+              ],
+              { signal, timeoutMs }
+            );
+            sources.push(
+              ...repos.slice(0, maxResults).map((repo, idx) => ({
+                id: `github-repo-${idx}-${repo.htmlUrl}`,
+                type: "github",
+                reference: repo.htmlUrl,
+                title: repo.fullName,
+                excerpt: repo.description ?? "",
+                status: "completed",
+                metadata: {
+                  resultType: "repo",
+                  stars: repo.stargazersCount ?? 0,
+                  language: repo.language,
+                  updatedAt: repo.updatedAt,
+                  rank: idx + 1
+                }
+              }))
+            );
+          }
+          if (searchType === "issues" || searchType === "both") {
+            const issues = await runGhJsonAsync(
+              [
+                "search",
+                "issues",
+                query,
+                "--json",
+                "title,body,htmlUrl,state,labels",
+                "--limit",
+                String(maxResults)
+              ],
+              { signal, timeoutMs }
+            );
+            sources.push(
+              ...issues.slice(0, maxResults).map((issue, idx) => ({
+                id: `github-issue-${idx}-${issue.htmlUrl}`,
+                type: "github",
+                reference: issue.htmlUrl,
+                title: issue.title,
+                excerpt: issue.body?.slice(0, 280) ?? "",
+                status: "completed",
+                metadata: {
+                  resultType: "issue",
+                  state: issue.state,
+                  labels: (issue.labels ?? []).map((label) => label.name).filter(Boolean),
+                  rank: idx + 1
+                }
+              }))
+            );
+          }
+          return sources;
+        } catch (error) {
+          throw this.mapGhError(error);
+        }
+      }
+      async fetchContent(url, config = {}, signal) {
+        const parsed = parseGitHubUrl(url);
+        if (!parsed) {
+          throw new ResearchProviderError({
+            providerType: "github",
+            code: "provider-unavailable",
+            message: "Unsupported GitHub URL"
+          });
+        }
+        const timeoutMs = Number(config.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+        try {
+          if (parsed.kind === "repo") {
+            const readme = await runGhJsonAsync(
+              ["api", `repos/${parsed.owner}/${parsed.repo}/readme`],
+              { signal, timeoutMs }
+            );
+            if (readme.encoding !== "base64" || !readme.content) {
+              throw new ResearchProviderError({
+                providerType: "github",
+                code: "provider-unavailable",
+                message: "Unsupported README encoding"
+              });
+            }
+            const content2 = Buffer.from(readme.content.replace(/\n/g, ""), "base64").toString("utf-8");
+            return {
+              content: content2,
+              metadata: {
+                url,
+                owner: parsed.owner,
+                repo: parsed.repo,
+                kind: "repo-readme",
+                name: readme.name
+              },
+              mimeType: "text/markdown"
+            };
+          }
+          if (parsed.kind === "issue") {
+            const issue = await runGhAsync(["issue", "view", parsed.number ?? "", "--repo", `${parsed.owner}/${parsed.repo}`, "--comments"], {
+              signal,
+              timeoutMs
+            });
+            return {
+              content: issue,
+              metadata: { url, owner: parsed.owner, repo: parsed.repo, kind: "issue", number: parsed.number },
+              mimeType: "text/plain"
+            };
+          }
+          if (parsed.kind === "pr") {
+            const pr = await runGhAsync(["pr", "view", parsed.number ?? "", "--repo", `${parsed.owner}/${parsed.repo}`, "--comments"], {
+              signal,
+              timeoutMs
+            });
+            return {
+              content: pr,
+              metadata: { url, owner: parsed.owner, repo: parsed.repo, kind: "pr", number: parsed.number },
+              mimeType: "text/plain"
+            };
+          }
+          const apiPath = `repos/${parsed.owner}/${parsed.repo}/contents/${parsed.filePath ?? ""}${parsed.ref ? `?ref=${encodeURIComponent(parsed.ref)}` : ""}`;
+          const file = await runGhJsonAsync(["api", apiPath], {
+            signal,
+            timeoutMs
+          });
+          const content = file.encoding === "base64" && file.content ? Buffer.from(file.content.replace(/\n/g, ""), "base64").toString("utf-8") : file.content ?? "";
+          return {
+            content,
+            metadata: {
+              url,
+              owner: parsed.owner,
+              repo: parsed.repo,
+              kind: "file",
+              path: parsed.filePath,
+              ref: parsed.ref,
+              name: file.name
+            },
+            mimeType: "text/plain"
+          };
+        } catch (error) {
+          throw this.mapGhError(error);
+        }
+      }
+      isConfigured() {
+        return isGhAvailable() && isGhAuthenticated();
+      }
+      mapGhError(error) {
+        if (error instanceof ResearchProviderError) return error;
+        if (isGhError(error)) {
+          const message = `${error.message}${error.stderr ? `: ${error.stderr}` : ""}`;
+          const lowered = message.toLowerCase();
+          if (error.code === "ABORT_ERR" || lowered.includes("aborted")) {
+            return new ResearchProviderError({ providerType: "github", code: "abort", message, cause: error });
+          }
+          if (lowered.includes("timed out")) {
+            return new ResearchProviderError({
+              providerType: "github",
+              code: "timeout",
+              message,
+              retryable: true,
+              cause: error
+            });
+          }
+          if (error.code === 403 || lowered.includes("rate limit")) {
+            return new ResearchProviderError({
+              providerType: "github",
+              code: "rate-limited",
+              message,
+              retryable: true,
+              cause: error
+            });
+          }
+          if (error.code === 401 || lowered.includes("not logged") || lowered.includes("authentication")) {
+            return new ResearchProviderError({
+              providerType: "github",
+              code: "auth-failed",
+              message,
+              cause: error
+            });
+          }
+          if (error.code === 404 || lowered.includes("not found")) {
+            return new ResearchProviderError({
+              providerType: "github",
+              code: "provider-unavailable",
+              message,
+              cause: error
+            });
+          }
+          return new ResearchProviderError({
+            providerType: "github",
+            code: "network-error",
+            message,
+            retryable: true,
+            cause: error
+          });
+        }
+        log8.warn("github provider error", { error });
+        return new ResearchProviderError({
+          providerType: "github",
+          code: "network-error",
+          message: error instanceof Error ? error.message : "GitHub provider failed",
+          retryable: true,
+          cause: error
+        });
+      }
+    };
+  }
+});
+
+// ../engine/src/research/providers/llm-synthesis-provider.ts
+function isLargeModel(modelId) {
+  const id = modelId?.toLowerCase() ?? "";
+  return id.includes("gpt-5") || id.includes("claude-opus") || id.includes("gemini-2.5-pro") || id.includes("sonnet");
+}
+function scoreSource(source) {
+  const confidence = typeof source.metadata?.confidence === "number" ? source.metadata.confidence : 0;
+  const hasContent = source.content ? 1 : 0;
+  return confidence * 10 + hasContent;
+}
+function buildSynthesisPrompt(request2, sources) {
+  const format = request2.desiredFormat ?? "markdown";
+  const renderedSources = sources.map(
+    (source, index) => `Source [${index + 1}]
+Title: ${source.title ?? source.reference}
+Reference: ${source.reference}
+Excerpt: ${source.excerpt ?? ""}
+Content: ${source.content ?? ""}`
+  ).join("\n\n");
+  return [
+    "You are a research synthesis assistant.",
+    `Query: ${request2.query}`,
+    `Round: ${request2.round}`,
+    `Desired format: ${format}`,
+    "Analyze the provided sources and produce: summary, key findings, contradictions, confidence, and follow-up queries.",
+    "Cite source references inline using [n] notation where n is source number.",
+    request2.instructions ? `Additional instructions: ${request2.instructions}` : "",
+    "Sources:",
+    renderedSources,
+    'Return valid JSON: {"summary": string, "findings": [{"statement": string, "citations": string[]}], "confidence": number, "followUps": string[]}'
+  ].filter(Boolean).join("\n\n");
+}
+function extractAssistantText(session) {
+  const messages = session.state?.messages;
+  if (!Array.isArray(messages)) return void 0;
+  for (let i = messages.length - 1; i >= 0; i -= 1) {
+    const msg = messages[i];
+    if (msg.role !== "assistant") continue;
+    if (typeof msg.content === "string" && msg.content.trim()) return msg.content;
+    if (Array.isArray(msg.content)) {
+      for (const part of msg.content) {
+        if (typeof part === "object" && part && "text" in part && typeof part.text === "string") {
+          return part.text;
+        }
+      }
+    }
+  }
+  return void 0;
+}
+function extractCitations(text, sources) {
+  const matches = text.match(/\[(\d+)\]/g) ?? [];
+  const refs = /* @__PURE__ */ new Set();
+  for (const match of matches) {
+    const idx = Number.parseInt(match.replace(/\D/g, ""), 10) - 1;
+    if (Number.isFinite(idx) && idx >= 0 && idx < sources.length) {
+      refs.add(sources[idx].reference);
+    }
+  }
+  return [...refs];
+}
+function extractConfidence(text) {
+  const jsonBlock = text.match(/```(?:json)?\s*([\s\S]*?)```/i)?.[1] ?? text;
+  try {
+    const parsed = JSON.parse(jsonBlock);
+    if (typeof parsed.confidence === "number") return parsed.confidence;
+  } catch {
+    const match = text.match(/"confidence"\s*:\s*([0-9]*\.?[0-9]+)/i);
+    if (match) {
+      const parsed = Number.parseFloat(match[1]);
+      if (Number.isFinite(parsed)) return parsed;
+    }
+  }
+  return void 0;
+}
+var log9, DEFAULT_TIMEOUT_MS2, LARGE_MODEL_CONTEXT_CHARS, SMALL_MODEL_CONTEXT_CHARS, LLMSynthesisProvider;
+var init_llm_synthesis_provider = __esm({
+  "../engine/src/research/providers/llm-synthesis-provider.ts"() {
+    "use strict";
+    init_logger2();
+    init_pi();
+    init_types2();
+    log9 = createLogger2("research:llm-synthesis");
+    DEFAULT_TIMEOUT_MS2 = 12e4;
+    LARGE_MODEL_CONTEXT_CHARS = 1e5;
+    SMALL_MODEL_CONTEXT_CHARS = 3e4;
+    LLMSynthesisProvider = class {
+      constructor(options) {
+        this.options = options;
+      }
+      type = "llm-synthesis";
+      isConfigured() {
+        return true;
+      }
+      async search(_query, _options = {}, _signal) {
+        return [];
+      }
+      async fetchContent(_url, _options = {}, _signal) {
+        return { content: "", metadata: {} };
+      }
+      async synthesize(request2, modelSelection, signal) {
+        if (!modelSelection?.provider || !modelSelection?.modelId) {
+          throw new ResearchProviderError({ providerType: "llm-synthesis", code: "provider-unavailable", message: "Synthesis model is not configured" });
+        }
+        const timeoutSignal = AbortSignal.timeout(this.options.timeoutMs ?? DEFAULT_TIMEOUT_MS2);
+        const requestSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
+        try {
+          const cappedSources = this.applySourceBudget(request2.sources, modelSelection);
+          const prompt = buildSynthesisPrompt(request2, cappedSources);
+          const { session } = await createFnAgent2({
+            cwd: this.options.projectRoot,
+            tools: "readonly",
+            systemPrompt: "You synthesize research findings into concise, cited outputs.",
+            defaultProvider: modelSelection.provider,
+            defaultModelId: modelSelection.modelId
+          });
+          try {
+            await Promise.race([
+              promptWithFallback(session, prompt),
+              new Promise((_, reject) => {
+                requestSignal.addEventListener(
+                  "abort",
+                  () => reject(new ResearchProviderError({
+                    providerType: "llm-synthesis",
+                    code: signal?.aborted ? "abort" : "timeout",
+                    message: signal?.aborted ? "Synthesis aborted" : "Synthesis timed out",
+                    retryable: !signal?.aborted
+                  })),
+                  { once: true }
+                );
+              })
+            ]);
+            if (requestSignal.aborted) {
+              throw new ResearchProviderError({ providerType: "llm-synthesis", code: signal?.aborted ? "abort" : "timeout", message: signal?.aborted ? "Synthesis aborted" : "Synthesis timed out", retryable: !signal?.aborted });
+            }
+            const responseText = extractAssistantText(session);
+            if (!responseText) {
+              throw new ResearchProviderError({ providerType: "llm-synthesis", code: "provider-unavailable", message: "No synthesis response received" });
+            }
+            return {
+              output: responseText,
+              citations: extractCitations(responseText, cappedSources),
+              confidence: extractConfidence(responseText),
+              metadata: {
+                sourceCount: cappedSources.length,
+                truncated: cappedSources.length < request2.sources.length
+              }
+            };
+          } finally {
+            session.dispose();
+          }
+        } catch (error) {
+          if (error instanceof ResearchProviderError) throw error;
+          if (error instanceof DOMException && error.name === "AbortError") {
+            throw new ResearchProviderError({ providerType: "llm-synthesis", code: "abort", message: "Synthesis aborted", cause: error });
+          }
+          log9.warn("llm synthesis failed", { error });
+          throw new ResearchProviderError({
+            providerType: "llm-synthesis",
+            code: "provider-unavailable",
+            message: error instanceof Error ? error.message : "Synthesis failed",
+            retryable: true,
+            cause: error
+          });
+        }
+      }
+      applySourceBudget(sources, modelSelection) {
+        const contextChars = isLargeModel(modelSelection.modelId) ? LARGE_MODEL_CONTEXT_CHARS : SMALL_MODEL_CONTEXT_CHARS;
+        const budget = Math.floor(contextChars * 0.8);
+        const ordered = [...sources].sort((a, b) => scoreSource(b) - scoreSource(a));
+        let total = 0;
+        const kept = [];
+        for (const source of ordered) {
+          const chunk = `${source.title ?? ""}
+${source.excerpt ?? ""}
+${source.content ?? ""}`;
+          if (total + chunk.length > budget) continue;
+          total += chunk.length;
+          kept.push(source);
+        }
+        return kept.length > 0 ? kept : ordered.slice(0, 1);
+      }
+    };
+  }
+});
+
+// ../engine/src/research/providers/local-docs-provider.ts
+import { promises as fs } from "node:fs";
+import { extname as extname2, join as join35, relative as relative7, resolve as resolve15 } from "node:path";
+function buildExcerpt(content, terms) {
+  const lower = content.toLowerCase();
+  const first = terms.find((term) => lower.includes(term));
+  if (!first) return content.slice(0, 220).replace(/\s+/g, " ").trim();
+  const idx = lower.indexOf(first);
+  const start = Math.max(0, idx - 80);
+  const end = Math.min(content.length, idx + 140);
+  return content.slice(start, end).replace(/\s+/g, " ").trim();
+}
+function matchesGitignore(relPath, patterns) {
+  return patterns.some((pattern) => {
+    if (pattern.endsWith("/")) return relPath.startsWith(pattern.slice(0, -1));
+    if (pattern.includes("*")) {
+      const regex = new RegExp(`^${pattern.split("*").map(escapeRegex2).join(".*")}$`);
+      return regex.test(relPath);
+    }
+    return relPath === pattern || relPath.startsWith(`${pattern}/`);
+  });
+}
+function escapeRegex2(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var log10, DEFAULT_MAX_RESULTS, DEFAULT_TIMEOUT_MS3, MAX_FILE_SIZE_BYTES, BINARY_SNIFF_BYTES, LocalDocsProvider;
+var init_local_docs_provider = __esm({
+  "../engine/src/research/providers/local-docs-provider.ts"() {
+    "use strict";
+    init_logger2();
+    init_types2();
+    log10 = createLogger2("research:local-docs");
+    DEFAULT_MAX_RESULTS = 10;
+    DEFAULT_TIMEOUT_MS3 = 3e4;
+    MAX_FILE_SIZE_BYTES = 1024 * 1024;
+    BINARY_SNIFF_BYTES = 8 * 1024;
+    LocalDocsProvider = class {
+      constructor(options) {
+        this.options = options;
+        this.projectRoot = resolve15(options.projectRoot);
+        this.scanPaths = options.scanPaths ?? ["docs", "README.md", "AGENTS.md", ".fusion/memory"];
+      }
+      type = "local-docs";
+      projectRoot;
+      scanPaths;
+      isConfigured() {
+        return true;
+      }
+      async search(query, config = {}, signal) {
+        const timeoutMs = Number(config.timeoutMs ?? this.options.timeoutMs ?? DEFAULT_TIMEOUT_MS3);
+        const maxResults = Number(config.maxResults ?? this.options.maxResults ?? DEFAULT_MAX_RESULTS);
+        const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
+        const files = await this.withTimeout(this.collectCandidateFiles(signal), timeoutMs, signal);
+        const results = [];
+        for (const file of files) {
+          this.throwIfAborted(signal);
+          const content = await this.safeReadText(file, signal);
+          if (!content) continue;
+          const lower = content.toLowerCase();
+          let score = 0;
+          for (const term of terms) {
+            const matches = lower.match(new RegExp(escapeRegex2(term), "g"));
+            score += matches?.length ?? 0;
+          }
+          if (score <= 0) continue;
+          const relPath = relative7(this.projectRoot, file);
+          results.push({
+            score,
+            source: {
+              id: `local-docs-${relPath}`,
+              type: "local",
+              reference: relPath,
+              title: relPath,
+              excerpt: buildExcerpt(content, terms),
+              status: "completed",
+              metadata: { score, path: relPath }
+            }
+          });
+        }
+        return results.sort((a, b) => b.score - a.score).slice(0, maxResults).map((item) => item.source);
+      }
+      async fetchContent(filePath, config = {}, signal) {
+        const timeoutMs = Number(config.timeoutMs ?? this.options.timeoutMs ?? DEFAULT_TIMEOUT_MS3);
+        const resolvedPath = resolve15(this.projectRoot, filePath);
+        if (!resolvedPath.startsWith(this.projectRoot)) {
+          throw new ResearchProviderError({
+            providerType: "local-docs",
+            code: "provider-unavailable",
+            message: "Path traversal is not allowed"
+          });
+        }
+        const stat8 = await this.withTimeout(fs.stat(resolvedPath), timeoutMs, signal);
+        if (!stat8.isFile()) {
+          throw new ResearchProviderError({ providerType: "local-docs", code: "provider-unavailable", message: "Path is not a file" });
+        }
+        const content = await this.withTimeout(fs.readFile(resolvedPath), timeoutMs, signal);
+        const sniff = content.subarray(0, BINARY_SNIFF_BYTES);
+        if (sniff.includes(0)) {
+          throw new ResearchProviderError({ providerType: "local-docs", code: "provider-unavailable", message: "Binary file is not supported" });
+        }
+        const text = content.toString("utf-8");
+        return {
+          content: text.length > MAX_FILE_SIZE_BYTES ? text.slice(0, MAX_FILE_SIZE_BYTES) : text,
+          metadata: {
+            path: relative7(this.projectRoot, resolvedPath),
+            size: stat8.size,
+            modifiedAt: stat8.mtime.toISOString(),
+            extension: extname2(resolvedPath)
+          },
+          mimeType: "text/plain"
+        };
+      }
+      async collectCandidateFiles(signal) {
+        const ignorePatterns = await this.readGitignore();
+        const files = [];
+        for (const pathEntry of this.scanPaths) {
+          const target = resolve15(this.projectRoot, pathEntry);
+          if (!target.startsWith(this.projectRoot)) continue;
+          try {
+            const stat8 = await fs.stat(target);
+            if (stat8.isDirectory()) {
+              await this.walk(target, files, ignorePatterns, signal);
+            } else if (stat8.isFile()) {
+              files.push(target);
+            }
+          } catch {
+          }
+        }
+        const rootEntries = await fs.readdir(this.projectRoot, { withFileTypes: true });
+        for (const entry of rootEntries) {
+          if (entry.isFile() && entry.name.toLowerCase().endsWith(".md")) {
+            files.push(join35(this.projectRoot, entry.name));
+          }
+        }
+        return [...new Set(files)];
+      }
+      async walk(dir, out, ignorePatterns, signal) {
+        this.throwIfAborted(signal);
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+          this.throwIfAborted(signal);
+          const fullPath = join35(dir, entry.name);
+          const relPath = relative7(this.projectRoot, fullPath).replace(/\\/g, "/");
+          if (matchesGitignore(relPath, ignorePatterns)) continue;
+          if (entry.isDirectory()) {
+            await this.walk(fullPath, out, ignorePatterns, signal);
+          } else if (entry.isFile()) {
+            out.push(fullPath);
+          }
+        }
+      }
+      async safeReadText(filePath, signal) {
+        try {
+          const stat8 = await fs.stat(filePath);
+          if (stat8.size > MAX_FILE_SIZE_BYTES) return void 0;
+          const content = await fs.readFile(filePath);
+          if (content.subarray(0, BINARY_SNIFF_BYTES).includes(0)) return void 0;
+          this.throwIfAborted(signal);
+          return content.toString("utf-8");
+        } catch (error) {
+          log10.warn("failed to read local docs file", { filePath, error });
+          return void 0;
+        }
+      }
+      async readGitignore() {
+        try {
+          const content = await fs.readFile(join35(this.projectRoot, ".gitignore"), "utf-8");
+          return content.split(/\r?\n/).map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
+        } catch {
+          return [];
+        }
+      }
+      throwIfAborted(signal) {
+        if (signal?.aborted) {
+          throw new ResearchProviderError({ providerType: "local-docs", code: "abort", message: "Local docs scan aborted" });
+        }
+      }
+      async withTimeout(promise, timeoutMs, signal) {
+        const timeoutSignal = AbortSignal.timeout(timeoutMs);
+        const combined = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
+        return await Promise.race([
+          promise,
+          new Promise((_, reject) => {
+            combined.addEventListener(
+              "abort",
+              () => {
+                reject(
+                  new ResearchProviderError({
+                    providerType: "local-docs",
+                    code: signal?.aborted ? "abort" : "timeout",
+                    message: signal?.aborted ? "Local docs operation aborted" : `Local docs operation timed out after ${timeoutMs}ms`,
+                    retryable: !signal?.aborted
+                  })
+                );
+              },
+              { once: true }
+            );
+          })
+        ]);
+      }
+    };
+  }
+});
+
+// ../engine/src/research/providers/page-fetch-provider.ts
+function extractHtml(html) {
+  const title = html.match(/<title[^>]*>([\s\S]*?)<\/title>/i)?.[1]?.trim();
+  const description = html.match(/<meta[^>]*name=["']description["'][^>]*content=["']([^"']+)["'][^>]*>/i)?.[1]?.trim();
+  const stripped = html.replace(/<script[\s\S]*?<\/script>/gi, " ").replace(/<style[\s\S]*?<\/style>/gi, " ").replace(/<(nav|footer|header)[\s\S]*?<\/\1>/gi, " ");
+  const main = stripped.match(/<(main|article)[^>]*>([\s\S]*?)<\/\1>/i)?.[2] ?? stripped.match(/<body[^>]*>([\s\S]*?)<\/body>/i)?.[1] ?? stripped;
+  const text = main.replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+  return { title, description, content: text };
+}
+function truncate(value) {
+  return value.length > MAX_CONTENT_CHARS ? value.slice(0, MAX_CONTENT_CHARS) : value;
+}
+function looksLikeJson(value) {
+  const trimmed = value.trim();
+  return trimmed.startsWith("{") || trimmed.startsWith("[");
+}
+var log11, DEFAULT_TIMEOUT_MS4, DEFAULT_USER_AGENT, MAX_CONTENT_CHARS, PageFetchProvider;
+var init_page_fetch_provider = __esm({
+  "../engine/src/research/providers/page-fetch-provider.ts"() {
+    "use strict";
+    init_logger2();
+    init_types2();
+    log11 = createLogger2("research:page-fetch");
+    DEFAULT_TIMEOUT_MS4 = 3e4;
+    DEFAULT_USER_AGENT = "FusionResearchBot/1.0";
+    MAX_CONTENT_CHARS = 500 * 1024;
+    PageFetchProvider = class {
+      constructor(options = {}) {
+        this.options = options;
+      }
+      type = "page-fetch";
+      isConfigured() {
+        return true;
+      }
+      async search(_query, _config = {}, _signal) {
+        return [];
+      }
+      async fetchContent(url, config = {}, signal) {
+        const timeoutMs = Number(config.timeoutMs ?? this.options.timeoutMs ?? DEFAULT_TIMEOUT_MS4);
+        const timeoutSignal = AbortSignal.timeout(timeoutMs);
+        const requestSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
+        try {
+          const response = await fetch(url, {
+            method: "GET",
+            redirect: "follow",
+            headers: {
+              "User-Agent": config.metadata?.userAgent ?? this.options.userAgent ?? DEFAULT_USER_AGENT
+            },
+            signal: requestSignal
+          });
+          if (!response.ok) {
+            throw new ResearchProviderError({
+              providerType: "page-fetch",
+              code: response.status >= 500 ? "provider-unavailable" : "network-error",
+              message: `fetch failed with status ${response.status}`,
+              retryable: response.status >= 500
+            });
+          }
+          const contentType = response.headers.get("content-type") ?? "application/octet-stream";
+          const mimeType = contentType.split(";")[0].trim().toLowerCase();
+          const raw = await response.text();
+          const metadata = {
+            url,
+            contentType,
+            contentLength: raw.length
+          };
+          if (mimeType.includes("text/html")) {
+            const extracted = extractHtml(raw);
+            metadata.title = extracted.title;
+            metadata.description = extracted.description;
+            metadata.contentLength = extracted.content.length;
+            return { content: truncate(extracted.content), metadata, mimeType };
+          }
+          if (mimeType.includes("application/json") || looksLikeJson(raw)) {
+            const pretty = JSON.stringify(JSON.parse(raw), null, 2);
+            return { content: truncate(pretty), metadata, mimeType };
+          }
+          if (mimeType.includes("text/") || mimeType.includes("markdown")) {
+            return { content: truncate(raw), metadata, mimeType };
+          }
+          throw new ResearchProviderError({
+            providerType: "page-fetch",
+            code: "provider-unavailable",
+            message: `unsupported mime type: ${mimeType}`
+          });
+        } catch (error) {
+          if (error instanceof ResearchProviderError) throw error;
+          if (error instanceof DOMException && error.name === "AbortError") {
+            throw new ResearchProviderError({ providerType: "page-fetch", code: "abort", message: "Fetch aborted", cause: error });
+          }
+          if (error instanceof Error && error.name === "TimeoutError") {
+            throw new ResearchProviderError({ providerType: "page-fetch", code: "timeout", message: error.message, retryable: true, cause: error });
+          }
+          log11.warn("page fetch failed", { error });
+          throw new ResearchProviderError({
+            providerType: "page-fetch",
+            code: "network-error",
+            message: error instanceof Error ? error.message : "fetch failed",
+            retryable: true,
+            cause: error
+          });
+        }
+      }
+    };
+  }
+});
+
+// ../engine/src/research/providers/web-search-provider.ts
+async function sleep3(ms, signal) {
+  await new Promise((resolve19, reject) => {
+    const timer = setTimeout(resolve19, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(new ResearchProviderError({ providerType: "web-search", code: "abort", message: "Search aborted" }));
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+var log12, DEFAULT_MAX_RESULTS2, DEFAULT_TIMEOUT_MS5, RETRY_BASE_DELAY_MS2, RETRY_MAX_DELAY_MS, RETRY_MAX_ATTEMPTS, WebSearchProvider;
+var init_web_search_provider = __esm({
+  "../engine/src/research/providers/web-search-provider.ts"() {
+    "use strict";
+    init_logger2();
+    init_types2();
+    log12 = createLogger2("research:web-search");
+    DEFAULT_MAX_RESULTS2 = 10;
+    DEFAULT_TIMEOUT_MS5 = 3e4;
+    RETRY_BASE_DELAY_MS2 = 1e3;
+    RETRY_MAX_DELAY_MS = 1e4;
+    RETRY_MAX_ATTEMPTS = 3;
+    WebSearchProvider = class {
+      constructor(options = {}) {
+        this.options = options;
+      }
+      type = "web-search";
+      isConfigured() {
+        const backend = this.options.backend ?? "none";
+        if (backend === "none") return false;
+        if (backend === "searxng") return Boolean(this.options.searxngUrl);
+        if (backend === "brave") return Boolean(this.options.braveApiKey);
+        if (backend === "google") return Boolean(this.options.googleApiKey && this.options.googleCx);
+        if (backend === "tavily") return Boolean(this.options.tavilyApiKey);
+        return false;
+      }
+      async search(query, config = {}, signal) {
+        const backend = this.options.backend ?? "none";
+        if (!this.isConfigured()) return [];
+        const maxResults = Number(config.maxResults ?? this.options.maxResults ?? DEFAULT_MAX_RESULTS2);
+        const timeoutMs = Number(config.timeoutMs ?? this.options.timeoutMs ?? DEFAULT_TIMEOUT_MS5);
+        const timeoutSignal = AbortSignal.timeout(timeoutMs);
+        const requestSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
+        const results = await this.withHttpRetry(async () => {
+          if (backend === "searxng") return this.searchSearxng(query, maxResults, requestSignal);
+          if (backend === "brave") return this.searchBrave(query, maxResults, requestSignal);
+          if (backend === "google") return this.searchGoogle(query, maxResults, requestSignal);
+          if (backend === "tavily") return this.searchTavily(query, maxResults, requestSignal);
+          return [];
+        }, requestSignal, backend);
+        return results.slice(0, maxResults).map((result, index) => ({
+          id: `${backend}-${index}-${result.url}`,
+          type: "web",
+          reference: result.url,
+          title: result.title,
+          excerpt: result.snippet,
+          status: "completed",
+          metadata: {
+            backend,
+            rank: index + 1
+          }
+        }));
+      }
+      async fetchContent(_url, _options = {}, _signal) {
+        return { content: "", metadata: {} };
+      }
+      async searchSearxng(query, maxResults, signal) {
+        const base = this.options.searxngUrl?.replace(/\/$/, "") ?? "";
+        const url = new URL(`${base}/search`);
+        url.searchParams.set("q", query);
+        url.searchParams.set("format", "json");
+        const response = await this.requestJson(
+          url.toString(),
+          {
+            method: "GET",
+            signal
+          },
+          "searxng"
+        );
+        return (response.results ?? []).slice(0, maxResults).map((item) => ({
+          url: item.url,
+          title: item.title ?? item.url,
+          snippet: item.content ?? ""
+        }));
+      }
+      async searchBrave(query, maxResults, signal) {
+        const url = new URL("https://api.search.brave.com/res/v1/web/search");
+        url.searchParams.set("q", query);
+        url.searchParams.set("count", String(maxResults));
+        const response = await this.requestJson(
+          url.toString(),
+          {
+            method: "GET",
+            headers: {
+              "X-Subscription-Token": this.options.braveApiKey ?? "",
+              "User-Agent": this.options.userAgent ?? "FusionResearchBot/1.0"
+            },
+            signal
+          },
+          "brave"
+        );
+        return (response.web?.results ?? []).slice(0, maxResults).map((item) => ({
+          url: item.url,
+          title: item.title ?? item.url,
+          snippet: item.description ?? ""
+        }));
+      }
+      async searchGoogle(query, maxResults, signal) {
+        const url = new URL("https://www.googleapis.com/customsearch/v1");
+        url.searchParams.set("q", query);
+        url.searchParams.set("num", String(maxResults));
+        url.searchParams.set("key", this.options.googleApiKey ?? "");
+        url.searchParams.set("cx", this.options.googleCx ?? "");
+        const response = await this.requestJson(
+          url.toString(),
+          {
+            method: "GET",
+            signal
+          },
+          "google"
+        );
+        return (response.items ?? []).slice(0, maxResults).map((item) => ({
+          url: item.link,
+          title: item.title ?? item.link,
+          snippet: item.snippet ?? ""
+        }));
+      }
+      async searchTavily(query, maxResults, signal) {
+        const response = await this.requestJson(
+          "https://api.tavily.com/search",
+          {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              "User-Agent": this.options.userAgent ?? "FusionResearchBot/1.0"
+            },
+            body: JSON.stringify({
+              api_key: this.options.tavilyApiKey,
+              query,
+              max_results: maxResults
+            }),
+            signal
+          },
+          "tavily"
+        );
+        return (response.results ?? []).slice(0, maxResults).map((item) => ({
+          url: item.url,
+          title: item.title ?? item.url,
+          snippet: item.content ?? ""
+        }));
+      }
+      async withHttpRetry(operation, signal, backend) {
+        let attempt = 0;
+        let lastError;
+        while (attempt < RETRY_MAX_ATTEMPTS) {
+          if (signal.aborted) {
+            throw new ResearchProviderError({ providerType: "web-search", code: "abort", message: "Search aborted" });
+          }
+          try {
+            return await operation();
+          } catch (error) {
+            lastError = error;
+            const isRetryableHttp = error instanceof ResearchProviderError && (error.code === "rate-limited" || error.code === "network-error" || error.code === "provider-unavailable") && error.retryable;
+            attempt += 1;
+            if (!isRetryableHttp || attempt >= RETRY_MAX_ATTEMPTS) {
+              break;
+            }
+            const delay2 = Math.min(RETRY_BASE_DELAY_MS2 * 2 ** (attempt - 1), RETRY_MAX_DELAY_MS);
+            const jitter = delay2 * (Math.random() * 0.2 - 0.1);
+            const totalDelay = Math.max(0, delay2 + jitter);
+            log12.warn(`retrying ${backend} search`, { attempt, totalDelay });
+            await sleep3(totalDelay, signal);
+          }
+        }
+        throw lastError;
+      }
+      async requestJson(url, init, backend) {
+        try {
+          const response = await fetch(url, init);
+          if (!response.ok) {
+            const message = `${backend} request failed with status ${response.status}`;
+            if (response.status === 401 || response.status === 403) {
+              throw new ResearchProviderError({ providerType: "web-search", code: "auth-failed", message });
+            }
+            if (response.status === 429) {
+              throw new ResearchProviderError({
+                providerType: "web-search",
+                code: "rate-limited",
+                message,
+                retryable: true
+              });
+            }
+            if (response.status >= 500) {
+              throw new ResearchProviderError({
+                providerType: "web-search",
+                code: "provider-unavailable",
+                message,
+                retryable: true
+              });
+            }
+            throw new ResearchProviderError({ providerType: "web-search", code: "network-error", message });
+          }
+          return await response.json();
+        } catch (error) {
+          if (error instanceof ResearchProviderError) throw error;
+          if (error instanceof DOMException && error.name === "AbortError") {
+            throw new ResearchProviderError({ providerType: "web-search", code: "abort", message: "Search aborted", cause: error });
+          }
+          if (error instanceof Error && error.name === "TimeoutError") {
+            throw new ResearchProviderError({ providerType: "web-search", code: "timeout", message: error.message, retryable: true, cause: error });
+          }
+          throw new ResearchProviderError({
+            providerType: "web-search",
+            code: "network-error",
+            message: error instanceof Error ? error.message : "Unexpected network error",
+            retryable: true,
+            cause: error
+          });
+        }
+      }
+    };
+  }
+});
+
+// ../engine/src/research/provider-registry.ts
+var log13, ResearchProviderRegistry, DisabledProvider;
+var init_provider_registry = __esm({
+  "../engine/src/research/provider-registry.ts"() {
+    "use strict";
+    init_logger2();
+    init_github_provider();
+    init_llm_synthesis_provider();
+    init_local_docs_provider();
+    init_page_fetch_provider();
+    init_web_search_provider();
+    log13 = createLogger2("research:provider-registry");
+    ResearchProviderRegistry = class {
+      constructor(settings, projectRoot) {
+        this.settings = settings;
+        this.projectRoot = projectRoot;
+        this.instantiateProviders();
+      }
+      providers = /* @__PURE__ */ new Map();
+      getProvider(type) {
+        return this.providers.get(type);
+      }
+      getAvailableProviders() {
+        return [...this.providers.entries()].filter(([, provider]) => provider.isConfigured()).map(([type]) => type);
+      }
+      isProviderAvailable(type) {
+        const provider = this.providers.get(type);
+        return Boolean(provider?.isConfigured());
+      }
+      refreshSettings(settings) {
+        this.settings = settings;
+        this.instantiateProviders();
+      }
+      instantiateProviders() {
+        const backend = this.resolveSearchBackend();
+        const maxResults = Number(this.settings.researchMaxSearchResults ?? 10);
+        const fetchTimeoutMs = Number(this.settings.researchFetchTimeoutMs ?? 3e4);
+        const userAgent = this.settings.researchUserAgent ?? "FusionResearchBot/1.0";
+        this.providers = /* @__PURE__ */ new Map([
+          [
+            "web-search",
+            new WebSearchProvider({
+              backend,
+              searxngUrl: this.settings.researchSearxngUrl,
+              braveApiKey: this.settings.researchBraveApiKey,
+              googleApiKey: this.settings.researchGoogleSearchApiKey,
+              googleCx: this.settings.researchGoogleSearchCx,
+              tavilyApiKey: this.settings.researchTavilyApiKey,
+              maxResults,
+              timeoutMs: fetchTimeoutMs,
+              userAgent
+            })
+          ],
+          ["page-fetch", new PageFetchProvider({ timeoutMs: fetchTimeoutMs, userAgent })],
+          ["github", this.settings.researchGitHubEnabled ? new GitHubProvider() : new DisabledProvider("github")],
+          [
+            "local-docs",
+            this.settings.researchLocalDocsEnabled === false ? new DisabledProvider("local-docs") : new LocalDocsProvider({ projectRoot: this.projectRoot, timeoutMs: fetchTimeoutMs, maxResults })
+          ],
+          ["llm-synthesis", new LLMSynthesisProvider({ projectRoot: this.projectRoot })]
+        ]);
+        log13.log("providers refreshed", { available: this.getAvailableProviders(), backend });
+      }
+      resolveSearchBackend() {
+        const explicit = this.settings.researchWebSearchProvider;
+        if (explicit && explicit !== "none") return explicit;
+        if (this.settings.researchSearxngUrl) return "searxng";
+        if (this.settings.researchTavilyApiKey) return "tavily";
+        if (this.settings.researchBraveApiKey) return "brave";
+        if (this.settings.researchGoogleSearchApiKey && this.settings.researchGoogleSearchCx) return "google";
+        return "none";
+      }
+    };
+    DisabledProvider = class {
+      type;
+      constructor(type) {
+        this.type = type;
+      }
+      isConfigured() {
+        return false;
+      }
+      async search() {
+        return [];
+      }
+      async fetchContent() {
+        return { content: "", metadata: {} };
+      }
+    };
+  }
+});
+
+// ../engine/src/research/providers/index.ts
+var init_providers = __esm({
+  "../engine/src/research/providers/index.ts"() {
+    "use strict";
+    init_web_search_provider();
+    init_page_fetch_provider();
+    init_github_provider();
+    init_local_docs_provider();
+    init_llm_synthesis_provider();
+  }
+});
+
 // ../engine/src/pr-monitor-gh.ts
 function createDefaultPrMonitorGhClient() {
   return {
@@ -71409,13 +73117,14 @@ async function sendNtfyNotification({
     schedulerLog.log(`Failed to send ntfy notification: ${err}`);
   }
 }
-var DEFAULT_NTFY_BASE_URL, DEFAULT_NTFY_EVENTS, NtfyNotifier;
+var DEFAULT_NTFY_BASE_URL, GRIDLOCK_NOTIFICATION_COOLDOWN_MS, DEFAULT_NTFY_EVENTS, NtfyNotifier;
 var init_notifier = __esm({
   "../engine/src/notifier.ts"() {
     "use strict";
     init_logger2();
     init_notification();
     DEFAULT_NTFY_BASE_URL = "https://ntfy.sh";
+    GRIDLOCK_NOTIFICATION_COOLDOWN_MS = 15 * 60 * 1e3;
     DEFAULT_NTFY_EVENTS = [
       "in-review",
       "merged",
@@ -71446,8 +73155,8 @@ var init_notifier = __esm({
       ntfyBaseUrl;
       defaultNtfyBaseUrl;
       projectId;
-      notifiedEvents = /* @__PURE__ */ new Set();
       abortController = null;
+      lastGridlockNotificationAt = null;
       async start() {
         this.abortController = new AbortController();
         const settings = await this.store.getSettings();
@@ -71480,8 +73189,16 @@ var init_notifier = __esm({
         this.ntfyBaseUrl = resolveNtfyBaseUrl(settings.ntfyBaseUrl, this.defaultNtfyBaseUrl);
       }
       notifyGridlock(event) {
+        if (event === null) {
+          this.lastGridlockNotificationAt = null;
+          return;
+        }
         if (!this.config.enabled || !this.config.topic || !this.isEventEnabled("gridlock")) return;
-        const blockedTasks = event.blockedTaskIds.sort();
+        const now = Date.now();
+        if (this.lastGridlockNotificationAt !== null && now - this.lastGridlockNotificationAt < GRIDLOCK_NOTIFICATION_COOLDOWN_MS) {
+          return;
+        }
+        const blockedTasks = [...event.blockedTaskIds].sort();
         const reasonSummary = Object.values(event.reasons).reduce((acc, reason) => {
           acc[reason] = (acc[reason] ?? 0) + 1;
           return acc;
@@ -71493,31 +73210,21 @@ var init_notifier = __esm({
           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
-          })
-        );
+        this.lastGridlockNotificationAt = now;
+        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
+        }).catch(() => {
+        });
       }
       isEventEnabled(event) {
         return isNtfyEventEnabled(this.config.events, event);
       }
-      maybeNotifyByKey(key, notifyFn) {
-        if (this.notifiedEvents.has(key)) {
-          return;
-        }
-        this.notifiedEvents.add(key);
-        notifyFn().catch(() => {
-        });
-      }
       getConfig() {
         return { ...this.config, events: [...this.config.events] };
       }
@@ -71574,7 +73281,7 @@ function truncateOutput(stdout, stderr) {
   }
   return combined;
 }
-var execAsync6, log6, DEFAULT_TIMEOUT_MS, MAX_BUFFER, MAX_OUTPUT_LENGTH, DEFAULT_POLL_INTERVAL_MS, MIN_POLL_INTERVAL_MS, CronRunner, AI_AUTOMATION_SYSTEM_PROMPT;
+var execAsync6, log14, DEFAULT_TIMEOUT_MS6, MAX_BUFFER, MAX_OUTPUT_LENGTH, DEFAULT_POLL_INTERVAL_MS, MIN_POLL_INTERVAL_MS, CronRunner, AI_AUTOMATION_SYSTEM_PROMPT;
 var init_cron_runner = __esm({
   "../engine/src/cron-runner.ts"() {
     "use strict";
@@ -71583,8 +73290,8 @@ var init_cron_runner = __esm({
     init_shell_utils();
     init_pi();
     execAsync6 = promisify7(exec6);
-    log6 = createLogger2("cron-runner");
-    DEFAULT_TIMEOUT_MS = 5 * 60 * 1e3;
+    log14 = createLogger2("cron-runner");
+    DEFAULT_TIMEOUT_MS6 = 5 * 60 * 1e3;
     MAX_BUFFER = 1024 * 1024;
     MAX_OUTPUT_LENGTH = 10 * 1024;
     DEFAULT_POLL_INTERVAL_MS = 60 * 1e3;
@@ -71616,7 +73323,7 @@ var init_cron_runner = __esm({
       start() {
         if (this.running) return;
         this.running = true;
-        log6.log(`Started (poll every ${this.pollIntervalMs / 1e3}s, scope: ${this.scope})`);
+        log14.log(`Started (poll every ${this.pollIntervalMs / 1e3}s, scope: ${this.scope})`);
         void this.tick();
         this.pollInterval = setInterval(() => {
           void this.tick();
@@ -71630,7 +73337,7 @@ var init_cron_runner = __esm({
           clearInterval(this.pollInterval);
           this.pollInterval = null;
         }
-        log6.log("Stopped");
+        log14.log("Stopped");
       }
       /**
        * Single poll cycle: find due schedules and execute them.
@@ -71654,29 +73361,29 @@ var init_cron_runner = __esm({
           const executedIds = /* @__PURE__ */ new Set();
           for (const schedule of dueSchedules) {
             if (this.inFlight.has(schedule.id)) {
-              log6.warn(`Skipping ${schedule.name} (${schedule.id}) \u2014 still running from previous tick`);
+              log14.warn(`Skipping ${schedule.name} (${schedule.id}) \u2014 still running from previous tick`);
               continue;
             }
             if (executedIds.has(schedule.id)) {
-              log6.log(`Skipping ${schedule.name} (${schedule.id}) \u2014 already executed from another scope this tick`);
+              log14.log(`Skipping ${schedule.name} (${schedule.id}) \u2014 already executed from another scope this tick`);
               continue;
             }
             executedIds.add(schedule.id);
             const scheduleScope = schedule.scope ?? "project";
             if (scheduleScope !== this.scope && this.scope !== "all") {
-              log6.log(`Skipping ${schedule.name} (${schedule.id}) \u2014 belongs to ${scheduleScope} scope, not polling`);
+              log14.log(`Skipping ${schedule.name} (${schedule.id}) \u2014 belongs to ${scheduleScope} scope, not polling`);
               continue;
             }
-            log6.log(`Executing ${schedule.name} (${schedule.id}) [scope: ${scheduleScope}]`);
+            log14.log(`Executing ${schedule.name} (${schedule.id}) [scope: ${scheduleScope}]`);
             const currentSettings = await this.store.getSettings();
             if (currentSettings.globalPause || currentSettings.enginePaused) {
-              log6.log("Pause detected mid-tick \u2014 stopping schedule execution");
+              log14.log("Pause detected mid-tick \u2014 stopping schedule execution");
               break;
             }
             await this.executeSchedule(schedule);
           }
         } catch (err) {
-          log6.error(`Tick error: ${err.message}`);
+          log14.error(`Tick error: ${err.message}`);
         } finally {
           this.ticking = false;
         }
@@ -71706,13 +73413,13 @@ var init_cron_runner = __esm({
         try {
           await this.automationStore.recordRun(schedule.id, result);
         } catch (recordErr) {
-          log6.error(`Failed to record run for ${schedule.id}: ${recordErr.message}`);
+          log14.error(`Failed to record run for ${schedule.id}: ${recordErr.message}`);
         }
         if (this.onScheduleRunProcessed) {
           try {
             await this.onScheduleRunProcessed(schedule, result);
           } catch (callbackErr) {
-            log6.error(
+            log14.error(
               `Post-run callback failed for ${schedule.name} (${schedule.id}): ${callbackErr.message}`
             );
           }
@@ -71723,16 +73430,16 @@ var init_cron_runner = __esm({
        * Execute a legacy single-command schedule.
        */
       async executeLegacyCommand(schedule, startedAt) {
-        log6.log(`Executing ${schedule.name} (${schedule.id}): ${schedule.command}`);
+        log14.log(`Executing ${schedule.name} (${schedule.id}): ${schedule.command}`);
         try {
-          const timeoutMs = schedule.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+          const timeoutMs = schedule.timeoutMs ?? DEFAULT_TIMEOUT_MS6;
           const { stdout, stderr } = await execAsync6(schedule.command, {
             timeout: timeoutMs,
             maxBuffer: MAX_BUFFER,
             shell: defaultShell
           });
           const output = truncateOutput(stdout, stderr);
-          log6.log(`\u2713 ${schedule.name} completed (${output.length} bytes output)`);
+          log14.log(`\u2713 ${schedule.name} completed (${output.length} bytes output)`);
           return {
             success: true,
             output,
@@ -71743,8 +73450,8 @@ var init_cron_runner = __esm({
           const stdout = err.stdout ?? "";
           const stderr = err.stderr ?? "";
           const output = truncateOutput(stdout, stderr);
-          const errorMessage = err.killed ? `Command timed out after ${(schedule.timeoutMs ?? DEFAULT_TIMEOUT_MS) / 1e3}s` : err.message ?? String(err);
-          log6.warn(`\u2717 ${schedule.name} failed: ${errorMessage}`);
+          const errorMessage = err.killed ? `Command timed out after ${(schedule.timeoutMs ?? DEFAULT_TIMEOUT_MS6) / 1e3}s` : err.message ?? String(err);
+          log14.warn(`\u2717 ${schedule.name} failed: ${errorMessage}`);
           return {
             success: false,
             output,
@@ -71760,25 +73467,25 @@ var init_cron_runner = __esm({
        */
       async executeSteps(schedule, startedAt) {
         const steps = schedule.steps;
-        log6.log(`Executing ${schedule.name} (${schedule.id}): ${steps.length} steps`);
+        log14.log(`Executing ${schedule.name} (${schedule.id}): ${steps.length} steps`);
         const stepResults = [];
         let overallSuccess = true;
         let stoppedEarly = false;
         for (let i = 0; i < steps.length; i++) {
           const step = steps[i];
-          log6.log(`  Step ${i + 1}/${steps.length}: ${step.name} (${step.type})`);
+          log14.log(`  Step ${i + 1}/${steps.length}: ${step.name} (${step.type})`);
           const stepResult = await this.executeStep(schedule, step, i);
           stepResults.push(stepResult);
           if (!stepResult.success) {
             overallSuccess = false;
             if (!step.continueOnFailure) {
-              log6.warn(`  Step "${step.name}" failed \u2014 stopping execution`);
+              log14.warn(`  Step "${step.name}" failed \u2014 stopping execution`);
               stoppedEarly = true;
               break;
             }
-            log6.warn(`  Step "${step.name}" failed \u2014 continuing (continueOnFailure=true)`);
+            log14.warn(`  Step "${step.name}" failed \u2014 continuing (continueOnFailure=true)`);
           } else {
-            log6.log(`  \u2713 Step "${step.name}" completed`);
+            log14.log(`  \u2713 Step "${step.name}" completed`);
           }
         }
         const outputParts = [];
@@ -71791,7 +73498,7 @@ var init_cron_runner = __esm({
         const failedSteps = stepResults.filter((sr) => !sr.success);
         const error = failedSteps.length > 0 ? `${failedSteps.length} step(s) failed: ${failedSteps.map((s) => s.stepName).join(", ")}${stoppedEarly ? " (execution stopped)" : ""}` : void 0;
         const status = overallSuccess ? "\u2713" : "\u2717";
-        log6.log(`${status} ${schedule.name}: ${stepResults.length}/${steps.length} steps executed, ${failedSteps.length} failed`);
+        log14.log(`${status} ${schedule.name}: ${stepResults.length}/${steps.length} steps executed, ${failedSteps.length} failed`);
         return {
           success: overallSuccess,
           output,
@@ -71806,7 +73513,7 @@ var init_cron_runner = __esm({
        */
       async executeStep(schedule, step, stepIndex) {
         const stepStartedAt = (/* @__PURE__ */ new Date()).toISOString();
-        const timeoutMs = step.timeoutMs ?? schedule.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        const timeoutMs = step.timeoutMs ?? schedule.timeoutMs ?? DEFAULT_TIMEOUT_MS6;
         if (step.type === "command") {
           return this.executeCommandStep(step, stepIndex, timeoutMs, stepStartedAt);
         } else if (step.type === "ai-prompt") {
@@ -71908,8 +73615,8 @@ var init_cron_runner = __esm({
         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" : ""}`);
+        log14.log(`    AI prompt step "${step.name}" using model: ${model}`);
+        log14.log(`    Prompt: ${step.prompt.slice(0, 100)}${step.prompt.length > 100 ? "\u2026" : ""}`);
         try {
           const resultPromise = this.aiPromptExecutor(step.prompt, modelProvider, modelId);
           const timeoutPromise = new Promise((_resolve, reject) => {
@@ -71917,7 +73624,7 @@ var init_cron_runner = __esm({
           });
           const response = await Promise.race([resultPromise, timeoutPromise]);
           const output = response.length > MAX_OUTPUT_LENGTH ? response.slice(0, MAX_OUTPUT_LENGTH) + "\n[output truncated]" : response;
-          log6.log(`    \u2713 AI prompt step "${step.name}" completed (${response.length} chars)`);
+          log14.log(`    \u2713 AI prompt step "${step.name}" completed (${response.length} chars)`);
           return {
             stepId: step.id,
             stepName: step.name,
@@ -71929,7 +73636,7 @@ var init_cron_runner = __esm({
           };
         } catch (err) {
           const errorMessage = err.message ?? String(err);
-          log6.warn(`    \u2717 AI prompt step "${step.name}" failed: ${errorMessage}`);
+          log14.warn(`    \u2717 AI prompt step "${step.name}" failed: ${errorMessage}`);
           return {
             stepId: step.id,
             stepName: step.name,
@@ -71973,7 +73680,7 @@ var init_cron_runner = __esm({
         try {
           const task = await this.store.createTask(taskInput);
           const output = `Created task ${task.id}: ${task.title || task.description.slice(0, 80)}`;
-          log6.log(`    \u2713 Create-task step "${step.name}" created task ${task.id}`);
+          log14.log(`    \u2713 Create-task step "${step.name}" created task ${task.id}`);
           return {
             stepId: step.id,
             stepName: step.name,
@@ -71985,7 +73692,7 @@ var init_cron_runner = __esm({
           };
         } catch (err) {
           const errorMessage = err.message ?? String(err);
-          log6.warn(`    \u2717 Create-task step "${step.name}" failed: ${errorMessage}`);
+          log14.warn(`    \u2717 Create-task step "${step.name}" failed: ${errorMessage}`);
           return {
             stepId: step.id,
             stepName: step.name,
@@ -72027,16 +73734,16 @@ function truncateOutput2(stdout, stderr) {
   }
   return output;
 }
-var import_cron_parser4, log7, execAsync7, DEFAULT_TIMEOUT_MS2, MAX_BUFFER2, MAX_OUTPUT_LENGTH2, MAX_CATCH_UP_INTERVALS, RoutineRunner;
+var import_cron_parser4, log15, execAsync7, DEFAULT_TIMEOUT_MS7, MAX_BUFFER2, MAX_OUTPUT_LENGTH2, MAX_CATCH_UP_INTERVALS, RoutineRunner;
 var init_routine_runner = __esm({
   "../engine/src/routine-runner.ts"() {
     "use strict";
     import_cron_parser4 = __toESM(require_dist2(), 1);
     init_logger2();
     init_shell_utils();
-    log7 = createLogger2("routine-runner");
+    log15 = createLogger2("routine-runner");
     execAsync7 = promisify8(exec7);
-    DEFAULT_TIMEOUT_MS2 = 5 * 60 * 1e3;
+    DEFAULT_TIMEOUT_MS7 = 5 * 60 * 1e3;
     MAX_BUFFER2 = 1024 * 1024;
     MAX_OUTPUT_LENGTH2 = 10 * 1024;
     MAX_CATCH_UP_INTERVALS = 10;
@@ -72071,7 +73778,7 @@ var init_routine_runner = __esm({
         }
         const concurrency = routine.executionPolicy ?? "queue";
         if (concurrency === "reject" && this.inFlightExecutions.has(routineId)) {
-          log7.log(`Routine ${routineId} rejected \u2014 already running`);
+          log15.log(`Routine ${routineId} rejected \u2014 already running`);
           return {
             routineId,
             success: false,
@@ -72082,7 +73789,7 @@ var init_routine_runner = __esm({
           };
         }
         if (concurrency === "queue" && this.inFlightExecutions.has(routineId)) {
-          log7.log(`Routine ${routineId} queued \u2014 waiting for existing execution`);
+          log15.log(`Routine ${routineId} queued \u2014 waiting for existing execution`);
           const existingResult = await this.inFlightExecutions.get(routineId);
           if (existingResult) {
             await existingResult;
@@ -72130,7 +73837,7 @@ var init_routine_runner = __esm({
           };
         } catch (err) {
           const errorMessage = err instanceof Error ? err.message : String(err);
-          log7.error(`Routine ${routineId} execution failed: ${errorMessage}`);
+          log15.error(`Routine ${routineId} execution failed: ${errorMessage}`);
           try {
             await this.options.routineStore.completeRoutineExecution(routineId, {
               completedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -72138,7 +73845,7 @@ var init_routine_runner = __esm({
               error: errorMessage
             });
           } catch (persistError) {
-            log7.error(`[${routineId}] Failed to persist error state: ${persistError}`);
+            log15.error(`[${routineId}] Failed to persist error state: ${persistError}`);
           }
           return {
             routineId,
@@ -72191,7 +73898,7 @@ var init_routine_runner = __esm({
       async executeCommand(command, timeoutMs, startedAt) {
         try {
           const { stdout, stderr } = await execAsync7(command, {
-            timeout: timeoutMs ?? DEFAULT_TIMEOUT_MS2,
+            timeout: timeoutMs ?? DEFAULT_TIMEOUT_MS7,
             maxBuffer: MAX_BUFFER2,
             shell: defaultShell
           });
@@ -72205,7 +73912,7 @@ var init_routine_runner = __esm({
           const errObj = err;
           const stdout = typeof errObj.stdout === "string" ? errObj.stdout : "";
           const stderr = typeof errObj.stderr === "string" ? errObj.stderr : "";
-          const error = errObj.killed === true ? `Command timed out after ${(timeoutMs ?? DEFAULT_TIMEOUT_MS2) / 1e3}s` : (err instanceof Error ? err.message : null) ?? String(err);
+          const error = errObj.killed === true ? `Command timed out after ${(timeoutMs ?? DEFAULT_TIMEOUT_MS7) / 1e3}s` : (err instanceof Error ? err.message : null) ?? String(err);
           return {
             success: false,
             output: truncateOutput2(stdout, stderr),
@@ -72250,7 +73957,7 @@ var init_routine_runner = __esm({
       }
       async executeStep(routine, step, stepIndex) {
         const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-        const timeoutMs = step.timeoutMs ?? routine.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
+        const timeoutMs = step.timeoutMs ?? routine.timeoutMs ?? DEFAULT_TIMEOUT_MS7;
         if (step.type === "command") {
           const result = await this.executeCommand(step.command ?? "", timeoutMs, startedAt);
           return {
@@ -72352,7 +74059,7 @@ var init_routine_runner = __esm({
           if (missedIntervals.length === 0) {
             return;
           }
-          log7.log(`[${routine.id}] Running ${missedIntervals.length} catch-up executions`);
+          log15.log(`[${routine.id}] Running ${missedIntervals.length} catch-up executions`);
           for (const missedInterval of missedIntervals) {
             try {
               await this.executeRoutine(routine.id, "cron", {
@@ -72360,11 +74067,11 @@ var init_routine_runner = __esm({
                 missedInterval: missedInterval.toISOString()
               });
             } catch (err) {
-              log7.error(`[${routine.id}] Catch-up execution failed: ${err}`);
+              log15.error(`[${routine.id}] Catch-up execution failed: ${err}`);
             }
           }
         } catch (err) {
-          log7.error(`[${routine.id}] Error calculating catch-up intervals: ${err}`);
+          log15.error(`[${routine.id}] Error calculating catch-up intervals: ${err}`);
         }
       }
       /**
@@ -72891,7 +74598,7 @@ var init_stuck_task_detector = __esm({
 import { exec as exec8 } from "node:child_process";
 import { promisify as promisify9 } from "node:util";
 import { existsSync as existsSync28, readdirSync as readdirSync5, rmSync as rmSync3, statSync as statSync5 } from "node:fs";
-import { isAbsolute as isAbsolute12, join as join35, relative as relative7, resolve as resolve15 } from "node:path";
+import { isAbsolute as isAbsolute12, join as join36, relative as relative8, resolve as resolve16 } from "node:path";
 function shellQuote(value) {
   return `'${value.replace(/'/g, "'\\''")}'`;
 }
@@ -72925,19 +74632,25 @@ function isNoTaskDoneFailure(task) {
 function hasStepProgress(task) {
   return task.steps.some((step) => step.status !== "pending");
 }
-var log8, execAsync8, APPROVED_TRIAGE_RECOVERY_GRACE_MS, ORPHANED_EXECUTION_RECOVERY_GRACE_MS, ACTIVE_MERGE_STATUSES, NON_TERMINAL_STEP_STATUSES2, ORPHANED_WITH_WORKTREE_GRACE_MS, MAX_TASK_DONE_RETRIES, SelfHealingManager;
+var log16, execAsync8, APPROVED_TRIAGE_RECOVERY_GRACE_MS, ORPHANED_EXECUTION_RECOVERY_GRACE_MS, ACTIVE_MERGE_STATUSES, NON_TERMINAL_STEP_STATUSES2, GHOST_REVIEW_PRESERVED_STATUSES, ORPHANED_WITH_WORKTREE_GRACE_MS, MAX_TASK_DONE_RETRIES, SelfHealingManager;
 var init_self_healing = __esm({
   "../engine/src/self-healing.ts"() {
     "use strict";
     init_src();
     init_logger2();
     init_worktree_pool();
-    log8 = createLogger2("self-healing");
+    log16 = createLogger2("self-healing");
     execAsync8 = promisify9(exec8);
     APPROVED_TRIAGE_RECOVERY_GRACE_MS = 6e4;
     ORPHANED_EXECUTION_RECOVERY_GRACE_MS = 6e4;
     ACTIVE_MERGE_STATUSES = /* @__PURE__ */ new Set(["merging", "merging-pr"]);
     NON_TERMINAL_STEP_STATUSES2 = /* @__PURE__ */ new Set(["pending", "in-progress"]);
+    GHOST_REVIEW_PRESERVED_STATUSES = /* @__PURE__ */ new Set([
+      "awaiting-user-review",
+      "awaiting-approval",
+      "merging",
+      "merging-pr"
+    ]);
     ORPHANED_WITH_WORKTREE_GRACE_MS = 3e5;
     MAX_TASK_DONE_RETRIES = 3;
     SelfHealingManager = class _SelfHealingManager {
@@ -72962,7 +74675,7 @@ var init_self_healing = __esm({
         };
         this.store.on("settings:updated", this.settingsListener);
         this.startMaintenance();
-        log8.log("Started");
+        log16.log("Started");
       }
       /**
        * Run only the recovery subset needed at runtime startup, after the executor
@@ -72987,10 +74700,10 @@ var init_self_healing = __esm({
         for (const step of steps) {
           try {
             await step.fn();
-            log8.log(`Startup recovery step "${step.name}" completed`);
+            log16.log(`Startup recovery step "${step.name}" completed`);
           } catch (stepErr) {
             const stepErrMessage = stepErr instanceof Error ? stepErr.message : String(stepErr);
-            log8.error(`Startup recovery step "${step.name}" failed: ${stepErrMessage} \u2014 continuing with remaining steps`);
+            log16.error(`Startup recovery step "${step.name}" failed: ${stepErrMessage} \u2014 continuing with remaining steps`);
           }
         }
       }
@@ -73000,7 +74713,7 @@ var init_self_healing = __esm({
             this.store.removeListener("settings:updated", this.settingsListener);
           } catch (err) {
             const errorMessage = err instanceof Error ? err.message : String(err);
-            log8.warn(`Failed to remove settings:updated listener during stop(): ${errorMessage}`);
+            log16.warn(`Failed to remove settings:updated listener during stop(): ${errorMessage}`);
           }
           this.settingsListener = null;
         }
@@ -73009,22 +74722,22 @@ var init_self_healing = __esm({
           clearInterval(this.maintenanceInterval);
           this.maintenanceInterval = null;
         }
-        log8.log("Stopped");
+        log16.log("Stopped");
       }
       // ── Auto-unpause ───────────────────────────────────────────────────
       onSettingsUpdated(settings, previous) {
         if (!previous.globalPause && settings.globalPause) {
           if (!settings.autoUnpauseEnabled) {
-            log8.log("Global pause activated \u2014 auto-unpause disabled, requires manual intervention");
+            log16.log("Global pause activated \u2014 auto-unpause disabled, requires manual intervention");
             return;
           }
           if (settings.globalPauseReason === "manual") {
-            log8.log("Global pause activated manually \u2014 auto-unpause skipped, requires manual intervention");
+            log16.log("Global pause activated manually \u2014 auto-unpause skipped, requires manual intervention");
             return;
           }
           if (this.lastUnpauseAt && Date.now() - this.lastUnpauseAt < 6e4) {
             this.unpauseAttempt++;
-            log8.warn(`Global pause re-triggered within 60s \u2014 escalating to attempt ${this.unpauseAttempt}`);
+            log16.warn(`Global pause re-triggered within 60s \u2014 escalating to attempt ${this.unpauseAttempt}`);
           }
           this.lastPauseTriggeredAt = Date.now();
           const baseDelay = settings.autoUnpauseBaseDelayMs ?? 3e5;
@@ -73044,7 +74757,7 @@ var init_self_healing = __esm({
         const delaySec = Math.round(delayMs / 1e3);
         const delayMin = Math.round(delaySec / 60);
         const display = delayMin >= 1 ? `${delayMin}m` : `${delaySec}s`;
-        log8.warn(`Auto-unpause scheduled in ${display} (attempt ${this.unpauseAttempt + 1})`);
+        log16.warn(`Auto-unpause scheduled in ${display} (attempt ${this.unpauseAttempt + 1})`);
         this.unpauseTimer = setTimeout(() => {
           this.unpauseTimer = null;
           void this.attemptUnpause();
@@ -73054,16 +74767,16 @@ var init_self_healing = __esm({
         try {
           const settings = await this.store.getSettings();
           if (!settings.globalPause) {
-            log8.log("Auto-unpause: already unpaused \u2014 no action needed");
+            log16.log("Auto-unpause: already unpaused \u2014 no action needed");
             this.unpauseAttempt = 0;
             return;
           }
-          log8.warn("Auto-unpause: clearing globalPause");
+          log16.warn("Auto-unpause: clearing globalPause");
           this.lastUnpauseAt = Date.now();
           await this.store.updateSettings({ globalPause: false, globalPauseReason: void 0 });
         } catch (err) {
           const errorMessage = err instanceof Error ? err.message : String(err);
-          log8.error(`Auto-unpause failed: ${errorMessage}`);
+          log16.error(`Auto-unpause failed: ${errorMessage}`);
         }
       }
       cancelUnpauseTimer() {
@@ -73087,7 +74800,7 @@ var init_self_healing = __esm({
           const task = await this.store.getTask(taskId);
           const newCount = (task.stuckKillCount ?? 0) + 1;
           if (newCount > maxKills) {
-            log8.warn(`${taskId} exceeded stuck kill budget (${newCount}/${maxKills}) \u2014 marking failed`);
+            log16.warn(`${taskId} exceeded stuck kill budget (${newCount}/${maxKills}) \u2014 marking failed`);
             await this.store.updateTask(taskId, {
               stuckKillCount: newCount,
               status: "failed",
@@ -73097,7 +74810,7 @@ var init_self_healing = __esm({
               await this.store.moveTask(taskId, "in-review");
             } catch (moveErr) {
               const moveErrMessage = moveErr instanceof Error ? moveErr.message : String(moveErr);
-              log8.warn(`${taskId} moveTask("in-review") failed (${moveErrMessage}) \u2014 task already marked failed, not re-queuing`);
+              log16.warn(`${taskId} moveTask("in-review") failed (${moveErrMessage}) \u2014 task already marked failed, not re-queuing`);
             }
             await this.store.logEntry(
               taskId,
@@ -73105,7 +74818,7 @@ var init_self_healing = __esm({
             );
             return false;
           }
-          log8.log(`${taskId} stuck kill ${newCount}/${maxKills} \u2014 will re-queue`);
+          log16.log(`${taskId} stuck kill ${newCount}/${maxKills} \u2014 will re-queue`);
           await this.store.updateTask(taskId, { stuckKillCount: newCount });
           await this.store.logEntry(
             taskId,
@@ -73114,7 +74827,7 @@ var init_self_healing = __esm({
           return true;
         } catch (err) {
           const errorMessage = err instanceof Error ? err.message : String(err);
-          log8.error(`checkStuckBudget failed for ${taskId}: ${errorMessage}`);
+          log16.error(`checkStuckBudget failed for ${taskId}: ${errorMessage}`);
           return true;
         }
       }
@@ -73143,7 +74856,7 @@ var init_self_healing = __esm({
           );
           const branchHead = branchHeadOut.trim();
           if (mergeBase === branchHead) {
-            log8.warn(
+            log16.warn(
               `${task.id} branch has no unique commits \u2014 resetting ${completedSteps.length} step(s) to pending`
             );
             for (let i = 0; i < task.steps.length; i++) {
@@ -73158,7 +74871,7 @@ var init_self_healing = __esm({
           }
         } catch (err) {
           const errorMessage = err instanceof Error ? err.message : String(err);
-          log8.warn(
+          log16.warn(
             `Failed to reset steps for ${task.id} after branch/worktree loss (${branchName}): ${errorMessage} \u2014 non-fatal`
           );
         }
@@ -73168,10 +74881,10 @@ var init_self_healing = __esm({
         const settings = await this.store.getSettings();
         const intervalMs = settings.maintenanceIntervalMs ?? 9e5;
         if (intervalMs <= 0) {
-          log8.log("Periodic maintenance disabled (maintenanceIntervalMs <= 0)");
+          log16.log("Periodic maintenance disabled (maintenanceIntervalMs <= 0)");
           return;
         }
-        log8.log(`Periodic maintenance every ${Math.round(intervalMs / 6e4)}m`);
+        log16.log(`Periodic maintenance every ${Math.round(intervalMs / 6e4)}m`);
         this.maintenanceInterval = setInterval(() => {
           void this.runMaintenance();
         }, intervalMs);
@@ -73234,7 +74947,7 @@ var init_self_healing = __esm({
             out = r.stdout;
           } catch (err) {
             const errorMessage = err instanceof Error ? err.message : String(err);
-            log8.warn(
+            log16.warn(
               `Failed to read git log for landed commit lookup (${task.id}): ${errorMessage} \u2014 retrying with HEAD range`
             );
             if (!task.baseCommitSha) return "";
@@ -73265,7 +74978,7 @@ var init_self_healing = __esm({
           Object.assign(commit, parseShortstat(stats.stdout));
         } catch (err) {
           const errorMessage = err instanceof Error ? err.message : String(err);
-          log8.warn(
+          log16.warn(
             `Failed to read shortstat for landed commit ${sha} (${task.id}): ${errorMessage} \u2014 continuing without stats`
           );
         }
@@ -73280,7 +74993,7 @@ var init_self_healing = __esm({
             });
           } catch (err) {
             const errorMessage = err instanceof Error ? err.message : String(err);
-            log8.warn(
+            log16.warn(
               `Failed to remove interrupted-merge worktree ${task.worktree} for ${task.id}: ${errorMessage} \u2014 non-fatal, cleanup can retry later`
             );
           }
@@ -73293,19 +75006,19 @@ var init_self_healing = __esm({
           });
         } catch (err) {
           const errorMessage = err instanceof Error ? err.message : String(err);
-          log8.warn(
+          log16.warn(
             `Failed to delete interrupted-merge branch ${branch} for ${task.id}: ${errorMessage} \u2014 non-fatal`
           );
         }
       }
       async runMaintenance() {
         if (this.maintenanceRunning) {
-          log8.log("Maintenance cycle skipped \u2014 previous cycle still running");
+          log16.log("Maintenance cycle skipped \u2014 previous cycle still running");
           return;
         }
         this.maintenanceRunning = true;
         const startMs = Date.now();
-        log8.log("Maintenance cycle starting");
+        log16.log("Maintenance cycle starting");
         try {
           const batch1Fns = [
             { name: "prune-worktrees", fn: () => this.pruneWorktrees() },
@@ -73317,9 +75030,9 @@ var init_self_healing = __esm({
           for (const fn of batch1Fns) {
             try {
               await fn.fn();
-              log8.log(`Maintenance batch 1 step "${fn.name}" succeeded`);
+              log16.log(`Maintenance batch 1 step "${fn.name}" succeeded`);
             } catch (stepErr) {
-              log8.error(`Maintenance batch 1 step "${fn.name}" failed: ${stepErr instanceof Error ? stepErr.message : String(stepErr)}`);
+              log16.error(`Maintenance batch 1 step "${fn.name}" failed: ${stepErr instanceof Error ? stepErr.message : String(stepErr)}`);
             }
           }
           const batch2Fns = [
@@ -73334,14 +75047,15 @@ var init_self_healing = __esm({
             { name: "recover-partial-progress-no-task-done", fn: () => this.recoverPartialProgressNoTaskDoneFailures() },
             { name: "recover-orphaned-executions", fn: () => this.recoverOrphanedExecutions() },
             { name: "recover-approved-triage", fn: () => this.recoverApprovedTriageTasks() },
-            { name: "recover-orphaned-planning", fn: () => this.recoverOrphanedPlanningTasks() }
+            { name: "recover-orphaned-planning", fn: () => this.recoverOrphanedPlanningTasks() },
+            { name: "recover-ghost-review", fn: () => this.recoverGhostReviewTasks() }
           ];
           for (const fn of batch2Fns) {
             try {
               await fn.fn();
-              log8.log(`Maintenance batch 2 step "${fn.name}" succeeded`);
+              log16.log(`Maintenance batch 2 step "${fn.name}" succeeded`);
             } catch (stepErr) {
-              log8.error(`Maintenance batch 2 step "${fn.name}" failed: ${stepErr instanceof Error ? stepErr.message : String(stepErr)}`);
+              log16.error(`Maintenance batch 2 step "${fn.name}" failed: ${stepErr instanceof Error ? stepErr.message : String(stepErr)}`);
             }
           }
           const batch3Fns = [
@@ -73350,13 +75064,13 @@ var init_self_healing = __esm({
           for (const fn of batch3Fns) {
             try {
               await fn.fn();
-              log8.log(`Maintenance batch 3 step "${fn.name}" succeeded`);
+              log16.log(`Maintenance batch 3 step "${fn.name}" succeeded`);
             } catch (stepErr) {
-              log8.error(`Maintenance batch 3 step "${fn.name}" failed: ${stepErr instanceof Error ? stepErr.message : String(stepErr)}`);
+              log16.error(`Maintenance batch 3 step "${fn.name}" failed: ${stepErr instanceof Error ? stepErr.message : String(stepErr)}`);
             }
           }
           const elapsedMs = Date.now() - startMs;
-          log8.log(`Maintenance cycle completed in ${elapsedMs}ms`);
+          log16.log(`Maintenance cycle completed in ${elapsedMs}ms`);
         } finally {
           this.maintenanceRunning = false;
         }
@@ -73389,7 +75103,7 @@ var init_self_healing = __esm({
             return movedAt < cutoff;
           });
           if (stale.length === 0) return 0;
-          log8.log(`Auto-archiving ${stale.length} done task(s) older than ${archiveAfterMs}ms`);
+          log16.log(`Auto-archiving ${stale.length} done task(s) older than ${archiveAfterMs}ms`);
           let archived = 0;
           for (const task of stale) {
             try {
@@ -73397,16 +75111,16 @@ var init_self_healing = __esm({
               archived++;
             } catch (err) {
               const errorMessage = err instanceof Error ? err.message : String(err);
-              log8.error(`Failed to auto-archive ${task.id}: ${errorMessage}`);
+              log16.error(`Failed to auto-archive ${task.id}: ${errorMessage}`);
             }
           }
           if (archived > 0) {
-            log8.log(`Auto-archived ${archived} stale done task(s)`);
+            log16.log(`Auto-archived ${archived} stale done task(s)`);
           }
           return archived;
         } catch (err) {
           const errorMessage = err instanceof Error ? err.message : String(err);
-          log8.error(`Auto-archive sweep failed: ${errorMessage}`);
+          log16.error(`Auto-archive sweep failed: ${errorMessage}`);
           return 0;
         }
       }
@@ -73431,25 +75145,25 @@ var init_self_healing = __esm({
             (t) => t.column === "in-progress" && !t.paused && !executingIds.has(t.id) && t.steps.length > 0 && t.steps.every((s) => s.status === "done" || s.status === "skipped")
           );
           if (stuckCompleted.length === 0) return 0;
-          log8.warn(`Found ${stuckCompleted.length} completed task(s) stuck in in-progress`);
+          log16.warn(`Found ${stuckCompleted.length} completed task(s) stuck in in-progress`);
           let recovered = 0;
           for (const task of stuckCompleted) {
             const latestExecutingIds = this.options.getExecutingTaskIds?.() ?? /* @__PURE__ */ new Set();
             if (latestExecutingIds.has(task.id)) {
-              log8.log(`${task.id} started executing concurrently \u2014 skipping recovery this cycle`);
+              log16.log(`${task.id} started executing concurrently \u2014 skipping recovery this cycle`);
               continue;
             }
-            log8.log(`Recovering completed task ${task.id}: ${task.title || task.description?.slice(0, 60) || "(untitled)"}`);
+            log16.log(`Recovering completed task ${task.id}: ${task.title || task.description?.slice(0, 60) || "(untitled)"}`);
             const success = await recoverFn(task);
             if (success) recovered++;
           }
           if (recovered > 0) {
-            log8.log(`Recovered ${recovered} completed task(s) \u2192 in-review`);
+            log16.log(`Recovered ${recovered} completed task(s) \u2192 in-review`);
           }
           return recovered;
         } catch (err) {
           const errorMessage = err instanceof Error ? err.message : String(err);
-          log8.error(`Completed task recovery failed: ${errorMessage}`);
+          log16.error(`Completed task recovery failed: ${errorMessage}`);
           return 0;
         }
       }
@@ -73472,7 +75186,7 @@ var init_self_healing = __esm({
             (t) => t.column === "in-review" && !t.paused && Boolean(t.worktree) && t.mergeDetails?.mergeConfirmed !== true && getTaskMergeBlocker(t) === void 0
           );
           if (mergeable.length === 0) return 0;
-          log8.warn(`Found ${mergeable.length} mergeable review task(s) stuck in in-review`);
+          log16.warn(`Found ${mergeable.length} mergeable review task(s) stuck in in-review`);
           const enqueueMerge = this.options.enqueueMerge;
           let recovered = 0;
           for (const task of mergeable) {
@@ -73486,20 +75200,20 @@ var init_self_healing = __esm({
                 task.id,
                 enqueueMerge ? "Auto-recovered: eligible in-review task re-enqueued for merge" : "Auto-recovered: eligible in-review task was merged and moved to done"
               );
-              log8.log(`Recovered mergeable review task ${task.id}`);
+              log16.log(`Recovered mergeable review task ${task.id}`);
               recovered++;
             } catch (err) {
               const errorMessage = err instanceof Error ? err.message : String(err);
-              log8.error(`Failed to recover mergeable review task ${task.id}: ${errorMessage}`);
+              log16.error(`Failed to recover mergeable review task ${task.id}: ${errorMessage}`);
             }
           }
           if (recovered > 0) {
-            log8.log(`Recovered ${recovered} mergeable review task(s) \u2192 done`);
+            log16.log(`Recovered ${recovered} mergeable review task(s) \u2192 done`);
           }
           return recovered;
         } catch (err) {
           const errorMessage = err instanceof Error ? err.message : String(err);
-          log8.error(`Mergeable review recovery failed: ${errorMessage}`);
+          log16.error(`Mergeable review recovery failed: ${errorMessage}`);
           return 0;
         }
       }
@@ -73547,7 +75261,7 @@ var init_self_healing = __esm({
             return true;
           });
           if (candidates.length === 0) return 0;
-          log8.warn(`Found ${candidates.length} in-review task(s) with failed pre-merge workflow steps \u2014 auto-reviving`);
+          log16.warn(`Found ${candidates.length} in-review task(s) with failed pre-merge workflow steps \u2014 auto-reviving`);
           let recovered = 0;
           for (const task of candidates) {
             const nextCount = (task.postReviewFixCount ?? 0) + 1;
@@ -73559,23 +75273,23 @@ var init_self_healing = __esm({
               );
               const sentBack = await recoverFn(task);
               if (sentBack) {
-                log8.log(`Revived ${task.id}: sent back for fix (${nextCount}/${maxFixes})`);
+                log16.log(`Revived ${task.id}: sent back for fix (${nextCount}/${maxFixes})`);
                 recovered++;
               } else {
-                log8.warn(`Revival of ${task.id} was skipped by executor \u2014 budget already consumed`);
+                log16.warn(`Revival of ${task.id} was skipped by executor \u2014 budget already consumed`);
               }
             } catch (err) {
               const errorMessage = err instanceof Error ? err.message : String(err);
-              log8.error(`Failed to revive ${task.id}: ${errorMessage}`);
+              log16.error(`Failed to revive ${task.id}: ${errorMessage}`);
             }
           }
           if (recovered > 0) {
-            log8.log(`Auto-revived ${recovered} in-review task(s) for pre-merge workflow step fix`);
+            log16.log(`Auto-revived ${recovered} in-review task(s) for pre-merge workflow step fix`);
           }
           return recovered;
         } catch (err) {
           const errorMessage = err instanceof Error ? err.message : String(err);
-          log8.error(`Failed pre-merge workflow step revival failed: ${errorMessage}`);
+          log16.error(`Failed pre-merge workflow step revival failed: ${errorMessage}`);
           return 0;
         }
       }
@@ -73599,7 +75313,7 @@ var init_self_healing = __esm({
             (task) => task.column === "in-review" && !task.paused && !task.status && task.steps.length > 0 && task.steps.some((step) => NON_TERMINAL_STEP_STATUSES2.has(step.status)) && now - new Date(task.updatedAt).getTime() >= timeoutMs
           );
           if (staleIncomplete.length === 0) return 0;
-          log8.warn(`Found ${staleIncomplete.length} stale in-review task(s) with incomplete steps`);
+          log16.warn(`Found ${staleIncomplete.length} stale in-review task(s) with incomplete steps`);
           let recovered = 0;
           for (const task of staleIncomplete) {
             try {
@@ -73608,17 +75322,82 @@ var init_self_healing = __esm({
                 "Auto-recovered: in-review task still had incomplete steps \u2014 moved back to todo for retry"
               );
               await this.store.moveTask(task.id, "todo");
-              log8.log(`Recovered stale incomplete review task ${task.id}: moved back to todo`);
+              log16.log(`Recovered stale incomplete review task ${task.id}: moved back to todo`);
               recovered++;
             } catch (err) {
               const errorMessage = err instanceof Error ? err.message : String(err);
-              log8.error(`Failed to recover stale incomplete review task ${task.id}: ${errorMessage}`);
+              log16.error(`Failed to recover stale incomplete review task ${task.id}: ${errorMessage}`);
             }
           }
           return recovered;
         } catch (err) {
           const errorMessage = err instanceof Error ? err.message : String(err);
-          log8.error(`Stale incomplete review recovery failed: ${errorMessage}`);
+          log16.error(`Stale incomplete review recovery failed: ${errorMessage}`);
+          return 0;
+        }
+      }
+      /**
+       * Final-fallback recovery for `in-review` tasks that fell through every other
+       * scan and have sat untouched longer than `taskStuckTimeoutMs`.
+       *
+       * The other review-recovery scans each require a specific shape (failed
+       * pre-merge step, incomplete steps, mergeable + worktree present, confirmed
+       * merge, transient merge status). A task whose state doesn't match any of
+       * those shapes — e.g. `status: "failed"` with no failed pre-merge step, or
+       * any other unanticipated combination — has no recovery path and stays
+       * silent in review forever.
+       *
+       * This catch-all kicks any such task back to `todo`, clearing transient
+       * `status` so the scheduler can pick it up. Worktree state is intentionally
+       * not considered: the executor will recreate one if needed.
+       *
+       * Preserved statuses (skipped):
+       * - `awaiting-user-review`, `awaiting-approval`: explicit human handoff
+       * - `merging`, `merging-pr`: handled by `recoverInterruptedMergingTasks`
+       *
+       * Rate-limiting comes from the `updatedAt >= taskStuckTimeoutMs` gate —
+       * each kick refreshes `updatedAt`, so a task that re-enters review and gets
+       * stuck again can only be kicked once per `taskStuckTimeoutMs` window.
+       *
+       * @returns Number of tasks kicked back to todo
+       */
+      async recoverGhostReviewTasks() {
+        try {
+          const settings = await this.store.getSettings();
+          const timeoutMs = settings.taskStuckTimeoutMs;
+          if (!timeoutMs || timeoutMs <= 0) return 0;
+          if (settings.globalPause || settings.enginePaused) return 0;
+          const now = Date.now();
+          const executingIds = this.options.getExecutingTaskIds?.() ?? /* @__PURE__ */ new Set();
+          const tasks = await this.store.listTasks({ column: "in-review", slim: true });
+          const ghosts = tasks.filter(
+            (task) => task.column === "in-review" && !task.paused && !executingIds.has(task.id) && !(task.status && GHOST_REVIEW_PRESERVED_STATUSES.has(task.status)) && // Confirmed merges belong in `done` (handled by `recoverMergedReviewTasks`).
+            task.mergeDetails?.mergeConfirmed !== true && now - new Date(task.updatedAt).getTime() >= timeoutMs
+          );
+          if (ghosts.length === 0) return 0;
+          log16.warn(`Found ${ghosts.length} ghost in-review task(s) \u2014 kicking back to todo`);
+          let recovered = 0;
+          for (const task of ghosts) {
+            try {
+              if (task.status) {
+                await this.store.updateTask(task.id, { status: null, error: null });
+              }
+              await this.store.logEntry(
+                task.id,
+                "Auto-recovered: in-review task idle past stuck-task timeout \u2014 kicked back to todo"
+              );
+              await this.store.moveTask(task.id, "todo");
+              log16.log(`Kicked ghost review task ${task.id} back to todo`);
+              recovered++;
+            } catch (err) {
+              const errorMessage = err instanceof Error ? err.message : String(err);
+              log16.error(`Failed to kick ghost review task ${task.id}: ${errorMessage}`);
+            }
+          }
+          return recovered;
+        } catch (err) {
+          const errorMessage = err instanceof Error ? err.message : String(err);
+          log16.error(`Ghost review recovery failed: ${errorMessage}`);
           return 0;
         }
       }
@@ -73646,7 +75425,7 @@ var init_self_healing = __esm({
             (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`);
+          log16.warn(`Found ${candidates.length} stale merging task(s) in in-review`);
           let recovered = 0;
           for (const task of candidates) {
             try {
@@ -73674,7 +75453,7 @@ var init_self_healing = __esm({
                   task.id,
                   `Auto-recovered: stale merge status finalized from landed commit ${landedCommit.sha.slice(0, 8)}`
                 );
-                log8.log(`Recovered interrupted merge ${task.id}: finalized landed commit ${landedCommit.sha.slice(0, 8)}`);
+                log16.log(`Recovered interrupted merge ${task.id}: finalized landed commit ${landedCommit.sha.slice(0, 8)}`);
                 recovered++;
                 continue;
               }
@@ -73683,27 +75462,27 @@ var init_self_healing = __esm({
                 task.id,
                 "Auto-recovered: stale merge status cleared; merge will be retried"
               );
-              log8.log(`Recovered interrupted merge ${task.id}: cleared stale status for retry`);
+              log16.log(`Recovered interrupted merge ${task.id}: cleared stale status for retry`);
               try {
                 this.options.enqueueMerge?.(task.id);
               } catch (enqueueErr) {
-                log8.warn(
+                log16.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);
-              log8.error(`Failed to recover interrupted merge ${task.id}: ${errorMessage}`);
+              log16.error(`Failed to recover interrupted merge ${task.id}: ${errorMessage}`);
             }
           }
           if (recovered > 0) {
-            log8.log(`Recovered ${recovered} interrupted merge task(s)`);
+            log16.log(`Recovered ${recovered} interrupted merge task(s)`);
           }
           return recovered;
         } catch (err) {
           const errorMessage = err instanceof Error ? err.message : String(err);
-          log8.error(`Interrupted merge recovery failed: ${errorMessage}`);
+          log16.error(`Interrupted merge recovery failed: ${errorMessage}`);
           return 0;
         }
       }
@@ -73724,7 +75503,7 @@ var init_self_healing = __esm({
             (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`);
+          log16.warn(`Found ${mergedButNotDone.length} merged task(s) stuck in in-review`);
           let recovered = 0;
           for (const task of mergedButNotDone) {
             try {
@@ -73738,20 +75517,20 @@ var init_self_healing = __esm({
                 task.id,
                 "Auto-recovered: merge already confirmed \u2014 moved from in-review to done"
               );
-              log8.log(`Recovered merged task ${task.id}: moved to done`);
+              log16.log(`Recovered merged task ${task.id}: moved to done`);
               recovered++;
             } catch (err) {
               const errorMessage = err instanceof Error ? err.message : String(err);
-              log8.error(`Failed to recover merged task ${task.id}: ${errorMessage}`);
+              log16.error(`Failed to recover merged task ${task.id}: ${errorMessage}`);
             }
           }
           if (recovered > 0) {
-            log8.log(`Recovered ${recovered} merged task(s) \u2192 done`);
+            log16.log(`Recovered ${recovered} merged task(s) \u2192 done`);
           }
           return recovered;
         } catch (err) {
           const errorMessage = err instanceof Error ? err.message : String(err);
-          log8.error(`Merged review recovery failed: ${errorMessage}`);
+          log16.error(`Merged review recovery failed: ${errorMessage}`);
           return 0;
         }
       }
@@ -73772,7 +75551,7 @@ var init_self_healing = __esm({
             (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`);
+          log16.warn(`Found ${misclassified.length} misclassified failure(s) with all steps done`);
           let recovered = 0;
           for (const task of misclassified) {
             try {
@@ -73784,20 +75563,20 @@ var init_self_healing = __esm({
                 task.id,
                 "Auto-recovered: all steps complete despite 'no task_done' failure \u2014 cleared error for normal review"
               );
-              log8.log(`Recovered misclassified failure ${task.id}: ${task.title || task.description?.slice(0, 60) || "(untitled)"}`);
+              log16.log(`Recovered misclassified failure ${task.id}: ${task.title || task.description?.slice(0, 60) || "(untitled)"}`);
               recovered++;
             } catch (err) {
               const errorMessage = err instanceof Error ? err.message : String(err);
-              log8.error(`Failed to recover misclassified failure ${task.id}: ${errorMessage}`);
+              log16.error(`Failed to recover misclassified failure ${task.id}: ${errorMessage}`);
             }
           }
           if (recovered > 0) {
-            log8.log(`Recovered ${recovered} misclassified failure(s) \u2192 cleared for review`);
+            log16.log(`Recovered ${recovered} misclassified failure(s) \u2192 cleared for review`);
           }
           return recovered;
         } catch (err) {
           const errorMessage = err instanceof Error ? err.message : String(err);
-          log8.error(`Misclassified failure recovery failed: ${errorMessage}`);
+          log16.error(`Misclassified failure recovery failed: ${errorMessage}`);
           return 0;
         }
       }
@@ -73821,7 +75600,7 @@ var init_self_healing = __esm({
             return staleness >= graceMs;
           });
           if (orphaned.length === 0) return 0;
-          log8.warn(`Found ${orphaned.length} orphaned executor task(s) stuck in in-progress`);
+          log16.warn(`Found ${orphaned.length} orphaned executor task(s) stuck in in-progress`);
           let recovered = 0;
           for (const task of orphaned) {
             try {
@@ -73841,16 +75620,16 @@ var init_self_healing = __esm({
               recovered++;
             } catch (err) {
               const errorMessage = err instanceof Error ? err.message : String(err);
-              log8.error(`Failed to recover orphaned executor task ${task.id}: ${errorMessage}`);
+              log16.error(`Failed to recover orphaned executor task ${task.id}: ${errorMessage}`);
             }
           }
           if (recovered > 0) {
-            log8.log(`Recovered ${recovered} orphaned executor task(s) \u2192 todo`);
+            log16.log(`Recovered ${recovered} orphaned executor task(s) \u2192 todo`);
           }
           return recovered;
         } catch (err) {
           const errorMessage = err instanceof Error ? err.message : String(err);
-          log8.error(`Orphaned executor recovery failed: ${errorMessage}`);
+          log16.error(`Orphaned executor recovery failed: ${errorMessage}`);
           return 0;
         }
       }
@@ -73871,12 +75650,12 @@ var init_self_healing = __esm({
             (task) => task.column === "in-progress" && task.status === "failed" && isNoTaskDoneFailure(task) && !task.paused && !executingIds.has(task.id) && !isTaskWorkComplete(task) && !hasStepProgress(task)
           );
           if (candidates.length === 0) return 0;
-          log8.warn(`Found ${candidates.length} no-progress no-task_done failure(s) in in-progress`);
+          log16.warn(`Found ${candidates.length} no-progress no-task_done failure(s) in in-progress`);
           let recovered = 0;
           for (const task of candidates) {
             try {
               if (await this.hasRecoverableGitWork(task)) {
-                log8.log(`${task.id} has recoverable git work \u2014 leaving in-progress for inspection`);
+                log16.log(`${task.id} has recoverable git work \u2014 leaving in-progress for inspection`);
                 continue;
               }
               await this.store.updateTask(task.id, {
@@ -73892,16 +75671,16 @@ var init_self_healing = __esm({
               recovered++;
             } catch (err) {
               const errorMessage = err instanceof Error ? err.message : String(err);
-              log8.error(`Failed to recover no-progress no-task_done failure ${task.id}: ${errorMessage}`);
+              log16.error(`Failed to recover no-progress no-task_done failure ${task.id}: ${errorMessage}`);
             }
           }
           if (recovered > 0) {
-            log8.log(`Recovered ${recovered} no-progress no-task_done failure(s) \u2192 todo`);
+            log16.log(`Recovered ${recovered} no-progress no-task_done failure(s) \u2192 todo`);
           }
           return recovered;
         } catch (err) {
           const errorMessage = err instanceof Error ? err.message : String(err);
-          log8.error(`No-progress no-task_done recovery failed: ${errorMessage}`);
+          log16.error(`No-progress no-task_done recovery failed: ${errorMessage}`);
           return 0;
         }
       }
@@ -73932,7 +75711,7 @@ var init_self_healing = __esm({
             (task) => task.column === "in-review" && task.status === "failed" && isNoTaskDoneFailure(task) && !task.paused && !isTaskWorkComplete(task) && hasStepProgress(task) && (task.taskDoneRetryCount ?? 0) < MAX_TASK_DONE_RETRIES
           );
           if (candidates.length === 0) return 0;
-          log8.warn(
+          log16.warn(
             `Found ${candidates.length} partial-progress no-task_done failure(s) eligible for auto-retry`
           );
           let recovered = 0;
@@ -73953,20 +75732,20 @@ var init_self_healing = __esm({
               recovered++;
             } catch (err) {
               const errorMessage = err instanceof Error ? err.message : String(err);
-              log8.error(
+              log16.error(
                 `Failed to auto-retry partial-progress no-task_done failure ${task.id}: ${errorMessage}`
               );
             }
           }
           if (recovered > 0) {
-            log8.log(
+            log16.log(
               `Auto-retried ${recovered} partial-progress no-task_done failure(s) \u2192 todo`
             );
           }
           return recovered;
         } catch (err) {
           const errorMessage = err instanceof Error ? err.message : String(err);
-          log8.error(`Partial-progress no-task_done recovery failed: ${errorMessage}`);
+          log16.error(`Partial-progress no-task_done recovery failed: ${errorMessage}`);
           return 0;
         }
       }
@@ -73980,7 +75759,7 @@ var init_self_healing = __esm({
             if (status.trim().length > 0) return true;
           } catch (err) {
             const errorMessage = err instanceof Error ? err.message : String(err);
-            log8.warn(
+            log16.warn(
               `Failed to inspect worktree status for ${task.id} at ${task.worktree}: ${errorMessage} \u2014 preserving worktree`
             );
             return true;
@@ -74003,7 +75782,7 @@ var init_self_healing = __esm({
           return Number.parseInt(uniqueCommits.trim(), 10) > 0;
         } catch (err) {
           const errorMessage = err instanceof Error ? err.message : String(err);
-          log8.warn(
+          log16.warn(
             `Failed to compare branch ${branchName} against HEAD for ${task.id}: ${errorMessage} \u2014 preserving branch`
           );
           return true;
@@ -74028,20 +75807,20 @@ var init_self_healing = __esm({
             (t) => t.column === "triage" && t.status === "planning" && !t.paused && !planningIds.has(t.id) && now - new Date(t.updatedAt).getTime() >= APPROVED_TRIAGE_RECOVERY_GRACE_MS && hasLatestSpecReviewApproval2(t)
           );
           if (orphanedApproved.length === 0) return 0;
-          log8.warn(`Found ${orphanedApproved.length} approved triage task(s) stuck in planning`);
+          log16.warn(`Found ${orphanedApproved.length} approved triage task(s) stuck in planning`);
           let recovered = 0;
           for (const task of orphanedApproved) {
-            log8.log(`Recovering approved triage task ${task.id}: ${task.title || task.description?.slice(0, 60) || "(untitled)"}`);
+            log16.log(`Recovering approved triage task ${task.id}: ${task.title || task.description?.slice(0, 60) || "(untitled)"}`);
             const success = await recoverFn(task);
             if (success) recovered++;
           }
           if (recovered > 0) {
-            log8.log(`Recovered ${recovered} approved triage task(s) out of planning`);
+            log16.log(`Recovered ${recovered} approved triage task(s) out of planning`);
           }
           return recovered;
         } catch (err) {
           const errorMessage = err instanceof Error ? err.message : String(err);
-          log8.error(`Approved triage recovery failed: ${errorMessage}`);
+          log16.error(`Approved triage recovery failed: ${errorMessage}`);
           return 0;
         }
       }
@@ -74067,11 +75846,11 @@ var init_self_healing = __esm({
             (t) => t.column === "triage" && t.status === "planning" && !t.paused && !planningIds.has(t.id) && now - new Date(t.updatedAt).getTime() >= APPROVED_TRIAGE_RECOVERY_GRACE_MS && !hasLatestSpecReviewApproval2(t)
           );
           if (orphaned.length === 0) return 0;
-          log8.warn(`Found ${orphaned.length} orphaned planning triage task(s) without approval`);
+          log16.warn(`Found ${orphaned.length} orphaned planning triage task(s) without approval`);
           let recovered = 0;
           for (const task of orphaned) {
             try {
-              log8.log(`Recovering orphaned planning task ${task.id}: ${task.title || task.description?.slice(0, 60) || "(untitled)"}`);
+              log16.log(`Recovering orphaned planning task ${task.id}: ${task.title || task.description?.slice(0, 60) || "(untitled)"}`);
               await this.store.updateTask(task.id, { status: null });
               await this.store.logEntry(
                 task.id,
@@ -74080,16 +75859,16 @@ var init_self_healing = __esm({
               recovered++;
             } catch (err) {
               const errorMessage = err instanceof Error ? err.message : String(err);
-              log8.error(`Failed to recover orphaned planning task ${task.id}: ${errorMessage}`);
+              log16.error(`Failed to recover orphaned planning task ${task.id}: ${errorMessage}`);
             }
           }
           if (recovered > 0) {
-            log8.log(`Recovered ${recovered} orphaned planning task(s) \u2014 cleared for re-planning`);
+            log16.log(`Recovered ${recovered} orphaned planning task(s) \u2014 cleared for re-planning`);
           }
           return recovered;
         } catch (err) {
           const errorMessage = err instanceof Error ? err.message : String(err);
-          log8.error(`Orphaned planning task recovery failed: ${errorMessage}`);
+          log16.error(`Orphaned planning task recovery failed: ${errorMessage}`);
           return 0;
         }
       }
@@ -74100,10 +75879,10 @@ var init_self_healing = __esm({
             cwd: this.options.rootDir,
             timeout: 3e4
           });
-          log8.log("Worktree prune completed");
+          log16.log("Worktree prune completed");
         } catch (err) {
           const errorMessage = err instanceof Error ? err.message : String(err);
-          log8.error(`Worktree prune failed: ${errorMessage}`);
+          log16.error(`Worktree prune failed: ${errorMessage}`);
         }
       }
       /**
@@ -74136,16 +75915,16 @@ var init_self_healing = __esm({
               cleaned++;
             } catch (err) {
               const errorMessage = err instanceof Error ? err.message : String(err);
-              log8.warn(`Failed to remove orphaned worktree ${worktreePath}: ${errorMessage} \u2014 non-fatal`);
+              log16.warn(`Failed to remove orphaned worktree ${worktreePath}: ${errorMessage} \u2014 non-fatal`);
             }
           }
           if (cleaned > 0) {
-            log8.log(`Cleaned ${cleaned} orphaned worktree(s)`);
+            log16.log(`Cleaned ${cleaned} orphaned worktree(s)`);
           }
           return cleaned;
         } catch (err) {
           const errorMessage = err instanceof Error ? err.message : String(err);
-          log8.error(`Orphan cleanup failed: ${errorMessage}`);
+          log16.error(`Orphan cleanup failed: ${errorMessage}`);
           return 0;
         }
       }
@@ -74156,35 +75935,35 @@ var init_self_healing = __esm({
        * tracks registered idle worktrees, never these orphans.
        */
       async reapUnregisteredOrphans() {
-        const worktreesDir = join35(this.options.rootDir, ".worktrees");
+        const worktreesDir = join36(this.options.rootDir, ".worktrees");
         if (!existsSync28(worktreesDir)) return 0;
         let dirs;
         try {
-          dirs = readdirSync5(worktreesDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => join35(worktreesDir, e.name));
+          dirs = readdirSync5(worktreesDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => join36(worktreesDir, e.name));
         } catch (err) {
-          log8.warn(`Failed to read .worktrees/ for unregistered orphan reap: ${err instanceof Error ? err.message : String(err)}`);
+          log16.warn(`Failed to read .worktrees/ for unregistered orphan reap: ${err instanceof Error ? err.message : String(err)}`);
           return 0;
         }
         if (dirs.length === 0) return 0;
         const registered = await getRegisteredWorktreePaths(this.options.rootDir);
-        const unregistered = dirs.filter((d) => !registered.has(resolve15(d)));
+        const unregistered = dirs.filter((d) => !registered.has(resolve16(d)));
         let cleaned = 0;
         for (const path2 of unregistered) {
-          const rel = relative7(worktreesDir, path2);
+          const rel = relative8(worktreesDir, path2);
           if (rel === "" || rel.startsWith("..") || isAbsolute12(rel)) {
-            log8.warn(`Refusing to remove path outside .worktrees: ${path2}`);
+            log16.warn(`Refusing to remove path outside .worktrees: ${path2}`);
             continue;
           }
           try {
             rmSync3(path2, { recursive: true, force: true });
-            log8.log(`Cleaned unregistered worktree dir: ${path2}`);
+            log16.log(`Cleaned unregistered worktree dir: ${path2}`);
             cleaned++;
           } catch (err) {
-            log8.warn(`Failed to remove unregistered worktree dir ${path2}: ${err instanceof Error ? err.message : String(err)}`);
+            log16.warn(`Failed to remove unregistered worktree dir ${path2}: ${err instanceof Error ? err.message : String(err)}`);
           }
         }
         if (cleaned > 0) {
-          log8.log(`Cleaned ${cleaned} unregistered worktree dir(s) (recycle mode preserves registered idle worktrees)`);
+          log16.log(`Cleaned ${cleaned} unregistered worktree dir(s) (recycle mode preserves registered idle worktrees)`);
         }
         return cleaned;
       }
@@ -74213,12 +75992,12 @@ var init_self_healing = __esm({
                 cwd: this.options.rootDir,
                 timeout: 3e4
               });
-              log8.log(`Deleted branch: ${branch}`);
+              log16.log(`Deleted branch: ${branch}`);
               cleaned++;
               deletedBranches.push(branch);
             } catch (err) {
               const errorMessage = err instanceof Error ? err.message : String(err);
-              log8.warn(
+              log16.warn(
                 `Safe delete failed for orphaned branch ${branch}: ${errorMessage} \u2014 attempting force delete`
               );
               try {
@@ -74226,28 +76005,28 @@ var init_self_healing = __esm({
                   cwd: this.options.rootDir,
                   timeout: 3e4
                 });
-                log8.log(`Force-deleted branch: ${branch}`);
+                log16.log(`Force-deleted branch: ${branch}`);
                 cleaned++;
                 deletedBranches.push(branch);
               } catch (forceErr) {
                 const forceErrorMessage = forceErr instanceof Error ? forceErr.message : String(forceErr);
-                log8.warn(`Failed to force-delete orphaned branch ${branch}: ${forceErrorMessage} \u2014 non-fatal`);
+                log16.warn(`Failed to force-delete orphaned branch ${branch}: ${forceErrorMessage} \u2014 non-fatal`);
               }
             }
           }
           if (deletedBranches.length > 0) {
             const cleared = this.store.clearStaleBaseBranchReferences(deletedBranches);
             if (cleared.length > 0) {
-              log8.log(`Cleared stale baseBranch on ${cleared.length} task(s): ${cleared.join(", ")}`);
+              log16.log(`Cleared stale baseBranch on ${cleared.length} task(s): ${cleared.join(", ")}`);
             }
           }
           if (cleaned > 0) {
-            log8.log(`Cleaned ${cleaned} orphaned branch(es)`);
+            log16.log(`Cleaned ${cleaned} orphaned branch(es)`);
           }
           return cleaned;
         } catch (err) {
           const errorMessage = err instanceof Error ? err.message : String(err);
-          log8.error(`Orphaned branch cleanup failed: ${errorMessage}`);
+          log16.error(`Orphaned branch cleanup failed: ${errorMessage}`);
           return 0;
         }
       }
@@ -74256,16 +76035,16 @@ var init_self_healing = __esm({
         try {
           const result = this.store.walCheckpoint();
           if (result.log > 0) {
-            log8.log(`WAL checkpoint: ${result.checkpointed}/${result.log} pages checkpointed` + (result.busy > 0 ? ` (${result.busy} busy)` : ""));
+            log16.log(`WAL checkpoint: ${result.checkpointed}/${result.log} pages checkpointed` + (result.busy > 0 ? ` (${result.busy} busy)` : ""));
           }
         } catch (err) {
           const errorMessage = err instanceof Error ? err.message : String(err);
-          log8.error(`WAL checkpoint failed: ${errorMessage}`);
+          log16.error(`WAL checkpoint failed: ${errorMessage}`);
         }
       }
       /** Remove oldest idle worktrees if total count exceeds 2× maxWorktrees. */
       async enforceWorktreeCap() {
-        const worktreesDir = join35(this.options.rootDir, ".worktrees");
+        const worktreesDir = join36(this.options.rootDir, ".worktrees");
         if (!existsSync28(worktreesDir)) return;
         try {
           const settings = await this.store.getSettings();
@@ -74280,7 +76059,7 @@ var init_self_healing = __esm({
               return { path: p, mtime: statSync5(p).mtimeMs };
             } catch (err) {
               const errorMessage = err instanceof Error ? err.message : String(err);
-              log8.warn(`Failed to read mtime for worktree ${p}: ${errorMessage} \u2014 defaulting mtime to 0`);
+              log16.warn(`Failed to read mtime for worktree ${p}: ${errorMessage} \u2014 defaulting mtime to 0`);
               return { path: p, mtime: 0 };
             }
           });
@@ -74297,15 +76076,15 @@ var init_self_healing = __esm({
               removed++;
             } catch (err) {
               const errorMessage = err instanceof Error ? err.message : String(err);
-              log8.warn(`Failed to remove idle worktree ${worktreePath} during cap enforcement: ${errorMessage} \u2014 non-fatal`);
+              log16.warn(`Failed to remove idle worktree ${worktreePath} during cap enforcement: ${errorMessage} \u2014 non-fatal`);
             }
           }
           if (removed > 0) {
-            log8.warn(`Worktree cap: removed ${removed} idle worktree(s) (was ${dirs.length}, cap ${cap})`);
+            log16.warn(`Worktree cap: removed ${removed} idle worktree(s) (was ${dirs.length}, cap ${cap})`);
           }
         } catch (err) {
           const errorMessage = err instanceof Error ? err.message : String(err);
-          log8.error(`Worktree cap enforcement failed: ${errorMessage}`);
+          log16.error(`Worktree cap enforcement failed: ${errorMessage}`);
         }
       }
     };
@@ -74804,13 +76583,13 @@ var init_plugin_runner = __esm({
        * Returns the result on success, throws on timeout.
        */
       withTimeout(promise, ms, timeoutMessage) {
-        return new Promise((resolve18, reject) => {
+        return new Promise((resolve19, reject) => {
           const timer = setTimeout(() => {
             reject(new Error(timeoutMessage));
           }, ms);
           promise.then((result) => {
             clearTimeout(timer);
-            resolve18(result);
+            resolve19(result);
           }).catch((err) => {
             clearTimeout(timer);
             reject(err);
@@ -75275,7 +77054,7 @@ var init_in_process_runtime = __esm({
           try {
             const { RoutineStore: RoutineStoreClass } = await Promise.resolve().then(() => (init_src(), src_exports));
             if (typeof RoutineStoreClass.prototype.getDueRoutines === "function") {
-              const routineStore = new RoutineStoreClass(this.taskStore.getFusionDir());
+              const routineStore = new RoutineStoreClass(this.config.workingDirectory);
               await routineStore.init();
               this.routineStore = routineStore;
               if (this.heartbeatMonitor) {
@@ -75446,7 +77225,7 @@ var init_in_process_runtime = __esm({
             runtimeLog.log(
               `Waiting for ${metrics.inFlightTasks} in-flight tasks to complete...`
             );
-            await new Promise((resolve18) => setTimeout(resolve18, 1e3));
+            await new Promise((resolve19) => setTimeout(resolve19, 1e3));
           }
           const finalMetrics = this.getMetrics();
           if (finalMetrics.inFlightTasks > 0) {
@@ -75843,13 +77622,13 @@ var init_ipc_host = __esm({
         }
         const id = generateCorrelationId();
         const message = { type, id, payload };
-        return new Promise((resolve18, reject) => {
+        return new Promise((resolve19, reject) => {
           const timeout = setTimeout(() => {
             this.pendingCommands.delete(id);
             reject(new Error(`Command ${type} timed out after ${timeoutMs ?? this.commandTimeoutMs}ms`));
           }, timeoutMs ?? this.commandTimeoutMs);
           this.pendingCommands.set(id, {
-            resolve: resolve18,
+            resolve: resolve19,
             reject,
             timeout,
             type
@@ -75927,7 +77706,7 @@ var init_ipc_host = __esm({
 import { EventEmitter as EventEmitter20 } from "node:events";
 import { fork } from "node:child_process";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
-import { dirname as dirname10, join as join36 } from "node:path";
+import { dirname as dirname10, join as join37 } from "node:path";
 var HealthMonitor, ChildProcessRuntime;
 var init_child_process_runtime = __esm({
   "../engine/src/runtimes/child-process-runtime.ts"() {
@@ -76089,7 +77868,7 @@ var init_child_process_runtime = __esm({
         const isCompiled = !import.meta.url.endsWith(".ts");
         const currentDir = dirname10(fileURLToPath3(import.meta.url));
         const workerFile = isCompiled ? "child-process-worker.js" : "child-process-worker.ts";
-        return join36(currentDir, workerFile);
+        return join37(currentDir, workerFile);
       }
       /**
        * Set up event forwarding from IPC host to runtime listeners.
@@ -76320,7 +78099,7 @@ var init_child_process_runtime = __esm({
 });
 
 // ../engine/src/runtimes/remote-node-client.ts
-var RemoteNodeRequestError, RETRY_BASE_DELAY_MS2, DEFAULT_MAX_RETRIES, RemoteNodeClient;
+var RemoteNodeRequestError, RETRY_BASE_DELAY_MS3, DEFAULT_MAX_RETRIES, RemoteNodeClient;
 var init_remote_node_client = __esm({
   "../engine/src/runtimes/remote-node-client.ts"() {
     "use strict";
@@ -76333,7 +78112,7 @@ var init_remote_node_client = __esm({
         this.name = "RemoteNodeRequestError";
       }
     };
-    RETRY_BASE_DELAY_MS2 = 1e3;
+    RETRY_BASE_DELAY_MS3 = 1e3;
     DEFAULT_MAX_RETRIES = 3;
     RemoteNodeClient = class {
       baseUrl;
@@ -76638,7 +78417,7 @@ var init_remote_node_client = __esm({
             if (!isRetryable || attempt >= maxRetries) {
               throw error;
             }
-            const delayMs = RETRY_BASE_DELAY_MS2 * 2 ** attempt;
+            const delayMs = RETRY_BASE_DELAY_MS3 * 2 ** attempt;
             attempt += 1;
             remoteNodeLog.warn(
               `Request failed, retrying in ${delayMs}ms (attempt ${attempt}/${maxRetries})`,
@@ -76658,8 +78437,8 @@ var init_remote_node_client = __esm({
         return error instanceof TypeError;
       }
       async sleep(ms) {
-        await new Promise((resolve18) => {
-          setTimeout(resolve18, ms);
+        await new Promise((resolve19) => {
+          setTimeout(resolve19, ms);
         });
       }
     };
@@ -76923,14 +78702,14 @@ var init_remote_node_runtime = __esm({
         return error instanceof Error ? error : new Error(String(error));
       }
       async sleep(ms, signal) {
-        await new Promise((resolve18) => {
+        await new Promise((resolve19) => {
           const timeout = setTimeout(() => {
             cleanup();
-            resolve18();
+            resolve19();
           }, ms);
           const onAbort = () => {
             cleanup();
-            resolve18();
+            resolve19();
           };
           const cleanup = () => {
             clearTimeout(timeout);
@@ -77271,11 +79050,13 @@ var init_gridlock_detector = __esm({
         this.pollIntervalMs = options.pollIntervalMs ?? 3e4;
         this.missionStore = options.missionStore;
         this.onGridlock = options.onGridlock;
+        this.onGridlockCleared = options.onGridlockCleared;
       }
       interval = null;
       pollIntervalMs;
       missionStore;
       onGridlock;
+      onGridlockCleared;
       lastGridlockKey = null;
       start() {
         if (this.interval) return;
@@ -77305,12 +79086,12 @@ var init_gridlock_detector = __esm({
           return true;
         });
         if (schedulable.length === 0) {
-          this.lastGridlockKey = null;
+          this.clearGridlockState();
           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;
+          this.clearGridlockState();
           return null;
         }
         const overlapIgnorePaths = settings.overlapIgnorePaths ?? [];
@@ -77348,7 +79129,7 @@ var init_gridlock_detector = __esm({
         }
         const blockedTaskIds = Object.keys(reasons).sort();
         if (blockedTaskIds.length !== schedulable.length) {
-          this.lastGridlockKey = null;
+          this.clearGridlockState();
           return null;
         }
         const gridlockKey = blockedTaskIds.join(",");
@@ -77365,6 +79146,12 @@ var init_gridlock_detector = __esm({
         }
         return event;
       }
+      clearGridlockState() {
+        if (this.lastGridlockKey !== null) {
+          this.lastGridlockKey = null;
+          this.onGridlockCleared?.();
+        }
+      }
       isMissionBlocked(task) {
         if (!this.missionStore || !task.sliceId) return false;
         try {
@@ -77825,10 +79612,10 @@ var init_tunnel_process_manager = __esm({
           lastError: null
         });
         this.emitLog("info", "manager", `Stopping ${currentHandle.provider} tunnel (pid=${currentHandle.child.pid ?? "n/a"})`);
-        this.activeStopPromise = new Promise((resolve18) => {
+        this.activeStopPromise = new Promise((resolve19) => {
           const onClose = () => {
             currentHandle.child.removeListener("close", onClose);
-            resolve18();
+            resolve19();
           };
           currentHandle.child.once("close", onClose);
           killManagedProcess(currentHandle.child, "SIGTERM");
@@ -77979,6 +79766,8 @@ var init_project_engine = __esm({
     init_merger();
     init_concurrency();
     init_logger2();
+    init_research_orchestrator();
+    init_research_step_runner();
     init_tunnel_process_manager();
     execFileAsync = promisify10(execFile3);
     MERGE_HANDOFF_GRACE_MS = 300;
@@ -78009,6 +79798,7 @@ var init_project_engine = __esm({
       gridlockDetector;
       cronRunner;
       automationStore;
+      researchOrchestrator;
       remoteTunnelManager;
       remoteTunnelRestoreDiagnostics = {
         outcome: "skipped",
@@ -78063,6 +79853,14 @@ var init_project_engine = __esm({
         await this.runtime.start();
         const store = this.runtime.getTaskStore();
         const cwd = this.config.workingDirectory;
+        const settings = await store.getSettings();
+        if (typeof store.getResearchStore === "function") {
+          this.researchOrchestrator = new ResearchOrchestrator({
+            store: store.getResearchStore(),
+            stepRunner: new ResearchStepRunner(),
+            maxConcurrentRuns: settings.researchMaxConcurrentRuns ?? 3
+          });
+        }
         this.remoteTunnelManager = new TunnelProcessManager();
         try {
           await this.restoreRemoteTunnelIfNeeded(store);
@@ -78093,7 +79891,8 @@ var init_project_engine = __esm({
           await this.notifier.start();
         }
         this.gridlockDetector = new GridlockDetector(store, {
-          onGridlock: (event) => this.notifier?.notifyGridlock(event)
+          onGridlock: (event) => this.notifier?.notifyGridlock(event),
+          onGridlockCleared: () => this.notifier?.notifyGridlock(null)
         });
         this.gridlockDetector.start();
         this.setAutomationSubsystemHealth(
@@ -78112,11 +79911,11 @@ var init_project_engine = __esm({
             scope: "project"
             // Project-scoped execution — global schedules run separately
           });
-          const settings = await store.getSettings();
+          const settings2 = await store.getSettings();
           const startupSyncFailures = [];
           if (typeof coreAutomationModule.syncInsightExtractionAutomation === "function") {
             try {
-              await coreAutomationModule.syncInsightExtractionAutomation(this.automationStore, settings);
+              await coreAutomationModule.syncInsightExtractionAutomation(this.automationStore, settings2);
             } catch (err) {
               const { message, detail } = formatErrorDetails(err);
               startupSyncFailures.push(`insight extraction: ${message}`);
@@ -78128,7 +79927,7 @@ ${detail}`);
           }
           if (typeof coreAutomationModule.syncAutoSummarizeAutomation === "function") {
             try {
-              await coreAutomationModule.syncAutoSummarizeAutomation(this.automationStore, settings);
+              await coreAutomationModule.syncAutoSummarizeAutomation(this.automationStore, settings2);
             } catch (err) {
               const { message, detail } = formatErrorDetails(err);
               startupSyncFailures.push(`auto-summarize: ${message}`);
@@ -78140,7 +79939,7 @@ ${detail}`);
           }
           if (typeof coreAutomationModule.syncMemoryDreamsAutomation === "function") {
             try {
-              await coreAutomationModule.syncMemoryDreamsAutomation(this.automationStore, settings);
+              await coreAutomationModule.syncMemoryDreamsAutomation(this.automationStore, settings2);
             } catch (err) {
               const { message, detail } = formatErrorDetails(err);
               startupSyncFailures.push(`memory dreams: ${message}`);
@@ -78305,6 +80104,10 @@ ${detail}`
       getRoutineStore() {
         return this.runtime.getRoutineStore();
       }
+      /** Get the ResearchOrchestrator (if initialized). Returns undefined before start(). */
+      getResearchOrchestrator() {
+        return this.researchOrchestrator;
+      }
       /** Get the remote tunnel manager (available after start()). */
       getRemoteTunnelManager() {
         return this.remoteTunnelManager;
@@ -78395,12 +80198,12 @@ ${detail}`
        */
       async onMerge(taskId) {
         if (this.mergeActive.has(taskId)) {
-          return new Promise((resolve18, reject) => {
-            this.manualMergeResolvers.set(taskId, { resolve: resolve18, reject });
+          return new Promise((resolve19, reject) => {
+            this.manualMergeResolvers.set(taskId, { resolve: resolve19, reject });
           });
         }
-        return new Promise((resolve18, reject) => {
-          this.manualMergeResolvers.set(taskId, { resolve: resolve18, reject });
+        return new Promise((resolve19, reject) => {
+          this.manualMergeResolvers.set(taskId, { resolve: resolve19, reject });
           this.internalEnqueueMerge(taskId);
         });
       }
@@ -80138,11 +81941,14 @@ __export(src_exports2, {
   AgentSemaphore: () => AgentSemaphore,
   CronRunner: () => CronRunner,
   DEFAULT_NTFY_EVENTS: () => DEFAULT_NTFY_EVENTS,
+  GitHubProvider: () => GitHubProvider,
   HEARTBEAT_NO_TASK_SYSTEM_PROMPT: () => HEARTBEAT_NO_TASK_SYSTEM_PROMPT,
   HEARTBEAT_PROCEDURE: () => HEARTBEAT_PROCEDURE,
   HEARTBEAT_SYSTEM_PROMPT: () => HEARTBEAT_SYSTEM_PROMPT,
   HeartbeatMonitor: () => HeartbeatMonitor,
   HeartbeatTriggerScheduler: () => HeartbeatTriggerScheduler,
+  LLMSynthesisProvider: () => LLMSynthesisProvider,
+  LocalDocsProvider: () => LocalDocsProvider,
   MissionAutopilot: () => MissionAutopilot,
   MissionExecutionLoop: () => MissionExecutionLoop,
   NodeHealthMonitor: () => NodeHealthMonitor,
@@ -80152,6 +81958,7 @@ __export(src_exports2, {
   PRIORITY_EXECUTE: () => PRIORITY_EXECUTE,
   PRIORITY_MERGE: () => PRIORITY_MERGE,
   PRIORITY_SPECIFY: () => PRIORITY_SPECIFY,
+  PageFetchProvider: () => PageFetchProvider,
   PeerExchangeService: () => PeerExchangeService,
   PluginRunner: () => PluginRunner,
   PrCommentHandler: () => PrCommentHandler,
@@ -80161,6 +81968,13 @@ __export(src_exports2, {
   ProjectManager: () => ProjectManager,
   RemoteNodeClient: () => RemoteNodeClient,
   RemoteNodeRuntime: () => RemoteNodeRuntime,
+  ResearchOrchestrator: () => ResearchOrchestrator,
+  ResearchProviderError: () => ResearchProviderError,
+  ResearchProviderRegistry: () => ResearchProviderRegistry,
+  ResearchStepAbortError: () => ResearchStepAbortError,
+  ResearchStepProviderError: () => ResearchStepProviderError,
+  ResearchStepRunner: () => ResearchStepRunner,
+  ResearchStepTimeoutError: () => ResearchStepTimeoutError,
   RoutineRunner: () => RoutineRunner,
   RoutineScheduler: () => RoutineScheduler,
   Scheduler: () => Scheduler,
@@ -80172,6 +81986,7 @@ __export(src_exports2, {
   TriageProcessor: () => TriageProcessor,
   TunnelProcessManager: () => TunnelProcessManager,
   UsageLimitPauser: () => UsageLimitPauser,
+  WebSearchProvider: () => WebSearchProvider,
   WebhookNotificationProvider: () => WebhookNotificationProvider,
   WorktreePool: () => WorktreePool,
   aiMergeTask: () => aiMergeTask,
@@ -80244,6 +82059,11 @@ var init_src2 = __esm({
     init_logger2();
     init_usage_limit_detector();
     init_rate_limit_retry();
+    init_research_orchestrator();
+    init_research_step_runner();
+    init_provider_registry();
+    init_types2();
+    init_providers();
     init_pr_monitor();
     init_pr_comment_handler();
     init_notifier();
@@ -82028,7 +83848,7 @@ function buildHermesArgs(prompt, settings, resumeSessionId) {
 async function invokeHermesCli(prompt, settings, resumeSessionId, signal) {
   const args = buildHermesArgs(prompt, settings, resumeSessionId);
   const binary = resolveBinaryForSpawn(settings.binaryPath);
-  return new Promise((resolve18, reject) => {
+  return new Promise((resolve19, reject) => {
     let settled = false;
     const spawnEnv = { ...process.env, PYTHONUNBUFFERED: "1" };
     if (settings.profile) {
@@ -82096,7 +83916,7 @@ ${combined}`));
         return;
       }
       try {
-        resolve18(parseHermesOutput(stdout, stderr));
+        resolve19(parseHermesOutput(stdout, stderr));
       } catch (parseErr) {
         reject(parseErr);
       }
@@ -82322,7 +84142,7 @@ async function promptCli(session, message, config, callbacks, signal) {
   const args = buildOpenClawArgs(config, session.sessionId, message);
   const cb = { ...session.callbacks, ...callbacks };
   cb.onToolStart?.("openclaw.agent", { sessionId: session.sessionId });
-  return new Promise((resolve18, reject) => {
+  return new Promise((resolve19, reject) => {
     let settled = false;
     const child = spawn5(config.binaryPath, args, {
       stdio: ["ignore", "pipe", "pipe"]
@@ -82415,7 +84235,7 @@ async function promptCli(session, message, config, callbacks, signal) {
         ...metaError ? { error: metaError } : {},
         ...errorText.length > 0 ? { toolErrors: errorText } : {}
       });
-      resolve18();
+      resolve19();
     });
   });
 }
@@ -83468,7 +85288,7 @@ var require_galois_field = __commonJS({
         EXP_TABLE[i] = EXP_TABLE[i - 255];
       }
     })();
-    exports.log = function log9(n) {
+    exports.log = function log17(n) {
       if (n < 1) throw new Error("log(" + n + ")");
       return LOG_TABLE[n];
     };
@@ -86690,7 +88510,7 @@ var require_utils2 = __commonJS({
 var require_png2 = __commonJS({
   "../../node_modules/.pnpm/qrcode@1.5.4/node_modules/qrcode/lib/renderer/png.js"(exports) {
     "use strict";
-    var fs = __require("fs");
+    var fs2 = __require("fs");
     var PNG = require_png().PNG;
     var Utils = require_utils2();
     exports.render = function render(qrData, options) {
@@ -86742,7 +88562,7 @@ var require_png2 = __commonJS({
         called = true;
         cb.apply(null, args);
       };
-      const stream = fs.createWriteStream(path2);
+      const stream = fs2.createWriteStream(path2);
       stream.on("error", done);
       stream.on("close", done);
       exports.renderToFileStream(stream, qrData, options);
@@ -86810,9 +88630,9 @@ var require_utf8 = __commonJS({
         cb = options;
         options = void 0;
       }
-      const fs = __require("fs");
+      const fs2 = __require("fs");
       const utf8 = exports.render(qrData, options);
-      fs.writeFile(path2, utf8, cb);
+      fs2.writeFile(path2, utf8, cb);
     };
   }
 });
@@ -86991,10 +88811,10 @@ var require_svg = __commonJS({
         cb = options;
         options = void 0;
       }
-      const fs = __require("fs");
+      const fs2 = __require("fs");
       const svgTag = exports.render(qrData, options);
       const xmlStr = '<?xml version="1.0" encoding="utf-8"?><!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">' + svgTag;
-      fs.writeFile(path2, xmlStr, cb);
+      fs2.writeFile(path2, xmlStr, cb);
     };
   }
 });
@@ -87099,10 +88919,10 @@ var require_browser3 = __commonJS({
           text = canvas;
           canvas = void 0;
         }
-        return new Promise(function(resolve18, reject) {
+        return new Promise(function(resolve19, reject) {
           try {
             const data = QRCode2.create(text, opts);
-            resolve18(renderFunc(data, canvas, opts));
+            resolve19(renderFunc(data, canvas, opts));
           } catch (e) {
             reject(e);
           }
@@ -87184,11 +89004,11 @@ var require_server = __commonJS({
     }
     function render(renderFunc, text, params) {
       if (!params.cb) {
-        return new Promise(function(resolve18, reject) {
+        return new Promise(function(resolve19, reject) {
           try {
             const data = QRCode2.create(text, params.opts);
             return renderFunc(data, params.opts, function(err, data2) {
-              return err ? reject(err) : resolve18(data2);
+              return err ? reject(err) : resolve19(data2);
             });
           } catch (e) {
             reject(e);
@@ -87297,7 +89117,7 @@ var init_register_messaging_scripts = __esm({
 
 // ../dashboard/src/github.ts
 function delay(ms) {
-  return new Promise((resolve18) => setTimeout(resolve18, ms));
+  return new Promise((resolve19) => setTimeout(resolve19, ms));
 }
 function normalizeCheckState(state) {
   switch ((state ?? "").toLowerCase()) {
@@ -89848,13 +91668,13 @@ function resolvePaperclipConfig(settings) {
   };
 }
 async function discoverPaperclipCliConfig(opts = {}) {
-  const fs = await import("node:fs/promises");
+  const fs2 = await import("node:fs/promises");
   const path2 = await import("node:path");
   const os3 = await import("node:os");
   const configPath = opts.configPath ?? path2.join(os3.homedir(), ".paperclip", "instances", "default", "config.json");
   let raw;
   try {
-    raw = await fs.readFile(configPath, "utf-8");
+    raw = await fs2.readFile(configPath, "utf-8");
   } catch (error) {
     const code = error.code;
     return {
@@ -90017,7 +91837,7 @@ async function spawnPaperclipCliJson(args, opts) {
   }
   const timeoutMs = opts.cliTimeoutMs ?? 15e3;
   const label = ["paperclipai", ...args].join(" ");
-  return new Promise((resolve18, reject) => {
+  return new Promise((resolve19, reject) => {
     let child;
     try {
       child = spawn10(bin, fullArgs, { stdio: ["ignore", "pipe", "pipe"] });
@@ -90063,7 +91883,7 @@ async function spawnPaperclipCliJson(args, opts) {
         return;
       }
       try {
-        resolve18(JSON.parse(cleaned));
+        resolve19(JSON.parse(cleaned));
       } catch {
         reject(new Error(`${label} returned non-JSON output: ${cleaned.slice(0, 200)}`));
       }
@@ -90132,8 +91952,8 @@ var init_paperclip_client = __esm({
 
 // ../../plugins/fusion-plugin-paperclip-runtime/dist/runtime-adapter.js
 import { randomUUID as randomUUID14 } from "node:crypto";
-function sleep3(ms) {
-  return new Promise((resolve18) => setTimeout(resolve18, ms));
+function sleep4(ms) {
+  return new Promise((resolve19) => setTimeout(resolve19, ms));
 }
 function asString2(value) {
   return typeof value === "string" ? value : void 0;
@@ -90435,7 +92255,7 @@ var init_runtime_adapter3 = __esm({
             this.logger.warn(`Paperclip run ${runId} exceeded local runTimeoutMs=${session.runTimeoutMs}; abandoning poll. Run continues server-side.`);
             break;
           }
-          await sleep3(interval);
+          await sleep4(interval);
           interval = Math.min(interval * 2, session.pollIntervalMaxMs);
         }
         return { text: textBuf, thinking: thinkBuf, runStatus, timedOutLocally };
@@ -94593,7 +96413,7 @@ var init_auth_middleware = __esm({
 
 // ../dashboard/src/server.ts
 import express from "express";
-import { join as join37, dirname as dirname11 } from "node:path";
+import { join as join38, dirname as dirname11 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 function clearAiSessionCleanupInterval() {
   if (!aiSessionCleanupIntervalHandle) {
@@ -94701,7 +96521,7 @@ var init_src4 = __esm({
 });
 
 // src/project-context.ts
-import { resolve as resolve16, dirname as dirname12, basename as basename9 } from "node:path";
+import { resolve as resolve17, dirname as dirname12, basename as basename9 } from "node:path";
 async function resolveProject(projectNameFlag, cwd = process.cwd(), globalDir) {
   const central = new CentralCore(globalDir);
   await central.init();
@@ -94777,9 +96597,9 @@ async function clearDefaultProject(globalDir) {
   await globalStore.updateSettings(rest);
 }
 async function detectProjectFromCwd(cwd, central) {
-  let currentDir = resolve16(cwd);
+  let currentDir = resolve17(cwd);
   while (true) {
-    const kbPath = resolve16(currentDir, ".fusion", "fusion.db");
+    const kbPath = resolve17(currentDir, ".fusion", "fusion.db");
     if (isValidSqliteDatabaseFile(kbPath)) {
       const project = await central.getProjectByPath(currentDir);
       if (project) {
@@ -94883,7 +96703,7 @@ __export(task_exports, {
 });
 import { createInterface as createInterface2 } from "node:readline/promises";
 import { watchFile, unwatchFile, statSync as statSync6, existsSync as existsSync29, readFileSync as readFileSync8 } from "node:fs";
-import { basename as basename10, join as join38 } from "node:path";
+import { basename as basename10, join as join39 } from "node:path";
 function getGitHubIssueUrl(sourceMetadata) {
   if (!sourceMetadata || typeof sourceMetadata !== "object") return void 0;
   const issueUrl = sourceMetadata.issueUrl;
@@ -95047,11 +96867,11 @@ async function runTaskCreate(descriptionArg, attachFiles, depends, projectName,
   console.log(`    Path:   .fusion/tasks/${task.id}/`);
   if (attachFiles && attachFiles.length > 0) {
     const { readFile: readFile19 } = await import("node:fs/promises");
-    const { basename: basename12, extname: extname3, resolve: resolve18 } = await import("node:path");
+    const { basename: basename12, extname: extname4, resolve: resolve19 } = await import("node:path");
     for (const filePath of attachFiles) {
-      const resolvedPath = resolve18(filePath);
+      const resolvedPath = resolve19(filePath);
       const filename = basename12(resolvedPath);
-      const ext = extname3(filename).toLowerCase();
+      const ext = extname4(filename).toLowerCase();
       const mimeType = MIME_TYPES[ext];
       if (!mimeType) {
         console.error(`    \u2717 Unsupported file type: ${ext} (${filename})`);
@@ -95183,7 +97003,7 @@ async function runTaskLogs(id, options = {}, projectName) {
   printEntries(filteredEntries);
   if (options.follow) {
     const projectPath = projectContext?.projectPath ?? process.cwd();
-    const logPath = join38(projectPath, ".fusion", "tasks", id, "agent.log");
+    const logPath = join39(projectPath, ".fusion", "tasks", id, "agent.log");
     if (!existsSync29(logPath)) {
       console.log(`
   Waiting for log file to be created...`);
@@ -95346,11 +97166,11 @@ async function runTaskMerge(id, projectName) {
 }
 async function runTaskAttach(id, filePath, projectName) {
   const { readFile: readFile19 } = await import("node:fs/promises");
-  const { basename: basename12, extname: extname3 } = await import("node:path");
-  const { resolve: resolve18 } = await import("node:path");
-  const resolvedPath = resolve18(filePath);
+  const { basename: basename12, extname: extname4 } = await import("node:path");
+  const { resolve: resolve19 } = await import("node:path");
+  const resolvedPath = resolve19(filePath);
   const filename = basename12(resolvedPath);
-  const ext = extname3(filename).toLowerCase();
+  const ext = extname4(filename).toLowerCase();
   const mimeType = MIME_TYPES[ext];
   if (!mimeType) {
     console.error(`Unsupported file type: ${ext}`);
@@ -95887,12 +97707,12 @@ async function promptText(question) {
   console.log("  (Enter your response. Type DONE on its own line when finished):\n");
   const rl = createInterface2({ input: process.stdin, output: process.stdout });
   const lines = [];
-  return new Promise((resolve18) => {
+  return new Promise((resolve19) => {
     const askLine = () => {
       rl.question("  ").then((line) => {
         if (line.trim() === "DONE") {
           rl.close();
-          resolve18(lines.join("\n"));
+          resolve19(lines.join("\n"));
         } else {
           lines.push(line);
           askLine();
@@ -96297,9 +98117,9 @@ async function runSkillsInstall(args, options) {
     stdio: "inherit",
     shell: true
   });
-  const exitCode = await new Promise((resolve18, reject) => {
+  const exitCode = await new Promise((resolve19, reject) => {
     child.on("exit", (code) => {
-      resolve18(code ?? 1);
+      resolve19(code ?? 1);
     });
     child.on("error", (err) => {
       reject(err);
@@ -96326,7 +98146,7 @@ init_src();
 init_gh_cli();
 import { Type as Type7 } from "typebox";
 import { StringEnum } from "@mariozechner/pi-ai";
-import { resolve as resolve17, basename as basename11, extname as extname2, join as join39 } from "node:path";
+import { resolve as resolve18, basename as basename11, extname as extname3, join as join40 } from "node:path";
 import { readFile as readFile18 } from "node:fs/promises";
 import { existsSync as existsSync30 } from "node:fs";
 import { spawn as spawn9 } from "node:child_process";
@@ -96346,14 +98166,14 @@ var MIME_TYPES2 = {
   ".xml": "application/xml"
 };
 function resolveProjectRoot(cwd) {
-  let current = resolve17(cwd);
+  let current = resolve18(cwd);
   while (true) {
-    if (existsSync30(join39(current, ".fusion"))) {
+    if (existsSync30(join40(current, ".fusion"))) {
       return current;
     }
-    const parent = resolve17(current, "..");
+    const parent = resolve18(current, "..");
     if (parent === current) {
-      return resolve17(cwd);
+      return resolve18(cwd);
     }
     current = parent;
   }
@@ -96369,7 +98189,7 @@ async function getStore2(cwd) {
   return store;
 }
 function getFusionDir(cwd) {
-  return join39(resolveProjectRoot(cwd), ".fusion");
+  return join40(resolveProjectRoot(cwd), ".fusion");
 }
 async function validateAssignableAgentId(cwd, agentId) {
   const { AgentStore: AgentStore2, isEphemeralAgent: isEphemeralAgent2 } = await Promise.resolve().then(() => (init_src(), src_exports));
@@ -96698,9 +98518,9 @@ Column: triage
       path: Type7.String({ description: "Path to the file to attach" })
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-      const filePath = resolve17(ctx.cwd, params.path.replace(/^@/, ""));
+      const filePath = resolve18(ctx.cwd, params.path.replace(/^@/, ""));
       const filename = basename11(filePath);
-      const ext = extname2(filename).toLowerCase();
+      const ext = extname3(filename).toLowerCase();
       const mimeType = MIME_TYPES2[ext];
       if (!mimeType) {
         throw new Error(
@@ -97815,12 +99635,12 @@ Status: ${updated.status}`
       child.stderr?.on("data", (data) => {
         stderr += data.toString();
       });
-      const exitCode = await new Promise((resolve18) => {
+      const exitCode = await new Promise((resolve19) => {
         child.on("exit", (code) => {
-          resolve18(code ?? 1);
+          resolve19(code ?? 1);
         });
         child.on("error", () => {
-          resolve18(1);
+          resolve19(1);
         });
       });
       try {