@aion0/forge 0.10.55 → 0.10.57

package/RELEASE_NOTES.md

@@ -1,8 +1,8 @@
-# Forge v0.10.55
+# Forge v0.10.57
 
-Released: 2026-06-09
+Released: 2026-06-10
 
-## Changes since v0.10.54
+## Changes since v0.10.56
 
 
-**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.10.54...v0.10.55
+**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.10.56...v0.10.57

package/app/api/activity/summary/route.ts

@@ -13,6 +13,7 @@
 import { NextResponse } from 'next/server';
 import { listPipelinesSummary } from '@/lib/pipeline';
 import { listSchedules } from '@/lib/schedules/store';
+import { listTasksLite } from '@/lib/task-manager';
 
 interface RunningRow {
   id: string;
@@ -41,8 +42,20 @@ interface RecentRow {
   durationMs: number | null;
 }
 
+interface RunningTaskRow {
+  id: string;
+  project: string;
+  prompt_preview: string;
+  status: string;
+  startedAt: string | null;
+  createdAt: string;
+  agent: string | null;
+}
+
 interface Summary {
   running: RunningRow[];
+  /** Currently dispatched Claude CLI tasks (separate from pipelines). */
+  running_tasks: RunningTaskRow[];
   upcoming: UpcomingRow[];
   recent: RecentRow[];
   generated_at: string;
@@ -125,8 +138,25 @@ export async function GET() {
     schedule_summary: scheduleSummary(s),
   }));
 
+  // Running tasks — dispatched via chat's dispatch_task or pipeline node.
+  // Lite list (no log / git_diff / result_summary) — same shape constraint
+  // as listPipelinesSummary; we just need name + status + project for the
+  // activity bar. Top 20 by recency to bound the response.
+  const runningTasks: RunningTaskRow[] = listTasksLite('running')
+    .slice(0, 20)
+    .map((t) => ({
+      id: t.id,
+      project: t.projectName,
+      prompt_preview: (t.prompt || '').replace(/\s+/g, ' ').slice(0, 80),
+      status: t.status,
+      startedAt: t.startedAt ?? null,
+      createdAt: t.createdAt,
+      agent: t.agent || null,
+    }));
+
   const summary: Summary = {
     running,
+    running_tasks: runningTasks,
     upcoming,
     recent,
     generated_at: new Date().toISOString(),

package/components/Dashboard.tsx

@@ -121,8 +121,12 @@ export default function Dashboard({ user }: { user: any }) {
     }
     // Optional deep-link to a specific pipeline run — used by the extension
     // Jobs tab when surfacing a dispatch's target pipeline.
-    const pid = params.get('pipelineId');
-    if (pid) setPendingPipelineId(pid);
+    const pid = params.get('pipelineId') || params.get('pipeline');
+    if (pid) { setPendingPipelineId(pid); setViewMode('pipelines' as any); }
+    // Same shape for tasks — extension ActivityBar deeplinks
+    // ?task=<id> to jump straight to that task in the Tasks view.
+    const tid = params.get('taskId') || params.get('task');
+    if (tid) { setActiveTaskId(tid); setViewMode('tasks' as any); }
   }, []);
   // workspaceProject state kept for forge:open-terminal event compatibility
   const [workspaceProject, setWorkspaceProject] = useState<{ name: string; path: string } | null>(null);

package/components/PipelineView.tsx

