@runfusion/fusion 0.74.0-beta.0 → 0.74.0-beta.1

package/dist/child-process-worker.js

@@ -1663,6 +1663,7 @@ var init_settings_schema = __esm({
       defaultProvider: void 0,
       defaultModelId: void 0,
       testMode: void 0,
+      voiceInput: void 0,
       modelPricingOverrides: void 0,
       modelPricingFetchedAt: void 0,
       modelPricingSource: void 0,
@@ -1954,6 +1955,7 @@ var init_settings_schema = __esm({
       // with this on but auto-merge off, review threads are resolved but the PR is not merged.
       autoResolveReviewComments: true,
       testMode: void 0,
+      voiceInput: void 0,
       mergeRequestContractShadowEnabled: false,
       mergeStrategy: "direct",
       directMergeCommitStrategy: "always-squash",
@@ -18387,9 +18389,13 @@ function buildRefinementSeedPrompt(title, description) {
 ${description}
 `;
 }
+function normalizeSeedText(content) {
+  return content.replace(/\r\n/g, "\n").replace(/[ \t]+$/gm, "").trimEnd();
+}
 function isUnplannedSeedPrompt(content, taskId, title, description) {
-  if (content === buildBootstrapPrompt(taskId, title, description)) return true;
-  return title !== void 0 && content === buildRefinementSeedPrompt(title, description);
+  const normalized = normalizeSeedText(content);
+  if (normalized === normalizeSeedText(buildBootstrapPrompt(taskId, title, description))) return true;
+  return title !== void 0 && normalized === normalizeSeedText(buildRefinementSeedPrompt(title, description));
 }
 var init_mesh_task_replication = __esm({
   "../core/src/mesh-task-replication.ts"() {
@@ -29650,9 +29656,11 @@ var init_agent_store = __esm({
               `Invalid state transition: ${currentState} -> ${newState}. Valid transitions: ${validTransitions.join(", ")}`
             );
           }
+          const clearsPauseReasonOnResume = (currentState === "paused" || currentState === "error") && (newState === "active" || newState === "idle" || newState === "running");
           const updated = {
             ...agent,
             state: newState,
+            ...clearsPauseReasonOnResume && { pauseReason: void 0 },
             updatedAt: (/* @__PURE__ */ new Date()).toISOString()
           };
           await this.writeAgent(updated);
@@ -64738,11 +64746,18 @@ async function moveTaskInternalImpl(store, id, toColumn, options, internal, curr
     const isLegacyRecoveryRehome = options?.recoveryRehome === true && sourceIsLegacy && COLUMNS.includes(toColumn);
     const isWorkflowDeclaredRecoveryRehome = options?.recoveryRehome === true && !COLUMNS.includes(toColumn) && workflowHasColumn(await resolveTaskWorkflowIrForMove(store, id), toColumn);
     if (!isEvacuation && !isLegacyRecoveryRehome && !isWorkflowDeclaredRecoveryRehome) {
-      const validTargets = sourceIsLegacy ? VALID_TRANSITIONS[task.column] ?? [] : resolveAllowedColumns(await resolveTaskWorkflowIrForMove(store, id), task.column);
-      if (!validTargets.includes(toColumn)) {
-        throw new Error(
-          `Invalid transition: '${task.column}' \u2192 '${toColumn}'. Valid targets: ${validTargets.join(", ") || "none"}`
+      const legacyTargets = sourceIsLegacy ? VALID_TRANSITIONS[task.column] ?? [] : [];
+      if (!legacyTargets.includes(toColumn)) {
+        const workflowTargets = resolveAllowedColumns(
+          await resolveTaskWorkflowIrForMove(store, id),
+          task.column
         );
+        const validTargets = [.../* @__PURE__ */ new Set([...legacyTargets, ...workflowTargets])];
+        if (!validTargets.includes(toColumn)) {
+          throw new Error(
+            `Invalid transition: '${task.column}' \u2192 '${toColumn}'. Valid targets: ${validTargets.join(", ") || "none"}`
+          );
+        }
       }
     }
     if (fromColumn === "in-review" && toColumn === "done" && !options?.skipMergeBlocker) {
@@ -87812,7 +87827,8 @@ async function _createTaskInternalBackendImpl(store, input, title, resolvedWorkf
     ownsStagingDirectory = true;
     if (store.isWatching) store.taskCache.set(id, { ...task });
     await store.writeTaskJsonFile(stagingDir, task);
-    const isIntakeColumn = task.column === "triage" || options?.resolvedEntryColumn !== void 0 && task.column === options.resolvedEntryColumn;
+    const isUnplannedStartCreate = options?.resolvedEntryColumn !== void 0 && options.resolvedEntryColumn !== "triage" && task.column === "todo";
+    const isIntakeColumn = task.column === "triage" || options?.resolvedEntryColumn !== void 0 && task.column === options.resolvedEntryColumn || isUnplannedStartCreate;
     const usedBootstrapPrompt = !options?.promptOverride && isIntakeColumn;
     const prompt = options?.promptOverride ?? (isIntakeColumn ? buildBootstrapPrompt(id, task.title, task.description) : store.generateSpecifiedPrompt(task));
     if (!usedBootstrapPrompt) {
@@ -88264,7 +88280,8 @@ async function _createTaskInternalImpl(store, input, title, resolvedWorkflowStep
   const dir = store.taskDir(id);
   await store.atomicCreateTaskJson(dir, task, "createTask");
   if (store.isWatching) store.taskCache.set(id, { ...task });
-  const isIntakeColumn = task.column === "triage" || options?.resolvedEntryColumn !== void 0 && task.column === options.resolvedEntryColumn;
+  const isUnplannedStartCreate = options?.resolvedEntryColumn !== void 0 && options.resolvedEntryColumn !== "triage" && task.column === "todo";
+  const isIntakeColumn = task.column === "triage" || options?.resolvedEntryColumn !== void 0 && task.column === options.resolvedEntryColumn || isUnplannedStartCreate;
   const usedBootstrapPrompt = !options?.promptOverride && isIntakeColumn;
   const prompt = options?.promptOverride ?? (isIntakeColumn ? buildBootstrapPrompt(id, task.title, task.description) : store.generateSpecifiedPrompt(task));
   if (!usedBootstrapPrompt) {
@@ -136153,15 +136170,26 @@ function countCapacitySlot(allTasks, effectiveWorkflowIdByTask, budgetColumns, w
   }
   return count2;
 }
+function trackHeld(taskId, reason, nowMs) {
+  const existing = heldSince.get(taskId);
+  if (!existing || existing.reason !== reason) {
+    heldSince.set(taskId, { reason, sinceMs: nowMs });
+    return 0;
+  }
+  return nowMs - existing.sinceMs;
+}
 async function runHoldReleaseSweep(store, deps) {
   const result = { released: [], held: [] };
+  const sweepStartedMs = deps.now();
   const settings = await store.getSettings();
   const allTasks = await store.listTasks({ includeArchived: false });
   const irCache = /* @__PURE__ */ new Map();
   const effectiveWorkflowIdByTask = /* @__PURE__ */ new Map();
+  const prefetchStartedMs = deps.now();
   for (const t of allTasks) {
     effectiveWorkflowIdByTask.set(t.id, await effectiveWorkflowId(store, t.id));
   }
+  const prefetchMs = deps.now() - prefetchStartedMs;
   for (const task of allTasks) {
     if (task.paused || task.userPaused) {
       continue;
@@ -136176,6 +136204,7 @@ async function runHoldReleaseSweep(store, deps) {
     if (!column || !holdConfig) continue;
     const release2 = typeof holdConfig.release === "string" ? holdConfig.release : "manual";
     if (release2 === "manual" || release2 === "external-event") {
+      trackHeld(task.id, `${release2}-only`, deps.now());
       result.held.push({ taskId: task.id, reason: `${release2}-only` });
       continue;
     }
@@ -136184,18 +136213,21 @@ async function runHoldReleaseSweep(store, deps) {
       const deadline = resolveTimerDeadline(holdConfig, task);
       shouldRelease = deadline !== void 0 && deps.now() >= deadline;
       if (!shouldRelease) {
+        trackHeld(task.id, "timer-not-elapsed", deps.now());
         result.held.push({ taskId: task.id, reason: "timer-not-elapsed" });
         continue;
       }
     } else if (release2 === "dependency") {
       shouldRelease = await allDependenciesSatisfied(store, task, allTasks);
       if (!shouldRelease) {
+        trackHeld(task.id, "deps-unsatisfied", deps.now());
         result.held.push({ taskId: task.id, reason: "deps-unsatisfied" });
         continue;
       }
     } else if (release2 === "capacity") {
       const target2 = resolveReleaseTarget(ir2, task.column, true);
       if (!target2) {
+        trackHeld(task.id, "no-downstream-capacity-column", deps.now());
         result.held.push({ taskId: task.id, reason: "no-downstream-capacity-column" });
         continue;
       }
@@ -136205,6 +136237,7 @@ async function runHoldReleaseSweep(store, deps) {
         const budgetColumns = new Set(resolveWipBudgetColumns(ir2, target2));
         const occupants = countCapacitySlot(allTasks, effectiveWorkflowIdByTask, budgetColumns, workflowId, capacity.countPending);
         if (occupants >= capacity.limit) {
+          trackHeld(task.id, "downstream-full", deps.now());
           result.held.push({ taskId: task.id, reason: "downstream-full" });
           continue;
         }
@@ -136214,16 +136247,40 @@ async function runHoldReleaseSweep(store, deps) {
     if (!shouldRelease) continue;
     const target = resolveReleaseTarget(ir2, task.column, release2 === "capacity");
     if (!target) {
+      trackHeld(task.id, "no-release-target", deps.now());
       result.held.push({ taskId: task.id, reason: "no-release-target" });
       continue;
     }
     const released = await issueRelease(store, deps, task, target, ir2);
     if (released) {
+      const waitedMs = deps.now() - (heldSince.get(task.id)?.sinceMs ?? deps.now());
+      heldSince.delete(task.id);
+      schedulerLog.log(
+        `Hold release for ${task.id} \u2192 ${target} after ${waitedMs}ms held (release=${release2})`
+      );
       result.released.push(task.id);
     } else {
+      trackHeld(task.id, "move-rejected-or-no-slot", deps.now());
       result.held.push({ taskId: task.id, reason: "move-rejected-or-no-slot" });
     }
   }
+  const sweepMs = deps.now() - sweepStartedMs;
+  const longestHeldMs = result.held.reduce((max2, h) => {
+    const entry = heldSince.get(h.taskId);
+    return entry ? Math.max(max2, deps.now() - entry.sinceMs) : max2;
+  }, 0);
+  const summary = `Hold-release sweep: ${sweepMs}ms (prefetch ${prefetchMs}ms over ${allTasks.length} tasks), released=${result.released.length}, held=${result.held.length}` + (longestHeldMs > 0 ? `, longest held ${longestHeldMs}ms` : "");
+  if (sweepMs >= SLOW_SWEEP_WARN_MS) {
+    schedulerLog.warn(`${summary} \u2014 sweep exceeded ${SLOW_SWEEP_WARN_MS}ms and is itself the delay`);
+  } else if (result.released.length > 0) {
+    schedulerLog.log(summary);
+  } else {
+    schedulerLog.debug(summary);
+  }
+  const stillHeld = new Set(result.held.map((h) => h.taskId));
+  for (const taskId of [...heldSince.keys()]) {
+    if (!stillHeld.has(taskId)) heldSince.delete(taskId);
+  }
   return result;
 }
 async function issueRelease(store, deps, task, target, ir2) {
@@ -136326,12 +136383,15 @@ async function releaseHeldTaskByEvent(store, taskId, eventTag, deps = {}) {
   );
   return released ? { released: true, toColumn: target } : { released: false, rejection: "capacity-exhausted-or-no-slot" };
 }
+var heldSince, SLOW_SWEEP_WARN_MS;
 var init_hold_release = __esm({
   "../engine/src/hold-release.ts"() {
     "use strict";
     init_src2();
     init_logger();
     init_spec_staleness();
+    heldSince = /* @__PURE__ */ new Map();
+    SLOW_SWEEP_WARN_MS = 2e3;
   }
 });
 
@@ -191897,6 +191957,15 @@ var Scheduler = class {
           this.schedule();
         }
       }
+      if (task.status === "planning") {
+        this.planningTaskIds.add(task.id);
+      } else if (this.planningTaskIds.has(task.id)) {
+        this.planningTaskIds.delete(task.id);
+        if (this.running && !task.status && !task.paused && !task.userPaused && (task.column === "todo" || task.column === "triage")) {
+          schedulerLog.log(`Task ${task.id} finished planning \u2014 triggering scheduling`);
+          this.schedule();
+        }
+      }
       if (!this.options.prMonitor) return;
       if (task.column !== "in-review") return;
       if (!task.prInfo) return;
@@ -191914,6 +191983,7 @@ var Scheduler = class {
       this.lastAutoClaimFingerprint.delete(task.id);
       this.options.snapshotManager?.invalidate("task:deleted");
       this.pausedTaskIds.delete(task.id);
+      this.planningTaskIds.delete(task.id);
       this.failedTaskIds.delete(task.id);
       this.recentEngineTodoRequeues.delete(task.id);
       this.wasNodeDispatchValidationBlocked.delete(task.id);
@@ -191986,6 +192056,13 @@ var Scheduler = class {
   activePollMs = null;
   /** Tracks which task IDs are currently paused, to detect unpause transitions. */
   pausedTaskIds = /* @__PURE__ */ new Set();
+  /**
+   * FNXC:CodingIdeasWorkflow 2026-07-25-13:10:
+   * Tracks task IDs last seen with status "planning", so the planning -> dispatchable transition
+   * can trigger an immediate scheduling pass. Plan-in-place workflows clear status without a
+   * task:moved, so this is the only signal that the card just became executable.
+   */
+  planningTaskIds = /* @__PURE__ */ new Set();
   /** Tracks mission-linked tasks observed with status=failed before moveTask clears status/error. */
   failedTaskIds = /* @__PURE__ */ new Set();
   /** Tracks tasks blocked by unavailable-node policy to deduplicate block log entries. */
@@ -192405,7 +192482,7 @@ var Scheduler = class {
         todo.map(async (t) => {
           try {
             const content = await readFile30(getPromptPath(this.store.getTasksDir(), t.id), "utf-8");
-            if (content === buildBootstrapPrompt(t.id, t.title, t.description)) return null;
+            if (isUnplannedSeedPrompt(content, t.id, t.title, t.description)) return null;
           } catch {
           }
           return t;
@@ -202218,6 +202295,44 @@ function renderRoomCoordinationPromptBlock(decision, pendingMessage) {
   ];
 }
 
+// ../engine/src/reports-health.ts
+var OPERATOR_ACTIONABLE_PAUSE_REASONS = /* @__PURE__ */ new Set([
+  "error-unrecoverable",
+  "error-retry-exhausted",
+  "heartbeat-model-unavailable"
+]);
+function classifyReportHealth(input) {
+  const pauseReason = input.pauseReason?.trim();
+  if (pauseReason) {
+    if (OPERATOR_ACTIONABLE_PAUSE_REASONS.has(pauseReason)) {
+      return {
+        bucket: "operator-actionable",
+        cellText: `**needs operator repair** (${pauseReason})`
+      };
+    }
+    return {
+      bucket: "paused",
+      cellText: `paused (${pauseReason})`
+    };
+  }
+  if (input.state === "error") {
+    return { bucket: "operator-actionable", cellText: "**needs operator repair**" };
+  }
+  if (input.staleParkedAssignment) {
+    return { bucket: "stale-assignment", cellText: "**stale** assignment" };
+  }
+  if (input.state === "running" && input.heartbeatAgeMs > input.heartbeatTimeoutMs * 2) {
+    return { bucket: "stuck", cellText: "**stuck**" };
+  }
+  if ((input.state === "active" || input.state === "idle") && input.heartbeatAgeMs > input.staleThresholdMs) {
+    return { bucket: "stale", cellText: "**stale**" };
+  }
+  if (input.state === "paused") {
+    return { bucket: "paused", cellText: "paused" };
+  }
+  return { bucket: "healthy", cellText: "healthy" };
+}
+
 // ../engine/src/agent-heartbeat.ts
 init_session_token_usage();
 
@@ -205323,26 +205438,28 @@ ${trimPromptMd(taskDetail.prompt, promptTemplate)}` : "No PROMPT.md available.",
           heartbeatLog.warn(`[reports-health] failed to validate task link for ${report.id}/${report.taskId}: ${error2 instanceof Error ? error2.message : String(error2)}`);
         }
       }
-      let health = "healthy";
-      if (staleParkedAssignment) {
-        health = "**stale** assignment";
-      } else if (report.state === "paused") {
-        health = report.pauseReason ? `paused (${report.pauseReason})` : "paused";
-      } else if (report.state === "error") {
-        health = "**stuck**";
-      } else if (report.state === "running") {
-        health = heartbeatAgeMs <= heartbeatTimeoutMs * 2 ? "healthy" : "**stuck**";
-      } else if ((report.state === "active" || report.state === "idle") && heartbeatAgeMs > staleThresholdMs) {
-        health = "**stale**";
+      const classification = classifyReportHealth({
+        state: report.state,
+        pauseReason: report.pauseReason,
+        heartbeatAgeMs,
+        heartbeatTimeoutMs,
+        staleThresholdMs,
+        staleParkedAssignment
+      });
+      if (classification.bucket === "stale") {
         heartbeatLog.log(`[reports-health] stale report ${report.id} intervalSource=${intervalSource} staleThresholdMs=${staleThresholdMs} heartbeatAgeMs=${heartbeatAgeMs}`);
       }
       const task = renderedTask;
       const state = renderedState;
       const heartbeat = formatRelativeTime(report.lastHeartbeatAt);
-      return `| ${report.name} | ${state} | ${task} | ${heartbeat} | ${health} |`;
+      return {
+        classification,
+        row: `| ${report.name} | ${state} | ${task} | ${heartbeat} | ${classification.cellText} |`
+      };
     }));
-    const hasStuck = rows.some((row) => row.includes("**stuck**"));
-    const hasStale = rows.some((row) => row.includes("**stale**"));
+    const hasStuck = rows.some(({ classification }) => classification.bucket === "stuck");
+    const hasStale = rows.some(({ classification }) => classification.bucket === "stale" || classification.bucket === "stale-assignment");
+    const hasOperatorActionable = rows.some(({ classification }) => classification.bucket === "operator-actionable");
     const actionLines = ["### Actions for Unresponsive Reports"];
     if (hasStuck) {
       actionLines.push("- For **stuck** reports: first check task-log/step progress, the active heartbeat run, and worktree/session liveness. If work is live, do not stop or reassign it; request status if needed. Reassign only after no live session and no forward progress are confirmed.");
@@ -205350,6 +205467,9 @@ ${trimPromptMd(taskDetail.prompt, promptTemplate)}` : "No PROMPT.md available.",
     if (hasStale) {
       actionLines.push("- For **stale** reports: the agent may have lost its heartbeat trigger \u2014 create a follow-up task to investigate.");
     }
+    if (hasOperatorActionable) {
+      actionLines.push("- For reports that **need operator repair**: notify the operator and create a follow-up task; do not reassign work until the parked agent's configuration or access issue is repaired.");
+    }
     return [
       "## Reports Health Check",
       "",
@@ -205357,7 +205477,7 @@ ${trimPromptMd(taskDetail.prompt, promptTemplate)}` : "No PROMPT.md available.",
       "",
       "| Name | State | Task | Last Heartbeat | Health |",
       "|------|-------|------|----------------|--------|",
-      ...rows,
+      ...rows.map(({ row }) => row),
       "",
       ...actionLines
     ].join("\n");
@@ -241396,12 +241516,30 @@ var TriageProcessor = class _TriageProcessor {
         this.activeSessions.delete(task.id);
       }
     };
