@runfusion/fusion 0.8.0 → 0.8.2

package/dist/extension.js

@@ -2432,7 +2432,7 @@ var init_db = __esm({
     "use strict";
     init_sqlite_adapter();
     init_types();
-    SCHEMA_VERSION = 50;
+    SCHEMA_VERSION = 51;
     SCHEMA_SQL = `
 -- Tasks table with JSON columns for nested data
 CREATE TABLE IF NOT EXISTS tasks (
@@ -3965,6 +3965,13 @@ CREATE INDEX IF NOT EXISTS idxTodoItemsSortOrder ON todo_items(listId, sortOrder
             this.addColumnIfMissing("tasks", "effectiveNodeSource", "TEXT");
           });
         }
+        if (version < 51) {
+          this.applyMigration(51, () => {
+            if (this.hasTable("chat_messages")) {
+              this.addColumnIfMissing("chat_messages", "attachments", "TEXT");
+            }
+          });
+        }
       }
       /**
        * Run a single migration step inside a transaction and bump the version.
@@ -6477,9 +6484,9 @@ var init_global_settings = __esm({
        * Serialize operations via promise chain to prevent lost-update races.
        */
       withLock(fn) {
-        let resolve17;
+        let resolve19;
         const next = new Promise((r) => {
-          resolve17 = r;
+          resolve19 = r;
         });
         const prev = this.lock;
         this.lock = next;
@@ -6487,7 +6494,7 @@ var init_global_settings = __esm({
           try {
             return await fn();
           } finally {
-            resolve17();
+            resolve19();
           }
         });
       }
@@ -11797,8 +11804,8 @@ import { join as join8, dirname as dirname2 } from "node:path";
 import { fileURLToPath } from "node:url";
 function getAppVersion() {
   if (cachedVersion !== null) return cachedVersion;
-  const __dirname3 = dirname2(fileURLToPath(import.meta.url));
-  let currentDir = __dirname3;
+  const __dirname2 = dirname2(fileURLToPath(import.meta.url));
+  let currentDir = __dirname2;
   for (let i = 0; i < 10; i++) {
     try {
       const pkgPath = join8(currentDir, "package.json");
@@ -27783,9 +27790,9 @@ var init_automation_store = __esm({
        */
       withScheduleLock(id, fn) {
         const prev = this.scheduleLocks.get(id) ?? Promise.resolve();
-        let resolve17;
+        let resolve19;
         const next = new Promise((r) => {
-          resolve17 = r;
+          resolve19 = r;
         });
         this.scheduleLocks.set(id, next);
         return prev.then(async () => {
@@ -27795,7 +27802,7 @@ var init_automation_store = __esm({
             if (this.scheduleLocks.get(id) === next) {
               this.scheduleLocks.delete(id);
             }
-            resolve17();
+            resolve19();
           }
         });
       }
@@ -29583,7 +29590,7 @@ var init_project_memory = __esm({
 // ../core/src/run-command.ts
 import { spawn } from "node:child_process";
 function runCommandAsync(command, options = {}) {
-  return new Promise((resolve17) => {
+  return new Promise((resolve19) => {
     const maxBuffer = options.maxBuffer ?? DEFAULT_MAX_BUFFER;
     let stdout = "";
     let stderr = "";
@@ -29642,7 +29649,7 @@ function runCommandAsync(command, options = {}) {
         clearTimeout(forceKillTimer);
         forceKillTimer = null;
       }
-      resolve17({
+      resolve19({
         stdout,
         stderr,
         exitCode: null,
@@ -29660,7 +29667,7 @@ function runCommandAsync(command, options = {}) {
       }
       signalProcessGroup("SIGTERM");
       scheduleForceKill(NORMAL_CLEANUP_FORCE_KILL_DELAY_MS);
-      resolve17({
+      resolve19({
         stdout,
         stderr,
         exitCode: code,
@@ -30810,9 +30817,9 @@ ${outcome}`;
        * lost-update races on the nextId counter.
        */
       withConfigLock(fn) {
-        let resolve17;
+        let resolve19;
         const next = new Promise((r) => {
-          resolve17 = r;
+          resolve19 = r;
         });
         const prev = this.configLock;
         this.configLock = next;
@@ -30820,7 +30827,7 @@ ${outcome}`;
           try {
             return await fn();
           } finally {
-            resolve17();
+            resolve19();
           }
         });
       }
@@ -30830,9 +30837,9 @@ ${outcome}`;
        */
       withTaskLock(id, fn) {
         const prev = this.taskLocks.get(id) ?? Promise.resolve();
-        let resolve17;
+        let resolve19;
         const next = new Promise((r) => {
-          resolve17 = r;
+          resolve19 = r;
         });
         this.taskLocks.set(id, next);
         return prev.then(async () => {
@@ -30842,7 +30849,7 @@ ${outcome}`;
             if (this.taskLocks.get(id) === next) {
               this.taskLocks.delete(id);
             }
-            resolve17();
+            resolve19();
           }
         });
       }
@@ -32997,7 +33004,7 @@ ${task.description}
               }
             }
           }
-          await new Promise((resolve17) => setImmediate(resolve17));
+          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();
@@ -33017,7 +33024,7 @@ ${task.description}
               this.emit("task:updated", task);
             }
             if (i > 0 && i % 50 === 0) {
-              await new Promise((resolve17) => setImmediate(resolve17));
+              await new Promise((resolve19) => setImmediate(resolve19));
             }
           }
           const elapsed = Date.now() - startTime;
@@ -34843,7 +34850,7 @@ function runGh(args, cwd) {
 }
 function runGhAsync(args, cwdOrOptions) {
   const { cwd, signal: externalSignal, timeoutMs = DEFAULT_GH_TIMEOUT_MS } = normalizeRunGhOptions(cwdOrOptions);
-  return new Promise((resolve17, reject) => {
+  return new Promise((resolve19, reject) => {
     if (externalSignal?.aborted) {
       reject(makeGhError(`gh command aborted: ${describeAbortReason(externalSignal.reason)}`, "ABORT_ERR"));
       return;
@@ -34894,7 +34901,7 @@ function runGhAsync(args, cwdOrOptions) {
           ghError.stderr = stderr ?? "";
           reject(ghError);
         } else {
-          resolve17(stdout ?? "");
+          resolve19(stdout ?? "");
         }
       }
     );
@@ -35182,9 +35189,9 @@ var init_routine_store = __esm({
        */
       withRoutineLock(id, fn) {
         const prev = this.routineLocks.get(id) ?? Promise.resolve();
-        let resolve17;
+        let resolve19;
         const next = new Promise((r) => {
-          resolve17 = r;
+          resolve19 = r;
         });
         this.routineLocks.set(id, next);
         return prev.then(async () => {
@@ -35194,7 +35201,7 @@ var init_routine_store = __esm({
             if (this.routineLocks.get(id) === next) {
               this.routineLocks.delete(id);
             }
-            resolve17();
+            resolve19();
           }
         });
       }
@@ -35793,13 +35800,13 @@ var init_plugin_loader = __esm({
        * Execute a promise with a timeout.
        */
       withTimeout(promise, ms, timeoutMessage) {
-        return new Promise((resolve17, reject) => {
+        return new Promise((resolve19, reject) => {
           const timer = setTimeout(() => {
             reject(new Error(timeoutMessage));
           }, ms);
           promise.then((result) => {
             clearTimeout(timer);
-            resolve17(result);
+            resolve19(result);
           }).catch((err) => {
             clearTimeout(timer);
             reject(err);
@@ -39006,7 +39013,7 @@ var require_get_stream = __commonJS({
       };
       const { maxBuffer } = options;
       let stream;
-      await new Promise((resolve17, reject) => {
+      await new Promise((resolve19, reject) => {
         const rejectPromise = (error) => {
           if (error && stream.getBufferedLength() <= BufferConstants.MAX_LENGTH) {
             error.bufferedData = stream.getBufferedValue();
@@ -39018,7 +39025,7 @@ var require_get_stream = __commonJS({
             rejectPromise(error);
             return;
           }
-          resolve17();
+          resolve19();
         });
         stream.on("data", () => {
           if (stream.getBufferedLength() > maxBuffer) {
@@ -40312,7 +40319,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((resolve17, reject) => {
+        return new Promise((resolve19, reject) => {
           this.zipfile.on("error", (err) => {
             this.canceled = true;
             reject(err);
@@ -40321,7 +40328,7 @@ var require_extract_zip = __commonJS({
           this.zipfile.on("close", () => {
             if (!this.canceled) {
               debug("zip extraction complete");
-              resolve17();
+              resolve19();
             }
           });
           this.zipfile.on("entry", async (entry) => {
@@ -48501,6 +48508,7 @@ var init_chat_store = __esm({
           content: row.content,
           thinkingOutput: row.thinkingOutput ?? null,
           metadata: fromJson(row.metadata) ?? null,
+          attachments: fromJson(row.attachments) ?? void 0,
           createdAt: row.createdAt
         };
       }
@@ -48719,11 +48727,12 @@ var init_chat_store = __esm({
           content: input.content,
           thinkingOutput: input.thinkingOutput ?? null,
           metadata: input.metadata ?? null,
+          attachments: input.attachments,
           createdAt: now
         };
         this.db.prepare(`
-      INSERT INTO chat_messages (id, sessionId, role, content, thinkingOutput, metadata, createdAt)
-      VALUES (?, ?, ?, ?, ?, ?, ?)
+      INSERT INTO chat_messages (id, sessionId, role, content, thinkingOutput, metadata, attachments, createdAt)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
     `).run(
           message.id,
           message.sessionId,
@@ -48731,6 +48740,7 @@ var init_chat_store = __esm({
           message.content,
           message.thinkingOutput,
           toJsonNullable(message.metadata),
+          toJsonNullable(message.attachments),
           message.createdAt
         );
         this.db.prepare("UPDATE chat_sessions SET updatedAt = ? WHERE id = ?").run(now, sessionId);
@@ -48738,6 +48748,28 @@ var init_chat_store = __esm({
         this.emit("chat:message:added", message);
         return message;
       }
+      /**
+       * Append a file attachment metadata record to an existing message.
+       */
+      addMessageAttachment(sessionId, messageId, attachment) {
+        const message = this.getMessage(messageId);
+        if (!message || message.sessionId !== sessionId) {
+          throw new Error(`Message ${messageId} not found in session ${sessionId}`);
+        }
+        const updatedAttachments = [...message.attachments ?? [], attachment];
+        this.db.prepare(`
+      UPDATE chat_messages
+      SET attachments = ?
+      WHERE id = ?
+    `).run(toJsonNullable(updatedAttachments), messageId);
+        const updated = this.getMessage(messageId);
+        if (!updated) {
+          throw new Error(`Failed to update message ${messageId}`);
+        }
+        this.db.bumpLastModified();
+        this.emit("chat:message:updated", updated);
+        return updated;
+      }
       /**
        * Get messages for a chat session with optional filtering.
        *
@@ -50345,12 +50377,12 @@ var init_concurrency = __esm({
           this._active++;
           return Promise.resolve();
         }
-        return new Promise((resolve17) => {
+        return new Promise((resolve19) => {
           this._waiters.push({
             priority,
             resolve: () => {
               this._active++;
-              resolve17();
+              resolve19();
             }
           });
         });
@@ -52771,20 +52803,20 @@ async function withRateLimitRetry(fn, options = {}) {
   throw lastError ?? new Error("withRateLimitRetry: unexpected state");
 }
 function sleep(ms, signal) {
-  return new Promise((resolve17, reject) => {
+  return new Promise((resolve19, reject) => {
     if (signal?.aborted) {
       reject(signal.reason ?? new Error("Aborted"));
       return;
     }
-    const timer = setTimeout(resolve17, 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 = resolve17;
-      resolve17 = () => {
+      const origResolve = resolve19;
+      resolve19 = () => {
         signal.removeEventListener("abort", onAbort);
         origResolve();
       };
@@ -52864,9 +52896,9 @@ async function readAttachmentContents(rootDir, taskId, attachments) {
     return { attachmentContents, imageContents };
   }
   const { readFile: readFile19 } = await import("node:fs/promises");
-  const { join: join39 } = await import("node:path");
+  const { join: join38 } = await import("node:path");
   for (const att of attachments) {
-    const filePath = join39(
+    const filePath = join38(
       rootDir,
       ".fusion",
       "tasks",
@@ -54380,9 +54412,9 @@ Remove or replace these ids and call fn_task_create again.`
             }
             try {
               const { readFile: readFile19 } = await import("node:fs/promises");
-              const { join: join39 } = await import("node:path");
+              const { join: join38 } = await import("node:path");
               const promptContent = await readFile19(
-                join39(rootDir, promptPath),
+                join38(rootDir, promptPath),
                 "utf-8"
               ).catch((err) => {
                 const msg = err instanceof Error ? err.message : String(err);
@@ -54751,7 +54783,7 @@ import { existsSync as existsSync21 } from "node:fs";
 import { join as join26 } from "node:path";
 import { Type as Type3 } from "typebox";
 async function execWithProcessGroup(command, options) {
-  return new Promise((resolve17, reject) => {
+  return new Promise((resolve19, reject) => {
     if (options.signal?.aborted) {
       reject(Object.assign(
         new Error(`Command aborted before start: ${command}`),
@@ -54844,7 +54876,7 @@ async function execWithProcessGroup(command, options) {
         return;
       }
       if (code === 0) {
-        resolve17({ stdout, stderr, bufferOverflow: stdoutOverflow || stderrOverflow });
+        resolve19({ stdout, stderr, bufferOverflow: stdoutOverflow || stderrOverflow });
         return;
       }
       reject(Object.assign(
@@ -55407,21 +55439,31 @@ ${failureContext.output.slice(0, VERIFICATION_LOG_MAX_CHARS)}
     return false;
   }
 }
-async function amendMergeCommitWithFixes(rootDir, taskId, authorArg) {
+function resetMergeWithWarn(rootDir, taskId, label) {
+  try {
+    execSync("git reset --merge", { cwd: rootDir, stdio: "pipe" });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    mergerLog.warn(`${taskId}: git reset --merge cleanup failed during ${label}: ${msg}`);
+  }
+}
+function buildDeterministicMergeMessage(params) {
+  const { taskId, branch, commitLog, includeTaskId } = params;
+  const prefix = includeTaskId ? `feat(${taskId})` : "feat";
+  const subject = `${prefix}: merge ${branch}`;
+  const body = commitLog && commitLog.trim().length > 0 ? commitLog.trim() : `- merge ${branch}`;
+  const escape = (s) => s.replace(/(["\\$`])/g, "\\$1");
+  return {
+    subjectArg: `-m "${escape(subject)}"`,
+    bodyArg: `-m "${escape(body)}"`
+  };
+}
+async function commitOrAmendMergeWithFixes(rootDir, taskId, branch, commitLog, includeTaskId, preAttemptHeadSha, authorArg) {
   try {
-    const { stdout: stagedFiles } = await execAsync2("git diff --cached --name-only", {
-      cwd: rootDir,
-      encoding: "utf-8"
-    });
     const { stdout: unstagedFiles } = await execAsync2("git diff --name-only", {
       cwd: rootDir,
       encoding: "utf-8"
     });
-    const hasChanges = stagedFiles.trim().length > 0 || unstagedFiles.trim().length > 0;
-    if (!hasChanges) {
-      mergerLog.log(`${taskId}: no changes to amend after verification fix`);
-      return false;
-    }
     if (unstagedFiles.trim().length > 0) {
       await execAsync2("git add -A", { cwd: rootDir });
     }
@@ -55429,12 +55471,10 @@ async function amendMergeCommitWithFixes(rootDir, taskId, authorArg) {
       cwd: rootDir,
       encoding: "utf-8"
     });
-    const gitlinkPaths = [];
     for (const line of staged.split("\n")) {
       const match = line.match(/^:\d{6} 160000 [^\t]+\t(.+)$/);
-      if (match) gitlinkPaths.push(match[1]);
-    }
-    for (const path2 of gitlinkPaths) {
+      if (!match) continue;
+      const path2 = match[1];
       mergerLog.warn(`${taskId}: refusing to stage gitlink "${path2}" (project uses no submodules \u2014 likely a nested worktree). Unstaging.`);
       try {
         await execAsync2(`git reset HEAD -- "${path2}"`, { cwd: rootDir });
@@ -55447,15 +55487,43 @@ async function amendMergeCommitWithFixes(rootDir, taskId, authorArg) {
       cwd: rootDir,
       encoding: "utf-8"
     });
-    if (finalStaged.trim().length > 0) {
-      await execAsync2(`git commit --amend --no-edit${authorArg}`, { cwd: rootDir });
-      mergerLog.log(`${taskId}: amended merge commit with verification fixes`);
+    const hasStaged = finalStaged.trim().length > 0;
+    const { stdout: currentHeadOut } = await execAsync2("git rev-parse HEAD", {
+      cwd: rootDir,
+      encoding: "utf-8"
+    });
+    const currentHead = currentHeadOut.trim();
+    const headMoved = currentHead !== preAttemptHeadSha;
+    if (!hasStaged && !headMoved) {
+      mergerLog.warn(
+        `${taskId}: refusing to record merge \u2014 no commit was created and no changes are staged. This usually means the AI agent never ran git commit and the in-merge fix had nothing to add.`
+      );
+      return false;
+    }
+    const { subjectArg, bodyArg } = buildDeterministicMergeMessage({
+      taskId,
+      branch,
+      commitLog,
+      includeTaskId
+    });
+    const trailerArg = buildTaskIdTrailerArg(taskId);
+    if (!headMoved) {
+      await execAsync2(
+        `git commit ${subjectArg} ${bodyArg}${trailerArg}${authorArg}`,
+        { cwd: rootDir }
+      );
+      mergerLog.log(`${taskId}: created fresh merge commit after verification fix (no prior commit to amend)`);
       return true;
     }
-    return false;
+    await execAsync2(
+      `git commit --amend ${subjectArg} ${bodyArg}${trailerArg}${authorArg}`,
+      { cwd: rootDir }
+    );
+    mergerLog.log(`${taskId}: amended merge commit with verification fixes (deterministic message)`);
+    return true;
   } catch (err) {
     const errorMessage = err instanceof Error ? err.message : String(err);
-    mergerLog.warn(`${taskId}: failed to amend merge commit: ${errorMessage}`);
+    mergerLog.warn(`${taskId}: failed to finalize merge commit: ${errorMessage}`);
     return false;
   }
 }
@@ -55706,6 +55774,11 @@ function getCommitAuthorArg(settings) {
   const email = settings.commitAuthorEmail || "noreply@runfusion.ai";
   return ` --author="${name} <${email}>"`;
 }
+function buildSourceIssueRef(sourceIssue) {
+  if (!sourceIssue || sourceIssue.provider !== "github") return "";
+  if (!sourceIssue.repository || !sourceIssue.issueNumber) return "";
+  return `${sourceIssue.repository}#${sourceIssue.issueNumber}`;
+}
 function buildMergeSystemPrompt(includeTaskId, agentPrompts, authorArg) {
   const commitFormat = includeTaskId ? `\`\`\`
 git commit -m "<type>(<scope>): <summary>" -m "<body>"${authorArg || ""}
@@ -55716,6 +55789,7 @@ Message format:
 - **Scope:** the task ID (e.g., KB-001)
 - **Summary:** one line describing what the squash brings in (imperative mood)
 - **Body:** 2-5 bullet points summarizing the key changes, each starting with "- "
+- **GitHub reference:** when the prompt includes a source issue reference, add \`Ref: owner/repo#N\` to the commit body
 ${authorArg ? `- **Author:** Always include the --author flag as shown in the example above.` : ""}
 
 Example:
@@ -55733,6 +55807,7 @@ Message format:
 - **Type:** feat, fix, refactor, docs, test, chore
 - **Summary:** one line describing what the squash brings in (imperative mood)
 - **Body:** 2-5 bullet points summarizing the key changes, each starting with "- "
+- **GitHub reference:** when the prompt includes a source issue reference, add \`Ref: owner/repo#N\` to the commit body
 ${authorArg ? `- **Author:** Always include the --author flag as shown in the example above.` : ""}
 Do NOT include a scope in the commit message type.
 
@@ -56116,6 +56191,7 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
     throw new Error(`Cannot merge ${taskId}: ${mergeBlocker}`);
   }
   const branch = task.branch || `fusion/${taskId.toLowerCase()}`;
+  const sourceIssueRef = buildSourceIssueRef(task.sourceIssue);
   const worktreePath = task.worktree;
   const result = {
     task,
@@ -56419,6 +56495,17 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
       void 0,
       "merger"
     );
+    let preAttemptHeadSha = "";
+    try {
+      const { stdout } = await execAsync2("git rev-parse HEAD", {
+        cwd: rootDir,
+        encoding: "utf-8"
+      });
+      preAttemptHeadSha = stdout.trim();
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      mergerLog.warn(`${taskId}: failed to capture pre-attempt HEAD (${msg}) \u2014 verification-fix finalizer will fall back to amend`);
+    }
     try {
       const success = await executeMergeAttempt({
         store,
@@ -56428,6 +56515,7 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
         commitLog,
         diffStat,
         includeTaskId,
+        sourceIssueRef,
         smartConflictResolution,
         mergeConflictStrategy,
         attemptNum,
@@ -56536,12 +56624,27 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
             }
             if (fixSuccess) {
               const authorArg = getCommitAuthorArg(settings);
-              await amendMergeCommitWithFixes(rootDir, taskId, authorArg);
+              const finalized = await commitOrAmendMergeWithFixes(
+                rootDir,
+                taskId,
+                branch,
+                commitLog,
+                includeTaskId,
+                preAttemptHeadSha,
+                authorArg
+              );
+              if (!finalized) {
+                resetMergeWithWarn(rootDir, taskId, "verification-fix finalize");
+                throw new Error(
+                  `${taskId}: verification fix succeeded but no merge commit could be created \u2014 refusing to mark merge complete.`
+                );
+              }
               return true;
             }
           }
         }
         mergerLog.error(`${taskId}: deterministic verification failed \u2014 aborting merge (in-merge fix exhausted or disabled)`);
+        resetMergeWithWarn(rootDir, taskId, "deterministic-verification rollback");
         throw error;
       }
       if (error.message?.includes("Build verification failed")) {
@@ -56612,7 +56715,21 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
           }
           if (fixSuccess) {
             const authorArg = getCommitAuthorArg(settings);
-            await amendMergeCommitWithFixes(rootDir, taskId, authorArg);
+            const finalized = await commitOrAmendMergeWithFixes(
+              rootDir,
+              taskId,
+              branch,
+              commitLog,
+              includeTaskId,
+              preAttemptHeadSha,
+              authorArg
+            );
+            if (!finalized) {
+              resetMergeWithWarn(rootDir, taskId, "build-verification fix finalize");
+              throw new Error(
+                `${taskId}: build verification fix succeeded but no merge commit could be created \u2014 refusing to mark merge complete.`
+              );
+            }
             return true;
           }
         }
@@ -56626,10 +56743,11 @@ async function aiMergeTask(store, rootDir, taskId, options = {}) {
             await audit.git({ type: "reset:hard", target: branch, metadata: { purpose: "build-retry" } });
           } catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
-            mergerLog.warn(`${taskId}: git reset --merge cleanup failed (build-retry): ${msg}`);
+            mergerLog.warn(`${taskId}: git reset --merge cleanup failed during build-verification rollback (build-retry): ${msg}`);
           }
           return false;
         }
+        resetMergeWithWarn(rootDir, taskId, "build-verification rollback (no retries left)");
         throw error;
       }
       if (error.name === "MergeNonConflictError") {
@@ -56977,6 +57095,7 @@ async function executeMergeAttempt(params, aiTracker) {
     commitLog,
     diffStat,
     includeTaskId,
+    sourceIssueRef,
     smartConflictResolution,
     attemptNum,
     options,
@@ -57167,19 +57286,12 @@ async function executeMergeAttempt(params, aiTracker) {
       simplifiedContext: attemptNum === 2,
       options,
       testCommand,
-      buildCommand: buildCommand2
+      buildCommand: buildCommand2,
+      sourceIssueRef
     });
     if (!agentResult.success) {
       const errorMessage = agentResult.error || "Build verification failed";
       await store.logEntry(taskId, "Build verification failed during merge", errorMessage);
-      try {
-        execSync("git reset --merge", { cwd: rootDir, stdio: "pipe" });
-      } catch (resetErr) {
-        const msg = resetErr instanceof Error ? resetErr.message : String(resetErr);
-        mergerLog.warn(
-          `${taskId}: git reset --merge cleanup failed during build-verification rollback (build-verification reset, build-retry): ${msg}`
-        );
-      }
       throw new Error(`Build verification failed for ${taskId}: ${errorMessage}`);
     }
     if (testCommand || buildCommand2) {
@@ -57195,6 +57307,24 @@ async function executeMergeAttempt(params, aiTracker) {
         options.signal
       );
     }
+    try {
+      const authorArg = getCommitAuthorArg(params.settings);
+      const { subjectArg, bodyArg } = buildDeterministicMergeMessage({
+        taskId,
+        branch,
+        commitLog,
+        includeTaskId
+      });
+      const trailerArg = buildTaskIdTrailerArg(taskId);
+      await execAsync2(
+        `git commit --amend ${subjectArg} ${bodyArg}${trailerArg}${authorArg}`,
+        { cwd: rootDir }
+      );
+      mergerLog.log(`${taskId}: rewrote AI-authored merge commit message with deterministic body`);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      mergerLog.warn(`${taskId}: failed to canonicalize merge commit message (${msg}) \u2014 keeping AI-written message`);
+    }
     return true;
   } catch (error) {
     if (error instanceof Error && error.name === "MergeAbortedError") {
@@ -57217,7 +57347,7 @@ async function executeMergeAttempt(params, aiTracker) {
   }
 }
 async function attemptWithSideStrategy(params, side = "theirs", aiTracker) {
-  const { rootDir, branch, commitLog, includeTaskId, taskId, store, settings, testCommand, buildCommand: buildCommand2, testSource, buildSource } = params;
+  const { rootDir, branch, commitLog, includeTaskId, sourceIssueRef, taskId, store, settings, testCommand, buildCommand: buildCommand2, testSource, buildSource } = params;
   mergerLog.log(`${taskId}: attempting merge with -X ${side} strategy`);
   try {
     throwIfAborted(params.options.signal, taskId);
@@ -57258,8 +57388,9 @@ async function attemptWithSideStrategy(params, side = "theirs", aiTracker) {
     const fallbackPrefix = includeTaskId ? `feat(${taskId})` : "feat";
     const authorArg = getCommitAuthorArg(settings);
     const trailerArg = buildTaskIdTrailerArg(taskId);
+    const issueRefBodyArg = sourceIssueRef ? ` -m "Ref: ${sourceIssueRef}"` : "";
     await execAsync2(
-      `git commit -m "${fallbackPrefix}: merge ${branch} (auto-resolved)" -m "${escapedLog}"${trailerArg}${authorArg}`,
+      `git commit -m "${fallbackPrefix}: merge ${branch} (auto-resolved)" -m "${escapedLog}"${issueRefBodyArg}${trailerArg}${authorArg}`,
       { cwd: rootDir }
     );
     mergerLog.log(`${taskId}: committed with -X ${side} auto-resolution`);
@@ -57296,6 +57427,7 @@ async function runAiAgentForCommit(params) {
     includeTaskId,
     hasConflicts,
     simplifiedContext,
+    sourceIssueRef,
     options,
     testCommand,
     buildCommand: buildCommand2
@@ -57394,7 +57526,8 @@ async function runAiAgentForCommit(params) {
       simplifiedContext,
       testCommand,
       buildCommand: buildCommand2,
-      authorArg
+      authorArg,
+      sourceIssueRef
     });
     mergerLog.log(`${taskId}: starting fresh merge agent session`);
     try {
@@ -57426,7 +57559,8 @@ async function runAiAgentForCommit(params) {
           // Also skip detailed context
           testCommand,
           buildCommand: buildCommand2,
-          authorArg
+          authorArg,
+          sourceIssueRef
         });
         try {
           await withRateLimitRetry(async () => {
@@ -57468,8 +57602,9 @@ async function runAiAgentForCommit(params) {
         const fallbackPrefix = includeTaskId ? `feat(${taskId})` : "feat";
         const authorArg2 = getCommitAuthorArg(settings);
         const trailerArg = buildTaskIdTrailerArg(taskId);
+        const issueRefBodyArg = sourceIssueRef ? ` -m "Ref: ${sourceIssueRef}"` : "";
         await execAsync2(
-          `git commit -m "${fallbackPrefix}: merge ${branch}" -m "${escapedLog}"${trailerArg}${authorArg2}`,
+          `git commit -m "${fallbackPrefix}: merge ${branch}" -m "${escapedLog}"${issueRefBodyArg}${trailerArg}${authorArg2}`,
           { cwd: rootDir }
         );
       } else {
@@ -57492,7 +57627,7 @@ async function runAiAgentForCommit(params) {
   }
 }
 function buildMergePrompt(params) {
-  const { taskId, branch, commitLog, diffStat, hasConflicts, simplifiedContext, testCommand, buildCommand: buildCommand2, authorArg } = params;
+  const { taskId, branch, commitLog, diffStat, hasConflicts, simplifiedContext, sourceIssueRef, testCommand, buildCommand: buildCommand2, authorArg } = params;
   const truncatedCommitLog = truncateWithEllipsis(commitLog, MERGE_COMMIT_LOG_MAX_CHARS);
   const truncatedDiffStat = truncateWithEllipsis(diffStat, MERGE_DIFF_STAT_MAX_CHARS);
   const parts = [
@@ -57528,6 +57663,13 @@ function buildMergePrompt(params) {
       `Write and run the \`git commit\` command with a good message summarizing the work.${authorArg ? ` Be sure to include \`${authorArg.trim()}\` in the commit command.` : ""}`
     );
   }
+  if (sourceIssueRef) {
+    parts.push(
+      "",
+      "Include this in the commit message body:",
+      `- Ref: ${sourceIssueRef}`
+    );
+  }
   if (testCommand) {
     parts.push(
       "",
@@ -58703,7 +58845,7 @@ function resolveExecutorModelPair(taskModelProvider, taskModelId, settings) {
   return { provider: void 0, modelId: void 0 };
 }
 function sleep2(ms) {
-  return new Promise((resolve17) => setTimeout(resolve17, 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({
@@ -59451,6 +59593,7 @@ function buildExecutionPrompt(task, rootDir, settings, worktreePath) {
   const reviewMatch = prompt.match(/##\s*Review Level[:\s]*(\d)/);
   const reviewLevel = reviewMatch ? parseInt(reviewMatch[1], 10) : 0;
   const authorArg = settings?.commitAuthorEnabled !== false ? ` --author="${settings?.commitAuthorName || "Fusion"} <${settings?.commitAuthorEmail || "noreply@runfusion.ai"}>"` : "";
+  const sourceIssueRef = task.sourceIssue?.provider === "github" && task.sourceIssue.repository && task.sourceIssue.issueNumber ? `${task.sourceIssue.repository}#${task.sourceIssue.issueNumber}` : "";
   const hasProgress = task.steps.length > 0 && task.steps.some((s) => s.status !== "pending");
   let progressSection = "";
   if (hasProgress) {
@@ -59553,7 +59696,7 @@ ${hasProgress ? `Resume from Step ${task.currentStep}. Do NOT redo completed ste
 Use \`fn_task_update\` to report progress on every step transition.
 Use \`fn_task_log\` for important actions and decisions.
 Use \`fn_task_create\` for truly separate follow-up work, not for fixes required to get tests, build, or typecheck back to green.
-Commit at step boundaries: \`git commit -m "feat(${task.id}): complete Step N \u2014 description"${authorArg}\`
+Commit at step boundaries: \`git commit -m "feat(${task.id}): complete Step N \u2014 description"${sourceIssueRef ? ` -m "Ref: ${sourceIssueRef}"` : ""}${authorArg}\`
 When all steps are complete: call \`fn_task_done()\`
 
 If a build command is configured, run that exact command in this worktree before calling \`fn_task_done()\`.
@@ -59586,7 +59729,7 @@ function detectReviewHandoffIntent(commentText) {
   ];
   return handoffPhrases.some((phrase) => text.includes(phrase));
 }
-var execAsync5, STEP_STATUSES, MAX_WORKFLOW_STEP_RETRIES, MAX_TASK_DONE_SESSION_RETRIES, MAX_TASK_DONE_REQUEUE_RETRIES, WORKFLOW_SCRIPT_OUTPUT_MAX_CHARS2, NonRetryableWorktreeError, taskUpdateParams, taskAddDepParams, spawnAgentParams, reviewStepParams, EXECUTOR_SYSTEM_PROMPT, TaskExecutor;
+var execAsync5, STEP_STATUSES, MAX_WORKFLOW_STEP_RETRIES, MAX_TASK_DONE_SESSION_RETRIES, MAX_TASK_DONE_REQUEUE_RETRIES, COMPLETED_TASK_WATCHDOG_MS, WORKFLOW_RERUN_WATCHDOG_MS, WORKFLOW_SCRIPT_OUTPUT_MAX_CHARS2, NonRetryableWorktreeError, taskUpdateParams, taskAddDepParams, spawnAgentParams, reviewStepParams, EXECUTOR_SYSTEM_PROMPT, TaskExecutor;
 var init_executor = __esm({
   "../engine/src/executor.ts"() {
     "use strict";
@@ -59622,6 +59765,8 @@ var init_executor = __esm({
     MAX_WORKFLOW_STEP_RETRIES = 3;
     MAX_TASK_DONE_SESSION_RETRIES = 3;
     MAX_TASK_DONE_REQUEUE_RETRIES = 3;
+    COMPLETED_TASK_WATCHDOG_MS = 6e4;
+    WORKFLOW_RERUN_WATCHDOG_MS = 15e3;
     WORKFLOW_SCRIPT_OUTPUT_MAX_CHARS2 = 4e3;
     NonRetryableWorktreeError = class extends Error {
     };
@@ -59739,6 +59884,7 @@ If the task's PROMPT.md includes a "Documentation Requirements" section listing
 ## Git discipline
 - Commit after completing each step (not after every file change)
 - Use conventional commit messages prefixed with the task ID
+- When the task has a GitHub issue reference, include \`Ref: owner/repo#N\` in the commit body
 - Do NOT commit broken or half-implemented code
 
 ## Worktree Boundaries
@@ -59831,6 +59977,7 @@ Lint, tests, and typecheck are also hard quality gates:
         store.on("task:moved", ({ task, from, to }) => {
           executorLog.log(`[event:task:moved] ${task.id}: ${from} \u2192 ${to}`);
           if (to === "in-progress") {
+            this.clearWorkflowRerunWatchdog(task.id);
             executorLog.log(`[event:task:moved] Initiating execute() for ${task.id}`);
             void (async () => {
               const taskForExecution = await this.resetMergeStateIfNeeded(task, from);
@@ -59839,6 +59986,7 @@ Lint, tests, and typecheck are also hard quality gates:
               (err) => executorLog.error(`Failed to start ${task.id}:`, err)
             );
           } else if (from === "in-progress") {
+            this.clearCompletedTaskWatchdog(task.id);
             if (this.activeSessions.has(task.id)) {
               executorLog.log(`${task.id} moved from in-progress to ${to} \u2014 terminating agent session`);
               this.pausedAborted.add(task.id);
@@ -60030,6 +60178,10 @@ Lint, tests, and typecheck are also hard quality gates:
       spawnedAgents = /* @__PURE__ */ new Map();
       /** Per-task baseline of session stats used for delta persistence across repeated updates. */
       tokenUsageBaselines = /* @__PURE__ */ new Map();
+      /** One-shot watchdogs for completed tasks that should have transitioned to in-review. */
+      completedTaskWatchdogs = /* @__PURE__ */ new Map();
+      /** One-shot watchdogs for workflow reruns that should have bounced back to in-progress. */
+      workflowRerunWatchdogs = /* @__PURE__ */ new Map();
       async finalizeAlreadyReviewedTask(taskId) {
         const latestTask = await this.store.getTask(taskId);
         if (!latestTask || latestTask.column !== "in-review") {
@@ -60185,6 +60337,120 @@ Lint, tests, and typecheck are also hard quality gates:
           await this.store.updateTask(task.id, updates);
         }
       }
+      clearCompletedTaskWatchdog(taskId) {
+        const handle = this.completedTaskWatchdogs.get(taskId);
+        if (!handle) return;
+        clearTimeout(handle);
+        this.completedTaskWatchdogs.delete(taskId);
+      }
+      clearWorkflowRerunWatchdog(taskId) {
+        const handle = this.workflowRerunWatchdogs.get(taskId);
+        if (!handle) return;
+        clearTimeout(handle);
+        this.workflowRerunWatchdogs.delete(taskId);
+      }
+      scheduleCompletedTaskWatchdog(taskId, trigger) {
+        this.clearCompletedTaskWatchdog(taskId);
+        const handle = setTimeout(async () => {
+          this.completedTaskWatchdogs.delete(taskId);
+          let currentTask = null;
+          try {
+            currentTask = await this.store.getTask(taskId);
+          } catch (err) {
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            executorLog.warn(`${taskId}: completed-task watchdog could not read latest task state: ${errorMessage}`);
+            return;
+          }
+          if (!currentTask || currentTask.column !== "in-progress" || currentTask.paused) {
+            return;
+          }
+          if (this.activeSessions.has(taskId) || this.activeStepExecutors.has(taskId) || this.recoveringCompleted.has(taskId)) {
+            return;
+          }
+          if (!this.isTaskWorkComplete(currentTask)) {
+            return;
+          }
+          executorLog.warn(
+            `${taskId}: completed-task watchdog fired after ${COMPLETED_TASK_WATCHDOG_MS / 1e3}s (${trigger}) \u2014 attempting direct recovery to in-review`
+          );
+          await this.store.logEntry(
+            taskId,
+            `Watchdog: task remained in-progress ${COMPLETED_TASK_WATCHDOG_MS / 1e3}s after ${trigger} \u2014 attempting direct recovery to in-review`
+          ).catch(() => void 0);
+          this.recoveringCompleted.add(taskId);
+          try {
+            const recovered = await this.recoverCompletedTask(currentTask);
+            if (!recovered) {
+              await this.store.logEntry(
+                taskId,
+                "Watchdog recovery attempt could not finalize completed task \u2014 leaving for follow-up recovery"
+              ).catch(() => void 0);
+            }
+          } finally {
+            this.recoveringCompleted.delete(taskId);
+          }
+        }, COMPLETED_TASK_WATCHDOG_MS);
+        this.completedTaskWatchdogs.set(taskId, handle);
+      }
+      async performWorkflowRerunBounce(taskId, worktreePath) {
+        const latestTask = await this.store.getTask(taskId);
+        if (!latestTask) {
+          throw new Error("task missing during workflow rerun bounce");
+        }
+        if (latestTask.column === "in-progress") {
+          await this.store.moveTask(taskId, "todo");
+          await this.store.updateTask(taskId, { worktree: worktreePath });
+          await this.store.moveTask(taskId, "in-progress");
+          return;
+        }
+        if (latestTask.column === "todo") {
+          await this.store.updateTask(taskId, { worktree: worktreePath });
+          await this.store.moveTask(taskId, "in-progress");
+          return;
+        }
+        throw new Error(`task is in '${latestTask.column}', cannot bounce to in-progress`);
+      }
+      scheduleWorkflowRerun(taskId, worktreePath, successMessage) {
+        this.clearWorkflowRerunWatchdog(taskId);
+        setTimeout(async () => {
+          try {
+            await this.performWorkflowRerunBounce(taskId, worktreePath);
+            executorLog.log(successMessage);
+          } catch (err) {
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            executorLog.error(`${taskId}: failed to schedule rerun bounce: ${errorMessage}`);
+          }
+        }, 0);
+        const watchdog = setTimeout(async () => {
+          this.workflowRerunWatchdogs.delete(taskId);
+          let currentTask = null;
+          try {
+            currentTask = await this.store.getTask(taskId);
+          } catch (err) {
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            executorLog.warn(`${taskId}: workflow rerun watchdog could not read latest task state: ${errorMessage}`);
+            return;
+          }
+          if (!currentTask || currentTask.paused || currentTask.column === "in-progress") {
+            return;
+          }
+          executorLog.warn(
+            `${taskId}: workflow rerun watchdog fired after ${WORKFLOW_RERUN_WATCHDOG_MS / 1e3}s \u2014 task is still ${currentTask.column}; retrying handoff once`
+          );
+          await this.store.logEntry(
+            taskId,
+            `Watchdog: workflow rerun handoff stalled for ${WORKFLOW_RERUN_WATCHDOG_MS / 1e3}s (still ${currentTask.column}) \u2014 retrying once`
+          ).catch(() => void 0);
+          try {
+            await this.performWorkflowRerunBounce(taskId, worktreePath);
+            executorLog.warn(`${taskId}: workflow rerun watchdog retry succeeded`);
+          } catch (err) {
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            executorLog.error(`${taskId}: workflow rerun watchdog retry failed: ${errorMessage}`);
+          }
+        }, WORKFLOW_RERUN_WATCHDOG_MS);
+        this.workflowRerunWatchdogs.set(taskId, watchdog);
+      }
       async shouldFinalizeCompletedTask(taskId, taskDone) {
         const task = await this.store.getTask(taskId);
         const completionBlocker = await this.getTaskCompletionBlocker(task);
@@ -60318,6 +60584,7 @@ Lint, tests, and typecheck are also hard quality gates:
           }
           await this.persistTokenUsage(task.id);
           await this.store.moveTask(task.id, "in-review");
+          this.clearCompletedTaskWatchdog(task.id);
           await this.store.logEntry(task.id, "Auto-recovered: task work was complete but stuck in in-progress \u2014 moved to in-review");
           executorLog.log(`\u2713 ${task.id} auto-recovered completed task \u2192 in-review`);
           this.options.onComplete?.(task);
@@ -60814,6 +61081,7 @@ Lint, tests, and typecheck are also hard quality gates:
                   executorLog.log(`${task.id}: captured ${modifiedFiles.length} modified files`);
                   await audit.filesystem({ type: "file:capture-modified", target: task.id, metadata: { files: modifiedFiles } });
                 }
+                this.scheduleCompletedTaskWatchdog(task.id, "step-session completion");
                 if (executionMode !== "fast") {
                   const workflowResult = await this.runWorkflowSteps(task, worktreePath, settings);
                   if (!workflowResult.allPassed) {
@@ -60834,6 +61102,7 @@ Lint, tests, and typecheck are also hard quality gates:
                 }
                 await this.store.updateTask(task.id, { workflowStepRetries: void 0, taskDoneRetryCount: null });
                 await this.store.moveTask(task.id, "in-review");
+                this.clearCompletedTaskWatchdog(task.id);
                 await audit.database({ type: "task:move", target: task.id, metadata: { to: "in-review" } });
                 executorLog.log(`\u2713 ${task.id} completed (step-session) \u2192 in-review`);
                 this.options.onComplete?.(task);
@@ -61170,6 +61439,7 @@ Lint, tests, and typecheck are also hard quality gates:
                   await this.store.logEntry(task.id, "Execution paused after completion \u2014 finalizing to in-review");
                   await this.persistTokenUsage(task.id);
                   await this.store.moveTask(task.id, "in-review");
+                  this.clearCompletedTaskWatchdog(task.id);
                   this.options.onComplete?.(task);
                 } else {
                   executorLog.log(`${task.id} paused (graceful session exit) \u2014 moving to todo`);
@@ -61190,6 +61460,7 @@ Lint, tests, and typecheck are also hard quality gates:
                   taskDone = true;
                   executorLog.log(`${task.id} all steps done \u2014 treating as implicit fn_task_done`);
                   await this.store.logEntry(task.id, "All steps complete \u2014 implicit fn_task_done (agent did not call tool explicitly)", void 0, this.currentRunContext);
+                  this.scheduleCompletedTaskWatchdog(task.id, "implicit fn_task_done");
                 }
               }
               if (taskDone) {
@@ -61199,6 +61470,7 @@ Lint, tests, and typecheck are also hard quality gates:
                   await this.store.updateTask(task.id, { modifiedFiles });
                   executorLog.log(`${task.id}: captured ${modifiedFiles.length} modified files`);
                 }
+                this.scheduleCompletedTaskWatchdog(task.id, "task completion");
                 if (executionMode !== "fast") {
                   const workflowResult = await this.runWorkflowSteps(task, worktreePath, settings);
                   if (!workflowResult.allPassed) {
@@ -61220,6 +61492,7 @@ Lint, tests, and typecheck are also hard quality gates:
                 await this.store.updateTask(task.id, { workflowStepRetries: void 0, taskDoneRetryCount: null });
                 await this.persistTokenUsage(task.id);
                 await this.store.moveTask(task.id, "in-review");
+                this.clearCompletedTaskWatchdog(task.id);
                 executorLog.log(`\u2713 ${task.id} completed \u2192 in-review`);
                 this.options.onComplete?.(task);
               } else {
@@ -61293,6 +61566,7 @@ Lint, tests, and typecheck are also hard quality gates:
                       taskDone = true;
                       executorLog.log(`${task.id} all steps done \u2014 treating as implicit fn_task_done`);
                       await this.store.logEntry(task.id, "All steps complete \u2014 implicit fn_task_done (agent did not call tool explicitly)", void 0, this.currentRunContext);
+                      this.scheduleCompletedTaskWatchdog(task.id, "implicit fn_task_done");
                     }
                   }
                 }
@@ -61303,6 +61577,7 @@ Lint, tests, and typecheck are also hard quality gates:
                     await this.store.updateTask(task.id, { modifiedFiles });
                     executorLog.log(`${task.id}: captured ${modifiedFiles.length} modified files`);
                   }
+                  this.scheduleCompletedTaskWatchdog(task.id, "task completion retry");
                   if (executionMode !== "fast") {
                     const workflowResult = await this.runWorkflowSteps(task, worktreePath, settings);
                     if (!workflowResult.allPassed) {
@@ -61320,6 +61595,7 @@ Lint, tests, and typecheck are also hard quality gates:
                   await this.store.updateTask(task.id, { workflowStepRetries: void 0, taskDoneRetryCount: null });
                   await this.persistTokenUsage(task.id);
                   await this.store.moveTask(task.id, "in-review");
+                  this.clearCompletedTaskWatchdog(task.id);
                   executorLog.log(`\u2713 ${task.id} completed on retry \u2192 in-review`);
                   this.options.onComplete?.(task);
                 } else {
@@ -61747,6 +62023,7 @@ Lint, tests, and typecheck are also hard quality gates:
               await store.updateTask(taskId, { summary: params.summary });
             }
             await store.logEntry(taskId, "Task marked done by agent");
+            this.scheduleCompletedTaskWatchdog(taskId, "fn_task_done");
             const successMessage = params.summary ? "Task marked complete with summary. All steps done. Moving to in-review." : "Task marked complete. All steps done. Moving to in-review.";
             return {
               content: [{ type: "text", text: successMessage }],
@@ -61973,6 +62250,7 @@ Take a different approach. Do NOT repeat the rejected strategy. Re-read the step
        */
       async handleWorkflowRevisionRequest(task, worktreePath, feedback, stepName) {
         executorLog.log(`${task.id}: workflow revision requested by step "${stepName}"`);
+        this.clearCompletedTaskWatchdog(task.id);
         const updatedTask = await this.store.getTask(task.id);
         const reopen = await this.reopenLastStepForRevision(task.id, updatedTask);
         const reopenSummary = reopen ? `re-opening Step ${reopen.index + 1} ("${reopen.name}") for in-place fix` : "no step to re-open (none were completed)";
@@ -61987,21 +62265,11 @@ Take a different approach. Do NOT repeat the rejected strategy. Re-read the step
           sessionFile: null
         });
         executorLog.log(`${task.id}: scheduling fresh execution after revision request`);
-        setTimeout(async () => {
-          try {
-            await this.store.moveTask(task.id, "todo");
-            await this.store.updateTask(task.id, { worktree: worktreePath });
-            await this.store.moveTask(task.id, "in-progress");
-            executorLog.log(`${task.id}: revision rerun scheduled \u2014 moved to todo then in-progress`);
-          } catch (err) {
-            const errorMessage = err instanceof Error ? err.message : String(err);
-            executorLog.error(`${task.id}: failed to schedule revision rerun: ${errorMessage}`);
-            await this.store.logEntry(
-              task.id,
-              "Workflow revision requested \u2014 executor ready for fresh execution"
-            );
-          }
-        }, 0);
+        this.scheduleWorkflowRerun(
+          task.id,
+          worktreePath,
+          `${task.id}: revision rerun scheduled \u2014 moved to todo then in-progress`
+        );
       }
       /**
        * Re-open the last non-pending step so a revision/failure handler gives the
@@ -62088,6 +62356,7 @@ ${feedback}
        * @returns true if a retry was scheduled, false if retries are exhausted
        */
       async handleWorkflowStepFailure(task, worktreePath, failureFeedback, stepName) {
+        this.clearCompletedTaskWatchdog(task.id);
         const currentRetries = task.workflowStepRetries ?? 0;
         if (currentRetries >= MAX_WORKFLOW_STEP_RETRIES) {
           executorLog.warn(`${task.id}: workflow step "${stepName}" failed \u2014 retries exhausted (${MAX_WORKFLOW_STEP_RETRIES}/${MAX_WORKFLOW_STEP_RETRIES})`);
@@ -62106,21 +62375,11 @@ ${feedback}
           sessionFile: null
         });
         executorLog.log(`${task.id}: scheduling fresh execution after workflow step failure (retry ${retryCount}/${MAX_WORKFLOW_STEP_RETRIES})`);
-        setTimeout(async () => {
-          try {
-            await this.store.moveTask(task.id, "todo");
-            await this.store.updateTask(task.id, { worktree: worktreePath });
-            await this.store.moveTask(task.id, "in-progress");
-            executorLog.log(`${task.id}: workflow step retry scheduled \u2014 moved to todo then in-progress`);
-          } catch (err) {
-            const errorMessage = err instanceof Error ? err.message : String(err);
-            executorLog.error(`${task.id}: failed to schedule workflow step retry: ${errorMessage}`);
-            await this.store.logEntry(
-              task.id,
-              "Workflow step failed \u2014 executor ready for fresh execution"
-            );
-          }
-        }, 0);
+        this.scheduleWorkflowRerun(
+          task.id,
+          worktreePath,
+          `${task.id}: workflow step retry scheduled \u2014 moved to todo then in-progress`
+        );
         return true;
       }
       /**
@@ -62130,6 +62389,7 @@ ${feedback}
        */
       async sendTaskBackForFix(task, worktreePath, failureFeedback, stepName, reason) {
         const taskId = task.id;
+        this.clearCompletedTaskWatchdog(taskId);
         await this.store.addTaskComment(
           taskId,
           `${reason}. The failing workflow step was "${stepName}". Feedback:
@@ -62151,17 +62411,11 @@ Please fix the issues so the verification can pass on the next attempt.`,
           sessionFile: null,
           workflowStepRetries: 0
         });
-        setTimeout(async () => {
-          try {
-            await this.store.moveTask(taskId, "todo");
-            await this.store.updateTask(taskId, { worktree: worktreePath });
-            await this.store.moveTask(taskId, "in-progress");
-            executorLog.log(`${taskId}: sent back to in-progress for remediation`);
-          } catch (err) {
-            const errorMessage = err instanceof Error ? err.message : String(err);
-            executorLog.error(`${taskId}: failed to move back to in-progress: ${errorMessage}`);
-          }
-        }, 0);
+        this.scheduleWorkflowRerun(
+          taskId,
+          worktreePath,
+          `${taskId}: sent back to in-progress for remediation`
+        );
       }
       /**
        * Inject or update the "Workflow Step Failure" section in PROMPT.md.
@@ -62712,7 +62966,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((resolve17) => setTimeout(resolve17, delay2));
+            await new Promise((resolve19) => setTimeout(resolve19, delay2));
           }
         }
         throw new Error("Unexpected exit from worktree creation retry loop");
@@ -72036,13 +72290,13 @@ var init_plugin_runner = __esm({
        * Returns the result on success, throws on timeout.
        */
       withTimeout(promise, ms, timeoutMessage) {
-        return new Promise((resolve17, reject) => {
+        return new Promise((resolve19, reject) => {
           const timer = setTimeout(() => {
             reject(new Error(timeoutMessage));
           }, ms);
           promise.then((result) => {
             clearTimeout(timer);
-            resolve17(result);
+            resolve19(result);
           }).catch((err) => {
             clearTimeout(timer);
             reject(err);
@@ -72711,7 +72965,7 @@ var init_in_process_runtime = __esm({
             runtimeLog.log(
               `Waiting for ${metrics.inFlightTasks} in-flight tasks to complete...`
             );
-            await new Promise((resolve17) => setTimeout(resolve17, 1e3));
+            await new Promise((resolve19) => setTimeout(resolve19, 1e3));
           }
           const finalMetrics = this.getMetrics();
           if (finalMetrics.inFlightTasks > 0) {
@@ -73108,13 +73362,13 @@ var init_ipc_host = __esm({
         }
         const id = generateCorrelationId();
         const message = { type, id, payload };
-        return new Promise((resolve17, 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: resolve17,
+            resolve: resolve19,
             reject,
             timeout,
             type
@@ -73923,8 +74177,8 @@ var init_remote_node_client = __esm({
         return error instanceof TypeError;
       }
       async sleep(ms) {
-        await new Promise((resolve17) => {
-          setTimeout(resolve17, ms);
+        await new Promise((resolve19) => {
+          setTimeout(resolve19, ms);
         });
       }
     };
@@ -74188,14 +74442,14 @@ var init_remote_node_runtime = __esm({
         return error instanceof Error ? error : new Error(String(error));
       }
       async sleep(ms, signal) {
-        await new Promise((resolve17) => {
+        await new Promise((resolve19) => {
           const timeout = setTimeout(() => {
             cleanup();
-            resolve17();
+            resolve19();
           }, ms);
           const onAbort = () => {
             cleanup();
-            resolve17();
+            resolve19();
           };
           const cleanup = () => {
             clearTimeout(timeout);
@@ -75082,10 +75336,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((resolve17) => {
+        this.activeStopPromise = new Promise((resolve19) => {
           const onClose = () => {
             currentHandle.child.removeListener("close", onClose);
-            resolve17();
+            resolve19();
           };
           currentHandle.child.once("close", onClose);
           killManagedProcess(currentHandle.child, "SIGTERM");
@@ -75641,12 +75895,12 @@ ${detail}`
        */
       async onMerge(taskId) {
         if (this.mergeActive.has(taskId)) {
-          return new Promise((resolve17, reject) => {
-            this.manualMergeResolvers.set(taskId, { resolve: resolve17, reject });
+          return new Promise((resolve19, reject) => {
+            this.manualMergeResolvers.set(taskId, { resolve: resolve19, reject });
           });
         }
-        return new Promise((resolve17, reject) => {
-          this.manualMergeResolvers.set(taskId, { resolve: resolve17, reject });
+        return new Promise((resolve19, reject) => {
+          this.manualMergeResolvers.set(taskId, { resolve: resolve19, reject });
           this.internalEnqueueMerge(taskId);
         });
       }
@@ -79170,7 +79424,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((resolve17, reject) => {
+  return new Promise((resolve19, reject) => {
     let settled = false;
     const spawnEnv = { ...process.env, PYTHONUNBUFFERED: "1" };
     if (settings.profile) {
@@ -79238,7 +79492,7 @@ ${combined}`));
         return;
       }
       try {
-        resolve17(parseHermesOutput(stdout, stderr));
+        resolve19(parseHermesOutput(stdout, stderr));
       } catch (parseErr) {
         reject(parseErr);
       }
@@ -79464,7 +79718,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((resolve17, reject) => {
+  return new Promise((resolve19, reject) => {
     let settled = false;
     const child = spawn5(config.binaryPath, args, {
       stdio: ["ignore", "pipe", "pipe"]
@@ -79557,7 +79811,7 @@ async function promptCli(session, message, config, callbacks, signal) {
         ...metaError ? { error: metaError } : {},
         ...errorText.length > 0 ? { toolErrors: errorText } : {}
       });
-      resolve17();
+      resolve19();
     });
   });
 }
@@ -79816,12 +80070,14 @@ var init_rate_limit = __esm({
 });
 
 // ../dashboard/src/routes/register-chat-routes.ts
+var CHAT_MAX_ATTACHMENT_SIZE;
 var init_register_chat_routes = __esm({
   "../dashboard/src/routes/register-chat-routes.ts"() {
     "use strict";
     init_api_error();
     init_rate_limit();
     init_sse_buffer();
+    CHAT_MAX_ATTACHMENT_SIZE = 5 * 1024 * 1024;
   }
 });
 
@@ -79866,7 +80122,7 @@ var init_register_messaging_scripts = __esm({
 
 // ../dashboard/src/github.ts
 function delay(ms) {
-  return new Promise((resolve17) => setTimeout(resolve17, ms));
+  return new Promise((resolve19) => setTimeout(resolve19, ms));
 }
 function normalizeCheckState(state) {
   switch ((state ?? "").toLowerCase()) {
@@ -82577,7 +82833,7 @@ async function spawnPaperclipCliJson(args, opts) {
   }
   const timeoutMs = opts.cliTimeoutMs ?? 15e3;
   const label = ["paperclipai", ...args].join(" ");
-  return new Promise((resolve17, reject) => {
+  return new Promise((resolve19, reject) => {
     let child;
     try {
       child = spawn10(bin, fullArgs, { stdio: ["ignore", "pipe", "pipe"] });
@@ -82623,7 +82879,7 @@ async function spawnPaperclipCliJson(args, opts) {
         return;
       }
       try {
-        resolve17(JSON.parse(cleaned));
+        resolve19(JSON.parse(cleaned));
       } catch {
         reject(new Error(`${label} returned non-JSON output: ${cleaned.slice(0, 200)}`));
       }
@@ -82693,7 +82949,7 @@ var init_paperclip_client = __esm({
 // ../../plugins/fusion-plugin-paperclip-runtime/dist/runtime-adapter.js
 import { randomUUID as randomUUID13 } from "node:crypto";
 function sleep3(ms) {
-  return new Promise((resolve17) => setTimeout(resolve17, ms));
+  return new Promise((resolve19) => setTimeout(resolve19, ms));
 }
 function asString2(value) {
   return typeof value === "string" ? value : void 0;
@@ -83102,22 +83358,29 @@ var init_update_check = __esm({
 });
 
 // ../dashboard/src/routes/register-update-check-routes.ts
-import { readFileSync as readFileSync7 } from "node:fs";
-import { dirname as dirname9, join as join35 } from "node:path";
+import { existsSync as existsSync28, readFileSync as readFileSync7 } from "node:fs";
+import { dirname as dirname9, resolve as resolve15 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
-var __dirname, CLI_PACKAGE_VERSION;
+var CLI_PACKAGE_VERSION;
 var init_register_update_check_routes = __esm({
   "../dashboard/src/routes/register-update-check-routes.ts"() {
     "use strict";
     init_src();
     init_update_check();
-    __dirname = dirname9(fileURLToPath3(import.meta.url));
     CLI_PACKAGE_VERSION = (() => {
       try {
-        const packageJsonPath = join35(__dirname, "..", "..", "..", "cli", "package.json");
-        const packageJson = JSON.parse(readFileSync7(packageJsonPath, "utf-8"));
-        if (typeof packageJson.version === "string" && packageJson.version.length > 0) {
-          return packageJson.version;
+        let cur = dirname9(fileURLToPath3(import.meta.url));
+        for (let i = 0; i < 8; i++) {
+          const pkgPath = resolve15(cur, "package.json");
+          if (existsSync28(pkgPath)) {
+            const parsed = JSON.parse(readFileSync7(pkgPath, "utf-8"));
+            if (parsed.name === "@runfusion/fusion" && typeof parsed.version === "string" && parsed.version.length > 0) {
+              return parsed.version;
+            }
+          }
+          const parent = resolve15(cur, "..");
+          if (parent === cur) break;
+          cur = parent;
         }
       } catch {
       }
@@ -87149,8 +87412,8 @@ var init_auth_middleware = __esm({
 
 // ../dashboard/src/server.ts
 import express from "express";
-import { join as join36, dirname as dirname10 } from "node:path";
-import { existsSync as existsSync28, readFileSync as readFileSync8 } from "node:fs";
+import { join as join35, dirname as dirname10, resolve as resolve16 } from "node:path";
+import { existsSync as existsSync29, readFileSync as readFileSync8 } from "node:fs";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 function clearAiSessionCleanupInterval() {
   if (!aiSessionCleanupIntervalHandle) {
@@ -87159,7 +87422,7 @@ function clearAiSessionCleanupInterval() {
   clearInterval(aiSessionCleanupIntervalHandle);
   aiSessionCleanupIntervalHandle = void 0;
 }
-var __dirname2, PACKAGE_VERSION, CLI_PACKAGE_VERSION2, MIN_AI_SESSION_TTL_MS, MAX_AI_SESSION_TTL_MS, MIN_AI_SESSION_CLEANUP_INTERVAL_MS, MAX_AI_SESSION_CLEANUP_INTERVAL_MS, aiSessionCleanupIntervalHandle;
+var __dirname, PACKAGE_VERSION, CLI_PACKAGE_VERSION2, MIN_AI_SESSION_TTL_MS, MAX_AI_SESSION_TTL_MS, MIN_AI_SESSION_CLEANUP_INTERVAL_MS, MAX_AI_SESSION_CLEANUP_INTERVAL_MS, aiSessionCleanupIntervalHandle;
 var init_server = __esm({
   "../dashboard/src/server.ts"() {
     "use strict";
@@ -87185,10 +87448,10 @@ var init_server = __esm({
     init_dev_server_routes();
     init_auth_middleware();
     init_remote_auth();
-    __dirname2 = dirname10(fileURLToPath4(import.meta.url));
+    __dirname = dirname10(fileURLToPath4(import.meta.url));
     PACKAGE_VERSION = (() => {
       try {
-        const packageJsonPath = join36(__dirname2, "..", "package.json");
+        const packageJsonPath = join35(__dirname, "..", "package.json");
         const packageJson = JSON.parse(readFileSync8(packageJsonPath, "utf-8"));
         if (typeof packageJson.version === "string" && packageJson.version.length > 0) {
           return packageJson.version;
@@ -87199,10 +87462,18 @@ var init_server = __esm({
     })();
     CLI_PACKAGE_VERSION2 = (() => {
       try {
-        const packageJsonPath = join36(__dirname2, "..", "..", "cli", "package.json");
-        const packageJson = JSON.parse(readFileSync8(packageJsonPath, "utf-8"));
-        if (typeof packageJson.version === "string" && packageJson.version.length > 0) {
-          return packageJson.version;
+        let cur = __dirname;
+        for (let i = 0; i < 8; i++) {
+          const pkgPath = resolve16(cur, "package.json");
+          if (existsSync29(pkgPath)) {
+            const parsed = JSON.parse(readFileSync8(pkgPath, "utf-8"));
+            if (parsed.name === "@runfusion/fusion" && typeof parsed.version === "string" && parsed.version.length > 0) {
+              return parsed.version;
+            }
+          }
+          const parent = resolve16(cur, "..");
+          if (parent === cur) break;
+          cur = parent;
         }
       } catch {
       }
@@ -87278,8 +87549,8 @@ var init_src4 = __esm({
 });
 
 // src/project-context.ts
-import { resolve as resolve15, dirname as dirname11 } from "node:path";
-import { existsSync as existsSync29 } from "node:fs";
+import { resolve as resolve17, dirname as dirname11 } from "node:path";
+import { existsSync as existsSync30 } from "node:fs";
 async function resolveProject(projectNameFlag, cwd = process.cwd(), globalDir) {
   const central = new CentralCore(globalDir);
   await central.init();
@@ -87355,10 +87626,10 @@ async function clearDefaultProject(globalDir) {
   await globalStore.updateSettings(rest);
 }
 async function detectProjectFromCwd(cwd, central) {
-  let currentDir = resolve15(cwd);
+  let currentDir = resolve17(cwd);
   while (true) {
-    const kbPath = resolve15(currentDir, ".fusion", "fusion.db");
-    if (existsSync29(kbPath)) {
+    const kbPath = resolve17(currentDir, ".fusion", "fusion.db");
+    if (existsSync30(kbPath)) {
       const project = await central.getProjectByPath(currentDir);
       if (project) {
         return project;
@@ -87458,8 +87729,8 @@ __export(task_exports, {
   runTaskUpdate: () => runTaskUpdate
 });
 import { createInterface as createInterface2 } from "node:readline/promises";
-import { watchFile, unwatchFile, statSync as statSync6, existsSync as existsSync30, readFileSync as readFileSync9 } from "node:fs";
-import { join as join37 } from "node:path";
+import { watchFile, unwatchFile, statSync as statSync6, existsSync as existsSync31, readFileSync as readFileSync9 } from "node:fs";
+import { join as join36 } from "node:path";
 function asLocalProjectContext(store) {
   const cwd = process.cwd();
   return {
@@ -87579,9 +87850,9 @@ 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: basename9, extname: extname3, resolve: resolve17 } = await import("node:path");
+    const { basename: basename9, extname: extname3, resolve: resolve19 } = await import("node:path");
     for (const filePath of attachFiles) {
-      const resolvedPath = resolve17(filePath);
+      const resolvedPath = resolve19(filePath);
       const filename = basename9(resolvedPath);
       const ext = extname3(filename).toLowerCase();
       const mimeType = MIME_TYPES[ext];
@@ -87715,8 +87986,8 @@ async function runTaskLogs(id, options = {}, projectName) {
   printEntries(filteredEntries);
   if (options.follow) {
     const projectPath = projectContext?.projectPath ?? process.cwd();
-    const logPath = join37(projectPath, ".fusion", "tasks", id, "agent.log");
-    if (!existsSync30(logPath)) {
+    const logPath = join36(projectPath, ".fusion", "tasks", id, "agent.log");
+    if (!existsSync31(logPath)) {
       console.log(`
   Waiting for log file to be created...`);
     }
@@ -87875,8 +88146,8 @@ async function runTaskMerge(id, projectName) {
 async function runTaskAttach(id, filePath, projectName) {
   const { readFile: readFile19 } = await import("node:fs/promises");
   const { basename: basename9, extname: extname3 } = await import("node:path");
-  const { resolve: resolve17 } = await import("node:path");
-  const resolvedPath = resolve17(filePath);
+  const { resolve: resolve19 } = await import("node:path");
+  const resolvedPath = resolve19(filePath);
   const filename = basename9(resolvedPath);
   const ext = extname3(filename).toLowerCase();
   const mimeType = MIME_TYPES[ext];
@@ -88407,12 +88678,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((resolve17) => {
+  return new Promise((resolve19) => {
     const askLine = () => {
       rl.question("  ").then((line) => {
         if (line.trim() === "DONE") {
           rl.close();
-          resolve17(lines.join("\n"));
+          resolve19(lines.join("\n"));
         } else {
           lines.push(line);
           askLine();
@@ -88816,9 +89087,9 @@ async function runSkillsInstall(args, options) {
     stdio: "inherit",
     shell: true
   });
-  const exitCode = await new Promise((resolve17, reject) => {
+  const exitCode = await new Promise((resolve19, reject) => {
     child.on("exit", (code) => {
-      resolve17(code ?? 1);
+      resolve19(code ?? 1);
     });
     child.on("error", (err) => {
       reject(err);
@@ -88845,9 +89116,9 @@ init_src();
 init_gh_cli();
 import { Type as Type7 } from "typebox";
 import { StringEnum } from "@mariozechner/pi-ai";
-import { resolve as resolve16, basename as basename8, extname as extname2, join as join38 } from "node:path";
+import { resolve as resolve18, basename as basename8, extname as extname2, join as join37 } from "node:path";
 import { readFile as readFile18 } from "node:fs/promises";
-import { existsSync as existsSync31 } from "node:fs";
+import { existsSync as existsSync32 } from "node:fs";
 import { spawn as spawn9 } from "node:child_process";
 var MIME_TYPES2 = {
   ".png": "image/png",
@@ -88865,14 +89136,14 @@ var MIME_TYPES2 = {
   ".xml": "application/xml"
 };
 function resolveProjectRoot(cwd) {
-  let current = resolve16(cwd);
+  let current = resolve18(cwd);
   while (true) {
-    if (existsSync31(join38(current, ".fusion"))) {
+    if (existsSync32(join37(current, ".fusion"))) {
       return current;
     }
-    const parent = resolve16(current, "..");
+    const parent = resolve18(current, "..");
     if (parent === current) {
-      return resolve16(cwd);
+      return resolve18(cwd);
     }
     current = parent;
   }
@@ -88888,7 +89159,20 @@ async function getStore2(cwd) {
   return store;
 }
 function getFusionDir(cwd) {
-  return join38(resolveProjectRoot(cwd), ".fusion");
+  return join37(resolveProjectRoot(cwd), ".fusion");
+}
+async function validateAssignableAgentId(cwd, agentId) {
+  const { AgentStore: AgentStore2, isEphemeralAgent: isEphemeralAgent2 } = await Promise.resolve().then(() => (init_src(), src_exports));
+  const agentStore = new AgentStore2({ rootDir: getFusionDir(cwd) });
+  await agentStore.init();
+  const agent = await agentStore.getAgent(agentId);
+  if (!agent) {
+    return `Agent ${agentId} not found`;
+  }
+  if (isEphemeralAgent2(agent)) {
+    return `Cannot assign task to ephemeral/runtime agent ${agentId}`;
+  }
+  return null;
 }
 function formatTaskLine(t) {
   const label = t.title || t.description.slice(0, 60) + (t.description.length > 60 ? "\u2026" : "");
@@ -88951,6 +89235,16 @@ function kbExtension(pi) {
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
       const store = await getStore2(ctx.cwd);
+      if (params.agentId !== void 0) {
+        const error = await validateAssignableAgentId(ctx.cwd, params.agentId);
+        if (error) {
+          return {
+            content: [{ type: "text", text: error }],
+            isError: true,
+            details: { error }
+          };
+        }
+      }
       const task = await store.createTask({
         description: params.description.trim(),
         dependencies: params.depends,
@@ -89036,6 +89330,16 @@ Column: triage
         updatedFields.push("dependencies");
       }
       if (params.agentId !== void 0) {
+        if (params.agentId !== null) {
+          const error = await validateAssignableAgentId(ctx.cwd, params.agentId);
+          if (error) {
+            return {
+              content: [{ type: "text", text: error }],
+              isError: true,
+              details: { error }
+            };
+          }
+        }
         updates.assignedAgentId = params.agentId;
         updatedFields.push("agentId");
       }
@@ -89183,7 +89487,7 @@ Column: triage
       path: Type7.String({ description: "Path to the file to attach" })
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-      const filePath = resolve16(ctx.cwd, params.path.replace(/^@/, ""));
+      const filePath = resolve18(ctx.cwd, params.path.replace(/^@/, ""));
       const filename = basename8(filePath);
       const ext = extname2(filename).toLowerCase();
       const mimeType = MIME_TYPES2[ext];
@@ -90292,12 +90596,12 @@ Status: ${updated.status}`
       child.stderr?.on("data", (data) => {
         stderr += data.toString();
       });
-      const exitCode = await new Promise((resolve17) => {
+      const exitCode = await new Promise((resolve19) => {
         child.on("exit", (code) => {
-          resolve17(code ?? 1);
+          resolve19(code ?? 1);
         });
         child.on("error", () => {
-          resolve17(1);
+          resolve19(1);
         });
       });
       try {