@@ -215,9 +215,15 @@ const STATUS_COLOR: Record<string, string> = {
 //      this is just a compact status bar to make the loop structure clear.
 //   2. Iterations — each completed iteration as a foldable card; current
 //      iter shown as a "running ↓" hint pointing to the DAG nodes below.
-function ForEachStatePanel({ pipeline, onViewTask }: {
+function ForEachStatePanel({ pipeline, onViewTask, onRetry }: {
   pipeline: Pipeline;
   onViewTask?: (taskId: string) => void;
+  /** Retry a failed node — wired to /api/pipelines/:id retry-node. Currently
+   *  the backend resets the node + downstream and (for forEach) rewinds the
+   *  iteration cursor so the orchestrator picks up from the failed iter and
+   *  continues through the remaining iterations. Surfaces "only last iter
+   *  supported" errors from the backend as an alert. */
+  onRetry?: (nodeId: string) => void;
 }) {
   const fe = pipeline.forEach!;
   const [openIdx, setOpenIdx] = useState<number | null>(null);
@@ -325,24 +331,47 @@ function ForEachStatePanel({ pipeline, onViewTask }: {
                 <div className="px-3 py-2 space-y-1 border-t border-[var(--border)] bg-[var(--bg-tertiary)]/30">
                   {Object.entries(iter.nodes).map(([nodeId, n]) => {
                     const clickable = !!(n.taskId && onViewTask);
-                    const Tag = clickable ? 'button' : 'div';
+                    const retriable = !!onRetry && (n.status === 'failed' || n.status === 'cancelled');
+                    // Row is a div when there's a retry button — buttons can't
+                    // nest inside buttons. Status icon / "view task" become
+                    // their own click targets in that case.
+                    const rowAsButton = clickable && !retriable;
+                    const Tag = rowAsButton ? 'button' : 'div';
                     return (
                       <Tag
                         key={nodeId}
-                        onClick={clickable ? () => onViewTask!(n.taskId!) : undefined}
-                        className={`flex items-start gap-2 text-[10px] w-full text-left rounded px-1 -mx-1 py-0.5 ${clickable ? 'hover:bg-[var(--bg-secondary)] cursor-pointer' : ''}`}
-                        title={clickable ? `View task ${n.taskId}` : undefined}
+                        onClick={rowAsButton ? () => onViewTask!(n.taskId!) : undefined}
+                        className={`flex items-start gap-2 text-[10px] w-full text-left rounded px-1 -mx-1 py-0.5 ${rowAsButton ? 'hover:bg-[var(--bg-secondary)] cursor-pointer' : ''}`}
+                        title={rowAsButton ? `View task ${n.taskId}` : undefined}
                       >
                         <span className={STATUS_COLOR[n.status] ?? 'text-gray-400'}>
                           {STATUS_ICON[n.status] ?? '?'}
                         </span>
                         <span className="font-mono">{nodeId}</span>
-                        {clickable && <span className="text-[9px] text-[var(--text-secondary)]">↗</span>}
+                        {clickable && !rowAsButton && (
+                          <button
+                            type="button"
+                            onClick={(e) => { e.stopPropagation(); onViewTask!(n.taskId!); }}
+                            className="text-[9px] text-[var(--text-secondary)] hover:text-[var(--accent)] underline"
+                            title={`View task ${n.taskId}`}
+                          >↗</button>
+                        )}
+                        {clickable && rowAsButton && (
+                          <span className="text-[9px] text-[var(--text-secondary)]">↗</span>
+                        )}
                         {n.error && (
                           <span className="text-red-400 truncate flex-1" title={n.error}>
                             — {n.error.slice(0, 80)}
                           </span>
                         )}
+                        {retriable && (
+                          <button
+                            type="button"
+                            onClick={(e) => { e.stopPropagation(); onRetry!(nodeId); }}
+                            className="ml-auto text-[9px] px-1.5 py-0 border border-yellow-500/50 text-yellow-400 hover:bg-yellow-500/10 rounded"
+                            title={`Retry ${nodeId} — resets this node and any downstream, and (for forEach) resumes from this iteration through the remaining items. Use this instead of retrying the underlying task, which leaves the pipeline stuck.`}
+                          >↻ retry</button>
+                        )}
                       </Tag>
                     );
                   })}
@@ -1554,7 +1583,11 @@ initial_prompt: "{{input.task}}"
             <div className="overflow-y-auto">
               {/* for_each loop: setup + iteration history above the current-iter nodes */}
               {selectedPipeline.forEach && (
-                <ForEachStatePanel pipeline={selectedPipeline} onViewTask={onViewTask} />
+                <ForEachStatePanel
+                  pipeline={selectedPipeline}
+                  onViewTask={onViewTask}
+                  onRetry={(nid) => handleRetryNode(selectedPipeline.id, nid)}
+                />
               )}
               <div className="p-4 space-y-2">
               {(() => {

package/lib/agents/known-models.ts

@@ -14,7 +14,7 @@ import type { ModelsRegistry } from '../public-info/types';
 
 export const KNOWN_MODELS_FALLBACK: ModelsRegistry = {
   version: 1,
-  updatedAt: '2026-05-30',
+  updatedAt: '2026-06-10',
   note: 'Bundled fallback — actual current list lives in forge-public-info/models/registry.json',
   agents: {
     'claude-code': {
@@ -22,11 +22,13 @@ export const KNOWN_MODELS_FALLBACK: ModelsRegistry = {
       default: 'claude-sonnet-4-6',
       aliases: [
         { id: 'default', label: 'default (CLI decides)' },
+        { id: 'fable',   label: 'fable (alias)' },
         { id: 'sonnet',  label: 'sonnet (alias)' },
         { id: 'opus',    label: 'opus (alias)' },
         { id: 'haiku',   label: 'haiku (alias)' },
       ],
       models: [
+        { id: 'claude-fable-5',            label: 'Fable 5',    tier: 'premium'  },
         { id: 'claude-opus-4-8',           label: 'Opus 4.8',   tier: 'premium'  },
         { id: 'claude-sonnet-4-6',         label: 'Sonnet 4.6', tier: 'standard', default: true },
         { id: 'claude-haiku-4-5-20251001', label: 'Haiku 4.5',  tier: 'fast'     },

package/lib/chat/agent-loop.ts

@@ -567,6 +567,19 @@ export interface RunTurnArgs {
 
 export async function runTurn(args: RunTurnArgs): Promise<{ ok: boolean; error?: string }> {
   const cb = args.callbacks?.onEvent ?? (() => {});
+
+  // Claim the turn-control flag FIRST — before any early-return path
+  // (session-not-found, provider-error). The outer try/finally below
+  // guarantees endTurn runs in EVERY exit path, including early returns
+  // and uncaught throws, so the running flag never gets stuck true.
+  //
+  // The caller (enqueueChatInput) may have already claimed via
+  // tryBeginTurn — beginTurn is idempotent on running:true and doesn't
+  // wipe notes that may have arrived in the claim→here window.
+  beginTurn(args.sessionId);
+
+  try {
+
   const session = getSession(args.sessionId);
   if (!session) {
     cb({ type: 'error', data: { error: `session not found: ${args.sessionId}` } });
@@ -762,10 +775,11 @@ export async function runTurn(args: RunTurnArgs): Promise<{ ok: boolean; error?:
   let lastStop = '';
   let assistantBlocksAccum: ContentBlock[] = [];
 
-  // Mark this turn live so the user can abort it / inject notes mid-flight
-  // (see turn-control.ts). Cleared in the finally below.
-  beginTurn(args.sessionId);
-
+  // beginTurn already ran at function entry (see top of runTurn). The
+  // try/finally below is for the LLM-streaming error path — keep it
+  // so fetch errors still get fanned out as 'error' events. endTurn is
+  // handled by the OUTER try/finally so removing it from this inner
+  // finally is intentional (avoids redundant calls).
   try {
     while (iter < MAX_ITERATIONS) {
       iter += 1;
@@ -1028,7 +1042,16 @@ export async function runTurn(args: RunTurnArgs): Promise<{ ok: boolean; error?:
     });
     cb({ type: 'error', data: { error: msg } });
     return { ok: false, error: msg };
+  }
+  // Inner try (LLM streaming) ends here — no finally; the OUTER
+  // finally below owns endTurn so it runs even when an early return
+  // above (session-not-found / provider-error) skips the inner loop.
+
   } finally {
+    // Outer finally — runs on ALL exit paths, including the early
+    // returns at session-not-found and provider-error, and any throw
+    // anywhere in the function. Guarantees the turn-control running
+    // flag is always cleared so future inputs can start fresh turns.
     endTurn(args.sessionId);
   }
 }

package/lib/chat/input-queue.ts

@@ -0,0 +1,159 @@
+/**
+ * Chat input queue — the single routing/merge layer for all external
+ * inputs to a chat session.
+ *
+ * Why this file exists. Before, every input source had to re-implement
+ * the "if a turn is already running, merge into it instead of forking
+ * a new turn" gate (see handleMessagePost vs the watch runChat callback).
+ * Easy to forget — and forgetting it caused the 2026-06-09 bug where a
+ * watch firing mid-turn produced duplicate trigger_pipeline calls (commit
+ * 0d48569 patched that one path). User: "你应该把所有的消息输入别是 chat
+ * 放在一个队列通道中,然后合并处理".
+ *
+ * Now there's exactly ONE entry point. All callers — user POST /messages,
+ * watch on_done/on_fail injects, schedule action announcements, future
+ * Slack/IDE/cron sources — call enqueueChatInput. The function decides
+ * whether to (a) merge into the running turn as a note, (b) start a new
+ * turn, or (c) just persist+broadcast an announcement without invoking
+ * the LLM.
+ *
+ * Per-session queueing already lives in turn-control.ts (notes Map keyed
+ * by sessionId). When multi-conversation features land later, they just
+ * spawn more sessions — the same merge semantics apply per-session
+ * without code changes here.
+ */
+
+import { appendMessage } from './session-store';
+import { runTurn, type AgentEvent } from './agent-loop';
+import type { ContentBlock } from './types';
+import { isTurnRunning, addNote, tryBeginTurn } from './turn-control';
+
+/** Where the input came from. Pure metadata — used for logs + decisions
+ *  about default behavior (e.g. watch text might want a tag prefix). */
+export type InputSource = 'user' | 'watch' | 'schedule' | 'bridge' | 'mcp' | 'unknown';
+
+export interface EnqueueOpts {
+  sessionId: string;
+  /** For 'turn' mode: the raw user-side text the agent should see.
+   *  For 'announce' mode: optional shortcut — wrapped in [{type:'text'}]. */
+  text?: string;
+  /** For 'announce' mode: pre-formed message blocks. Wins over `text`. */
+  blocks?: ContentBlock[];
+  /** Announce role. Default 'assistant' — a system-emitted notice. */
+  role?: 'user' | 'assistant';
+  /**
+   * 'turn'     — drive the agent. Either start a new turn or merge into
+   *              an already-running one as a note (LLM sees on next
+   *              iteration boundary). MOST CALLERS USE THIS.
+   * 'announce' — push a pre-formed message into the thread, no agent
+   *              invocation. Used by schedule chat-action so its
+   *              completion notice shows up without triggering a reply.
+   */
+  mode: 'turn' | 'announce';
+  source: InputSource;
+  /** Sink for SSE events fanned out to subscribers. Required for 'turn'
+   *  mode (or the UI sees no streaming). 'announce' uses it to push the
+   *  message_saved event so open tabs render the new message live. */
+  onEvent?: (e: AgentEvent) => void;
+}
+
+export interface EnqueueResult {
+  ok: boolean;
+  /** 'started'   — fresh runTurn kicked off
+   *  'merged'    — text queued as a note for the in-flight turn
+   *  'announced' — message persisted + broadcast, no turn
+   *  'rejected'  — input invalid (empty text in turn mode, etc.) */
+  status: 'started' | 'merged' | 'announced' | 'rejected';
+  /** Populated by 'announced' — the persisted message's id, so the
+   *  /inject HTTP response can return it (existing API contract). */
+  messageId?: string;
+  reason?: string;
+}
+
+/**
+ * The single entry point. Routes by mode + isTurnRunning state.
+ *
+ * Sync (returns immediately). For 'turn' mode it kicks off runTurn in
+ * the background — caller doesn't await; events flow through onEvent.
+ */
+export function enqueueChatInput(opts: EnqueueOpts): EnqueueResult {
+  if (opts.mode === 'announce') {
+    // Persist the message without invoking the LLM. role defaults to
+    // 'assistant' (system-emitted notice). Caller supplies blocks
+    // directly or a plain text shortcut.
+    const blocks: ContentBlock[] = opts.blocks
+      ?? [{ type: 'text', text: (opts.text ?? '') } as ContentBlock];
+    if (blocks.length === 0) {
+      return { ok: false, status: 'rejected', reason: 'announce requires blocks or text' };
+    }
+    const saved = appendMessage({
+      session_id: opts.sessionId,
+      role: opts.role || 'assistant',
+      blocks,
+    });
+    opts.onEvent?.({ type: 'message_saved', message_id: saved.id, data: saved });
+    return { ok: true, status: 'announced', messageId: saved.id };
+  }
+
+  // 'turn' mode — agent must drive a response.
+  const text = (opts.text || '').trim();
+  if (!text) {
+    return { ok: false, status: 'rejected', reason: 'turn mode requires non-empty text' };
+  }
+
+  // If a turn is already in flight on this session, queue the text as
+  // a note for that running turn. The loop splices each note in at the
+  // next iteration boundary (see agent-loop.ts:790). This is the merge
+  // semantic — replaces every caller having to gate isTurnRunning itself.
+  if (isTurnRunning(opts.sessionId)) {
+    const queued = addNote(opts.sessionId, text);
+    if (queued) return { ok: true, status: 'merged' };
+    // Tiny race: isTurnRunning was true but endTurn fired between the
+    // check and addNote. Fall through to start a fresh turn.
+  }
+
+  // Atomic claim — closes the gap between this check and the in-loop
+  // beginTurn() call inside runTurn. runTurn does ~100ms of async setup
+  // (appendMessage, listMessagesCapped, provider resolve, SSE pushes)
+  // BEFORE its beginTurn runs; without claiming here, a second input
+  // arriving during that window would also see isTurnRunning=false and
+  // fork another runTurn. Both then race on the same chat history and
+  // produce duplicate tool calls (observed 2026-06-10: watch + user
+  // input → two save_tmp_file calls, two LLM replies).
+  //
+  // If tryBeginTurn returns false, another caller claimed first within
+  // the same JS tick — merge as a note into THAT turn instead. Cheap +
+  // correct: addNote on a now-running session always succeeds.
+  const claimed = tryBeginTurn(opts.sessionId);
+  if (!claimed) {
+    addNote(opts.sessionId, text);
+    return { ok: true, status: 'merged' };
+  }
+
+  // Claimed — start a fresh one. Fire-
+  // and-forget; errors land on the onEvent stream as 'error' events.
+  // Two failure modes:
+  //   (a) runTurn throws (rejected Promise) — caught by .catch.
+  //   (b) runTurn resolves with {ok:false, error:'...'} — handled in
+  //       the .then; this case happens in agent-loop's known-error
+  //       paths (context budget exhausted / orphan tool-use trim /
+  //       fetch failure with adapter detail). Missing this branch
+  //       would leave the UI hanging with no error indicator.
+  const startedAt = Date.now();
+  const onEvent = opts.onEvent;
+  void runTurn({
+    sessionId: opts.sessionId,
+    userText: text,
+    callbacks: { onEvent: onEvent || (() => {}) },
+  }).then((r) => {
+    if (!r.ok) {
+      onEvent?.({ type: 'error', data: { error: r.error || 'turn failed' } });
+    }
+    const ms = Date.now() - startedAt;
+    console.log(`[chat] turn ${opts.sessionId.slice(0, 8)} (${opts.source}) done in ${ms}ms ok=${r.ok}`);
+  }).catch((err) => {
+    console.error(`[input-queue] runTurn threw (source=${opts.source}):`, (err as Error).message);
+    onEvent?.({ type: 'error', data: { error: (err as Error).message } });
+  });
+  return { ok: true, status: 'started' };
+}

package/lib/chat/turn-control.ts

@@ -31,12 +31,40 @@ function get(sessionId: string): TurnControl {
   return c;
 }
 
-/** Mark a turn as live. Resets abort + drains stale notes from any prior turn. */
+/** Mark a turn as live. Called by agent-loop at the top of runTurn.
+ *  Sets running:true + aborted:false. Does NOT clear notes — endTurn
+ *  is the one that clears them at completion. Important: if a turn was
+ *  claimed via tryBeginTurn in enqueueChatInput and a note arrived in
+ *  the async window before runTurn reached this point, the note must
+ *  survive to be picked up at the first iteration boundary. Wiping
+ *  here would silently drop user input. */
 export function beginTurn(sessionId: string): void {
   const c = get(sessionId);
   c.running = true;
   c.aborted = false;
-  c.notes = [];
+  // notes intentionally preserved — see comment above.
+}
+
+/** Atomic claim — if no turn is running, mark running and return true.
+ *  If a turn is already running, return false (caller should merge as note).
+ *  Synchronous — closes the race window between "check isTurnRunning" and
+ *  runTurn actually entering its loop and calling beginTurn. Without this,
+ *  two enqueueChatInput calls arriving while runTurn is still in its async
+ *  setup phase BOTH see isTurnRunning=false and BOTH fork a turn — exactly
+ *  the duplicate-turn bug observed on 2026-06-10 (watch fired, user typed
+ *  immediately after, both got separate runTurns and produced doubled
+ *  tool calls). */
+export function tryBeginTurn(sessionId: string): boolean {
+  const c = get(sessionId);
+  if (c.running) return false;
+  c.running = true;
+  c.aborted = false;
+  // notes intentionally NOT cleared here — any addNote that landed in
+  // the race window before claim is valid input for THIS new turn.
+  // beginTurn (called by agent-loop on entry) will set notes=[] only if
+  // this is the very first turn; otherwise the prior endTurn already
+  // cleared them.
+  return true;
 }
 
 /** Turn finished (normally or via abort) — clear all transient state. */

package/lib/chat-standalone.ts

@@ -33,10 +33,11 @@
 import { createServer, type IncomingMessage, type ServerResponse } from 'node:http';
 import {
   createSession, getSession, listSessions, updateSession, deleteSession, listMessages,
-  clearSessionMessages, ensureMainSession, forkSession, appendMessage,
+  clearSessionMessages, ensureMainSession, forkSession,
 } from './chat/session-store';
-import { runTurn, type AgentEvent } from './chat/agent-loop';
+import { type AgentEvent } from './chat/agent-loop';
 import { requestAbort, addNote, isTurnRunning } from './chat/turn-control';
+import { enqueueChatInput } from './chat/input-queue';
 import { bridgePush } from './chat/bridge-client';
 import { startWatchRunner } from './watch/watch-runner';
 
@@ -174,36 +175,21 @@ async function handleMessagePost(req: IncomingMessage, res: ServerResponse, id:
   const text = String(body?.text || '').trim();
   if (!text) return sendJson(res, 400, { error: 'text is required' });
 
-  // Merge instead of forking: if a turn is already running on this session,
-  // queue the text as a note for the running turn instead of starting a
-  // second concurrent runTurn. Two parallel loops on the same session
-  // (e.g. extension + webchat both sending) would otherwise interleave
-  // tool calls and share turn-control state — one abort would stop both,
-  // and the user sees the same task twice. This makes the merge happen
-  // server-side so it doesn't depend on which client is sending.
-  if (isTurnRunning(id)) {
-    const queued = addNote(id, text);
-    if (queued) {
-      return sendJson(res, 202, { accepted: true, merged: true, topic: `chat:${id}` });
-    }
-    // Tiny race window: isTurnRunning was true but turn ended before we
-    // queued. Fall through to start a fresh turn with this text.
-  }
-
-  const startedAt = Date.now();
-  void runTurn({
+  // Route through the single input queue — handles isTurnRunning merge
+  // (so extension + webchat sending on same session collapse into one
+  // turn) without this handler caring how. See lib/chat/input-queue.ts.
+  const r = enqueueChatInput({
     sessionId: id,
-    userText: text,
-    callbacks: { onEvent: (e: AgentEvent) => fanoutEvent(id, e) },
-  }).then((r) => {
-    if (!r.ok) fanoutEvent(id, { type: 'error', data: { error: r.error || 'unknown' } });
-    console.log(`[chat] turn ${id.slice(0, 8)} done in ${Date.now() - startedAt}ms ok=${r.ok}`);
-  }).catch((err) => {
-    fanoutEvent(id, { type: 'error', data: { error: (err as Error).message } });
-    console.error('[chat] turn error', err);
+    text,
+    mode: 'turn',
+    source: 'user',
+    onEvent: (e) => fanoutEvent(id, e),
+  });
+  sendJson(res, 202, {
+    accepted: true,
+    merged: r.status === 'merged',
+    topic: `chat:${id}`,
   });
-
-  sendJson(res, 202, { accepted: true, topic: `chat:${id}` });
 }
 
 /**
@@ -221,11 +207,18 @@ async function handleInjectMessage(req: IncomingMessage, res: ServerResponse, id
   const role: 'user' | 'assistant' = body?.role === 'user' ? 'user' : 'assistant';
   const blocks = Array.isArray(body?.blocks) ? body.blocks : null;
   if (!blocks || blocks.length === 0) return sendJson(res, 400, { error: 'blocks[] required' });
-  const saved = appendMessage({ session_id: id, role, blocks });
-  // Payload shape must match what agent-loop emits — extension's
-  // messageFromServer(event.data) reads .id/.role/.blocks/.ts directly.
-  fanoutEvent(id, { type: 'message_saved', message_id: saved.id, data: saved });
-  sendJson(res, 200, { ok: true, message_id: saved.id });
+  // Announce mode — persist + SSE push, no agent invocation. Goes
+  // through the same input-queue for consistency (one entry point).
+  const r = enqueueChatInput({
+    sessionId: id,
+    blocks,
+    role,
+    mode: 'announce',
+    source: 'schedule',
+    onEvent: (e) => fanoutEvent(id, e),
+  });
+  if (!r.ok) return sendJson(res, 400, { error: r.reason || 'enqueue failed' });
+  sendJson(res, 200, { ok: true, message_id: r.messageId });
 }
 
 // Abort the in-flight tool-call loop for a session. The loop breaks at its
@@ -361,8 +354,18 @@ httpServer.listen(PORT, '127.0.0.1', () => {
   startWatchRunner({
     onProgress: (sessionId, payload) => fanoutEvent(sessionId, { type: 'watch_status', data: payload }),
     runChat: (sessionId, text) => {
-      void runTurn({ sessionId, userText: text, callbacks: { onEvent: (e) => fanoutEvent(sessionId, e) } })
-        .catch((err) => console.error('[watch] runChat failed', (err as Error).message));
+      // Watch-triggered chat input. Routes through the single input
+      // queue — automatically merges into a running turn (as a note)
+      // or starts a fresh one. Without going through enqueueChatInput
+      // a watch firing mid-turn would spawn a concurrent runTurn and
+      // produce duplicate tool calls (regression seen on 2026-06-09).
+      enqueueChatInput({
+        sessionId,
+        text,
+        mode: 'turn',
+        source: 'watch',
+        onEvent: (e) => fanoutEvent(sessionId, e),
+      });
     },
   });
 });

package/lib/init.ts

@@ -182,6 +182,20 @@ export function ensureInitialized() {
     }, 60 * 60 * 1000);
   } catch {}
 
+  // Reconcile orphaned tasks — any DB row at status='running' or 'queued'
+  // at startup is by definition stuck (its parent next-server process is
+  // gone; we're booting the new one). Without this, the Activity panel
+  // shows zombie tasks indefinitely and dispatch_task can collide with
+  // stale project locks. Idempotent — second boot finds zero.
+  time('reconcileOrphanedTasks', () => {
+    try {
+      const { reconcileOrphanedTasks } = require('./task-manager');
+      reconcileOrphanedTasks();
+    } catch (e) {
+      console.warn('[init] reconcileOrphanedTasks failed:', (e as Error).message);
+    }
+  });
+
   // Usage scanner — defer to next tick so it doesn't block ensureInitialized().
   // On a host with hundreds of project dirs in ~/.claude/projects/, the
   // synchronous readdirSync + statSync loop can take 5-10s; running it on

package/lib/pipeline.ts

@@ -1589,6 +1589,17 @@ export async function retryNode(pipelineId: string, nodeId: string): Promise<{ o
   // underlying task is dead); cancelled covers user-cancelled pipelines
   // where the user later wants to resume from the cancelled node.
   // pending/done/skipped are still misclicks.
+  //
+  // 'skipped' specifically is NOT retriable here — in forEach pipelines
+  // orchestrator marks a per-iter step 'skipped' to indicate "this
+  // iteration failed but we're continuing to the next item" (not the
+  // usual "upstream-failed → skip downstream" semantic). Letting retry
+  // touch a skipped node would risk re-firing iteration logic that the
+  // orchestrator already decided to abandon, terminating the whole
+  // for_each loop. If a real upstream-failure-cascade arises and the
+  // user needs to retry a skipped downstream, the right path is to
+  // retry the failed root explicitly — its BFS-downstream reset will
+  // pull this node back to pending.
   if (nodeState.status !== 'failed' && nodeState.status !== 'running' && nodeState.status !== 'cancelled') {
     return { ok: false, error: `node is in status '${nodeState.status}' — only failed, running, or cancelled nodes can be retried` };
   }

package/lib/task-manager.ts

@@ -123,6 +123,36 @@ export function getTask(id: string): Task | null {
   return rowToTask(row);
 }
 
+/**
+ * Reconcile orphaned 'running' tasks. Tasks spawn child processes
+ * owned by next-server (lib/claude-process); when next-server exits
+ * (forge restart / crash / stop), those processes die but the DB row
+ * stays at status='running' forever. Result: Activity panel /
+ * /api/activity/summary keeps showing zombie tasks the user never
+ * started; new dispatches can collide with stuck project locks.
+ *
+ * Called once at init.ts startup. Any row still showing 'running' is
+ * by definition orphaned — its parent next-server process is gone
+ * (otherwise we wouldn't be in startup). Mark all as failed with a
+ * clear error so the user knows it was a restart, not a real failure.
+ *
+ * Idempotent — second run finds zero rows to update.
+ */
+export function reconcileOrphanedTasks(): number {
+  const r = db().prepare(`
+    UPDATE tasks
+       SET status = 'failed',
+           error = COALESCE(NULLIF(error, ''), 'orphaned by server restart — task process did not survive restart'),
+           completed_at = datetime('now')
+     WHERE status IN ('running', 'queued')
+  `).run();
+  const n = (r.changes as number) || 0;
+  if (n > 0) {
+    console.log(`[task-manager] reconciled ${n} orphaned task(s) (running→failed)`);
+  }
+  return n;
+}
+
 export function listTasks(status?: TaskStatus): Task[] {
   let query = 'SELECT * FROM tasks';
   const params: string[] = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aion0/forge",
-  "version": "0.10.55",
+  "version": "0.10.57",
   "description": "Unified AI workflow platform — multi-model task orchestration, persistent sessions, web terminal, remote access",
   "type": "module",
   "scripts": {