+    this.taskColumnWakeHandler = (task) => {
+      if (!task?.id) return;
+      if (task.column !== "todo" && task.column !== "triage") return;
+      if (task.paused === true || task.userPaused === true) return;
+      if (this.processing.has(task.id) || this.hasLivePlanningWork(task.id)) return;
+      this.requestImmediatePoll();
+    };
   }
   running = false;
   polling = false;
   pollInterval = null;
   /** The interval (ms) of the currently active `setInterval` timer. */
   activePollMs = null;
+  /*
+  FNXC:CodingIdeasWorkflow 2026-07-25-11:20:
+  Event-wake state for requestImmediatePoll(). Planning discovery is timer-driven, so pressing
+  Start on an Ideas card (which only writes a column change) used to wait out the remainder of the
+  poll interval — up to pollIntervalMs, 15s by default — before anything even looked at the card.
+  `nudgeTimer` debounces a burst of moves into one poll; `nudgeDuringPoll` remembers a nudge that
+  arrived while a poll was already in flight, since that poll may have snapshotted the task list
+  before the move landed and would otherwise drop the wake entirely.
+  */
+  nudgeTimer = null;
+  nudgeDuringPoll = false;
   processing = /* @__PURE__ */ new Set();
   /** Synchronous ownership fence shared with advanced-triage self-healing. */
   advancedRecoveryReservations = /* @__PURE__ */ new Set();
