@aion0/forge 0.10.53 → 0.10.56

package/components/ScratchViewer.tsx

@@ -16,7 +16,18 @@ function extOf(p: string): string {
   return m ? m[1].toLowerCase() : '';
 }
 
-export default function ScratchViewer({ path }: { path: string }) {
+export default function ScratchViewer({
+  path,
+  apiBase = '/api/scratch',
+  topLabel = 'scratch',
+}: {
+  path: string;
+  /** API route prefix. /api/scratch resolves under <dataDir>/scratch/;
+   *  /api/files resolves dataDir-wide. Default scratch for back-compat. */
+  apiBase?: string;
+  /** Tiny header tag shown next to the file path (e.g. "scratch", "file"). */
+  topLabel?: string;
+}) {
   const decoded = (() => {
     try {
       return decodeURIComponent(path);
@@ -25,7 +36,7 @@ export default function ScratchViewer({ path }: { path: string }) {
     }
   })();
   const ext = extOf(decoded);
-  const rawUrl = `/api/scratch/${path}`;
+  const rawUrl = `${apiBase}/${path}`;
   const downloadUrl = `${rawUrl}?download=1`;
 
   const [text, setText] = useState<string | null>(null);
@@ -67,7 +78,7 @@ export default function ScratchViewer({ path }: { path: string }) {
     <div className="min-h-screen bg-[var(--bg-primary)] text-[var(--text-primary)]">
       <header className="sticky top-0 z-10 flex items-center justify-between gap-2 px-4 py-2 border-b border-[var(--border)] bg-[var(--bg-secondary)]">
         <div className="flex items-center gap-2 min-w-0">
-          <span className="text-[10px] uppercase tracking-wide text-[var(--text-secondary)]">scratch</span>
+          <span className="text-[10px] uppercase tracking-wide text-[var(--text-secondary)]">{topLabel}</span>
           <span className="text-xs font-mono truncate" title={decoded}>
             {decoded}
           </span>

package/lib/chat/agent-loop.ts

@@ -28,6 +28,7 @@ import { buildMemoryContext } from './build-memory-context';
 import { buildReferencePromptSection } from './reference-prompt';
 import { buildMemoryTools } from './memory-tools';
 import { buildStartWatchTool } from '../watch/start-watch-tool';
+import { beginTurn, endTurn, isAborted, consumeNotes } from './turn-control';
 import { estimateTokens } from '../memory/token-estimate';
 import {
   listInstalledConnectors,
@@ -419,9 +420,16 @@ function buildSystemPrompt(
     }
   }
   if (builtinDefs.length > 0) {
+    // Builtins are always-active (no connector_open gate) — list their
+    // FULL description so per-tool rules like "save_tmp_file: output
+    // user_message verbatim" / "dispatch_task: ASK before classifying
+    // a save as a task" reach the LLM here, not just buried in the
+    // tools schema. The connector catalog above can be terse because
+    // those tools only become live after connector_open; builtins
+    // never go through that gate, so terseness here loses real guidance.
     lines.push('', 'Builtin tools (always available):');
     for (const t of builtinDefs) {
-      lines.push(`- ${t.name}: ${t.description.slice(0, 100)}`);
+      lines.push(`- ${t.name}: ${t.description}`);
     }
   }
 
@@ -559,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}` } });
@@ -754,10 +775,53 @@ export async function runTurn(args: RunTurnArgs): Promise<{ ok: boolean; error?:
   let lastStop = '';
   let assistantBlocksAccum: ContentBlock[] = [];
 
+  // 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;
 
+      // ── User intervention (turn-control) ────────────────────────
+      // Abort: stop the loop cleanly at this boundary with a sentinel so
+      // the turn doesn't just vanish. (The current in-flight LLM call /
+      // tool batch from the previous iteration has already settled here.)
+      if (isAborted(args.sessionId)) {
+        const stopMsg = appendMessage({
+          session_id: args.sessionId,
+          role: 'assistant',
+          blocks: [{ type: 'text', text: '⏹ Stopped by user.' } as TextBlock],
+        });
+        cb({ type: 'message_saved', message_id: stopMsg.id, data: stopMsg });
+        lastStop = 'aborted';
+        break;
+      }
+      // Supplementary notes: splice any queued user notes in as a user
+      // message so THIS iteration's LLM call sees them. Safe after a
+      // tool_result message — the adapter emits that as a `tool` message,
+      // so a following `user` message doesn't collide on role.
+      // Drain notes — each becomes its own user message so the thread
+      // shows them in arrival order (matches the optimistic messages the
+      // client already rendered when the user hit Send). The first note
+      // carries a flag for the model so it knows this is a mid-task
+      // redirect, not ambient chat; subsequent notes go raw to avoid
+      // cluttering the visible thread.
+      const notes = consumeNotes(args.sessionId);
+      if (notes.length > 0) {
+        const FLAG = '[mid-task interjection — sent WHILE you were running tools. Treat as an authoritative redirect that overrides any plan you announced earlier (count, target, scope). Adjust on the very next step.]';
+        for (let i = 0; i < notes.length; i++) {
+          const text = i === 0 ? `${FLAG}\n\n${notes[i]}` : notes[i]!;
+          const noteMsg = appendMessage({
+            session_id: args.sessionId,
+            role: 'user',
+            blocks: [{ type: 'text', text } as TextBlock],
+          });
+          cb({ type: 'message_saved', message_id: noteMsg.id, data: noteMsg });
+        }
+      }
+
       // ── Recompute open set every iteration ──────────────────────
       // Scan history (since last user text msg) + this turn's accumulated
       // blocks → which connectors are open right now. Then filter tools.
@@ -885,10 +949,28 @@ export async function runTurn(args: RunTurnArgs): Promise<{ ok: boolean; error?:
 
       if (result.stopReason !== 'tool_use') break;
 
-      // Execute tool calls
+      // Execute tool calls. The LLM can emit several tool_use blocks per
+      // iteration (parallel batch). Without an in-batch abort check, a
+      // user who clicks Stop after the batch starts has to wait for ALL
+      // tools to finish before the loop top-check fires next iter — feels
+      // like Stop did nothing. So: between tools, if abort was requested,
+      // skip the remaining ones with synthetic "aborted" tool_results
+      // (the tool_use/tool_result pairing invariant must hold for the
+      // Anthropic API; an orphan tool_use rejects the next call).
       const toolUses = result.content.filter((b): b is ToolUseBlock => b.type === 'tool_use');
       const toolResults: ToolResultBlock[] = [];
       for (const t of toolUses) {
+        if (isAborted(args.sessionId)) {
+          const block: ToolResultBlock = {
+            type: 'tool_result',
+            tool_use_id: t.id,
+            content: '⏹ Skipped — user requested stop.',
+            is_error: true,
+          };
+          toolResults.push(block);
+          cb({ type: 'tool_result', data: { tool_use_id: t.id, name: t.name, result: { content: block.content, is_error: true } } });
+          continue;
+        }
         const r = await dispatchTool({ id: t.id, name: t.name, input: t.input }, { extraBuiltins: memHandlers, sessionId: args.sessionId });
         const block: ToolResultBlock = {
           type: 'tool_result',
@@ -961,4 +1043,15 @@ 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/link-patterns.ts

@@ -81,17 +81,40 @@ export const LINK_PATTERNS: LinkPattern[] = [
     url: 'https://nvd.nist.gov/vuln/detail/{1}',
     label: '{1}',
   },
-  // Forge scratch-dir files. LLMs frequently emit paths like
-  // `scratch/foo.md` when they write reports during chat-launched tasks.
-  // Link to the in-browser viewer at /scratch/<path> (page renders .md
-  // through the chat markdown component + download button); the viewer
-  // itself fetches /api/scratch/<path> for raw bytes.
+  // Forge-managed files inside <dataDir>/. LLMs emit:
+  //   • `scratch/foo.md`  — legacy task-workspace writes (kept under
+  //                         <dataDir>/scratch/, served by /scratch viewer)
+  //   • `tmp/foo.md`      — chat's save_tmp_file output (<dataDir>/tmp/)
+  //   • `flows/x.yaml`    — pipeline workflow definitions
+  //   • `prompts/y.yaml`  — schedule prompt bodies
+  // All four resolve through the /files/<dataDir-path> viewer (rendered
+  // markdown + download button), which fetches /api/files for raw bytes.
+  // Sensitive top-level items (encrypt key, sqlite DBs, log, token
+  // caches) are blocked at the API layer, so safe to be liberal here.
   {
     id: 'scratch-file',
     regex: /\bscratch\/([\w\-./]+?\.(?:md|txt|json|yaml|yml|csv|log|html|pdf|png|jpg|jpeg|gif|svg))\b/gi,
     url: '/scratch/{1}',
     label: 'scratch/{1}',
   },
+  {
+    id: 'tmp-file',
+    regex: /\btmp\/([\w\-./]+?\.(?:md|txt|json|yaml|yml|csv|log|html|pdf|png|jpg|jpeg|gif|svg))\b/gi,
+    url: '/files/tmp/{1}',
+    label: 'tmp/{1}',
+  },
+  {
+    id: 'flows-file',
+    regex: /\bflows\/([\w\-./]+?\.(?:yaml|yml|json))\b/gi,
+    url: '/files/flows/{1}',
+    label: 'flows/{1}',
+  },
+  {
+    id: 'prompts-file',
+    regex: /\bprompts\/([\w\-./]+?\.(?:yaml|yml|md|txt))\b/gi,
+    url: '/files/prompts/{1}',
+    label: 'prompts/{1}',
+  },
 ];
 
 export interface CompiledPattern {