@@ -241441,6 +241579,8 @@ var TriageProcessor = class _TriageProcessor {
   stuckAborted = /* @__PURE__ */ new Set();
   taskDeletedHandler;
   taskPausedHandler;
+  /** FNXC:CodingIdeasWorkflow 2026-07-25-11:20: store-event wake for planning-eligible columns. */
+  taskColumnWakeHandler;
   _approvalRequestStore;
   /**
    * @param store — Task store instance (also used to listen for `settings:updated` events)
@@ -241545,6 +241685,10 @@ var TriageProcessor = class _TriageProcessor {
     if (this.taskPausedHandler && typeof this.store.on === "function") {
       this.store.on("task:updated", this.taskPausedHandler);
     }
+    if (this.taskColumnWakeHandler && typeof this.store.on === "function") {
+      this.store.on("task:updated", this.taskColumnWakeHandler);
+      this.store.on("task:created", this.taskColumnWakeHandler);
+    }
     this.clearStaleSpecifyingStatuses().catch((err) => {
       planLog.error("Failed to clear stale planning statuses:", err);
     });
@@ -241577,12 +241721,21 @@ var TriageProcessor = class _TriageProcessor {
       this.pollInterval = null;
       this.activePollMs = null;
     }
+    if (this.nudgeTimer) {
+      clearTimeout(this.nudgeTimer);
+      this.nudgeTimer = null;
+    }
+    this.nudgeDuringPoll = false;
     if (this.taskDeletedHandler && typeof this.store.off === "function") {
       this.store.off("task:deleted", this.taskDeletedHandler);
     }
     if (this.taskPausedHandler && typeof this.store.off === "function") {
       this.store.off("task:updated", this.taskPausedHandler);
     }
+    if (this.taskColumnWakeHandler && typeof this.store.off === "function") {
+      this.store.off("task:updated", this.taskColumnWakeHandler);
+      this.store.off("task:created", this.taskColumnWakeHandler);
+    }
     this.abortAndDisposeActiveSessions("engine stop");
     planLog.log("Processor stopped");
   }
@@ -241990,7 +242143,17 @@ var TriageProcessor = class _TriageProcessor {
         if (isUnplannedSeedPrompt(content, todoTask.id, todoTask.title, todoTask.description)) {
           eligibleTodoTasks.push(todoTask);
         }
-      } catch {
+      } catch (err) {
+        if (err?.code === "ENOENT") {
+          planLog.warn(
+            `${todoTask.id}: PROMPT.md is missing \u2014 treating as unplanned and admitting it for planning`
+          );
+          eligibleTodoTasks.push(todoTask);
+        } else {
+          planLog.warn(
+            `${todoTask.id}: PROMPT.md unreadable (${err?.code ?? "unknown"}) \u2014 skipping planning discovery for this poll`
+          );
+        }
       }
     }
     return [...eligibleTriageTasks, ...eligibleTodoTasks].sort((a, b3) => {
@@ -242004,10 +242167,41 @@ var TriageProcessor = class _TriageProcessor {
       return numeric2 !== 0 ? numeric2 : a.id.localeCompare(b3.id);
     });
   }
+  /**
+   * Run a planning-discovery poll now instead of waiting for the next timer tick.
+   *
+   * FNXC:CodingIdeasWorkflow 2026-07-25-11:20:
+   * Requirement: starting a task must begin planning immediately, not "within 15 seconds".
+   * The Start affordance on an intake (Ideas) card performs a bare column move — there is no
+   * dispatch call in that path — so planning only began when the next `setInterval` tick happened
+   * to fire. The store-event wake (taskColumnWakeHandler) is the primary caller.
+   *
+   * Contract: advisory and idempotent. It never plans a task by itself, it only advances WHEN the
+   * existing poll runs — every pause, seed-prompt, dependency, and concurrency gate still applies,
+   * so a nudge on a capacity-blocked card is a no-op rather than an admission bypass. Returns false
+   * when the processor is not running.
+   */
+  requestImmediatePoll() {
+    if (!this.running) return false;
+    if (this.polling) {
+      this.nudgeDuringPoll = true;
+      return true;
+    }
+    if (this.nudgeTimer) return true;
+    this.nudgeTimer = setTimeout(() => {
+      this.nudgeTimer = null;
+      void this.poll();
+    }, _TriageProcessor.NUDGE_DEBOUNCE_MS);
+    this.nudgeTimer.unref?.();
+    return true;
+  }
+  /** Coalescing window for requestImmediatePoll, so a multi-card drag causes one poll, not N. */
+  static NUDGE_DEBOUNCE_MS = 150;
   async poll() {
     if (!this.running) return;
     if (this.polling) return;
     this.polling = true;
+    this.nudgeDuringPoll = false;
     try {
       const settings = await this.store.getSettings();
       this.refreshPollInterval(settings.pollIntervalMs);
@@ -242113,6 +242307,10 @@ var TriageProcessor = class _TriageProcessor {
       planLog.error("Poll error:", err);
     } finally {
       this.polling = false;
+      if (this.nudgeDuringPoll && this.running) {
+        this.nudgeDuringPoll = false;
+        this.requestImmediatePoll();
+      }
     }
   }
   async backfillBlankTitleAfterTerminalTriageFailure(task) {