@aion0/forge 0.10.33 → 0.10.34

package/RELEASE_NOTES.md

@@ -1,23 +1,14 @@
-# Forge v0.10.33
+# Forge v0.10.34
 
-Released: 2026-06-02
+Released: 2026-06-03
 
-## Changes since v0.10.32
-
-### Documentation
-- docs: update help-docs for activity pill, marketplace, usage move, watch builtins
+## Changes since v0.10.33
 
 ### Other
-- refactor(marketplace): Pipelines first + default landing
-- refactor(dashboard): move Activity pill next to Automation tab
-- refactor(dashboard): promote Chat (web) + open standalone routes in new tab
-- refactor(dashboard): promote Settings, add icons to user menu rows
-- refactor(dashboard): move Usage into user menu next to Monitor/Login Status
-- refactor(marketplace): split category dropdown by group
-- perf(pipeline-view): invalidate cache after mutations
-- fix(activity): view link uses forge:navigate event
-- perf(pipeline-view): module-level SWR cache for meta + per-workflow runs
-- feat(activity): top-right Activity pill — running pipelines + upcoming schedules
+- fix(watch): heuristic terminal detection for all connector pollers
+- ui(activity): segmented pill — running/upcoming/failed each their own color
+- fix(watch): honor poll result's terminal: true regardless of done_match
+- fix(marketplace): scrollbar on long project list in install dropdown
 
 
-**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.10.32...v0.10.33
+**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.10.33...v0.10.34

package/components/ActivityPanel.tsx

@@ -123,25 +123,47 @@ export default function ActivityPanel() {
   const runningCount = summary?.running.length ?? 0;
   const upcomingCount = summary?.upcoming.length ?? 0;
   const recentFailed = (summary?.recent ?? []).filter((r) => r.status === 'failed').length;
+  const hasAny = runningCount + upcomingCount + recentFailed > 0;
 
-  // Pill chips
-  const chips: string[] = [];
-  if (runningCount) chips.push(`▶${runningCount}`);
-  if (upcomingCount) chips.push(`⏰${upcomingCount}`);
-  if (!chips.length) chips.push('✓');
+  // Pill border tint picks the most urgent state:
+  // failed (red) > running (blue) > else dim.
+  const borderTint = recentFailed > 0
+    ? 'border-red-500/50'
+    : runningCount > 0
+      ? 'border-blue-500/50'
+      : 'border-[var(--border)]';
 
   return (
     <div className="relative" ref={panelRef}>
       <button
         onClick={() => setOpen((o) => !o)}
-        className={`text-[10px] px-2 py-0.5 rounded border border-[var(--border)] flex items-center gap-1.5
-          ${runningCount > 0 ? 'text-blue-400 border-blue-500/50' : 'text-[var(--text-secondary)]'}
-          hover:text-[var(--text-primary)]`}
-        title="Activity — running pipelines + upcoming schedules"
+        className={`text-[10px] px-2 py-0.5 rounded border ${borderTint} flex items-center gap-2.5
+          text-[var(--text-secondary)] hover:text-[var(--text-primary)]`}
+        title="Activity — running pipelines · upcoming schedules · recent failures"
       >
-        <span className="font-medium">{chips.join(' ')}</span>
-        {recentFailed > 0 && (
-          <span className="text-red-400 text-[9px]" title={`${recentFailed} recently failed`}>!{recentFailed}</span>
+        {!hasAny ? (
+          <span className="text-[var(--text-secondary)]">✓</span>
+        ) : (
+          <>
+            {runningCount > 0 && (
+              <span className="inline-flex items-baseline text-blue-400" title={`${runningCount} running`}>
+                <span className="text-[7px] mr-0.5">●</span>
+                <span className="font-semibold tabular-nums">{runningCount}</span>
+              </span>
+            )}
+            {upcomingCount > 0 && (
+              <span className="inline-flex items-baseline text-[var(--text-secondary)]" title={`${upcomingCount} upcoming`}>
+                <span className="text-[8px] mr-0.5">◷</span>
+                <span className="font-semibold tabular-nums">{upcomingCount}</span>
+              </span>
+            )}
+            {recentFailed > 0 && (
+              <span className="inline-flex items-baseline text-red-400" title={`${recentFailed} recently failed`}>
+                <span className="text-[8px] mr-0.5">✕</span>
+                <span className="font-semibold tabular-nums">{recentFailed}</span>
+              </span>
+            )}
+          </>
         )}
       </button>
 

package/components/SkillsPanel.tsx

@@ -732,7 +732,7 @@ export default function SkillsPanel({ projectFilter }: { projectFilter?: string
                             {installTarget.skill === itemName && installTarget.show && (
                               <>
                                 <div className="fixed inset-0 z-40" onClick={() => setInstallTarget({ skill: '', show: false })} />
-                                <div className="absolute right-0 top-7 w-[200px] bg-[var(--bg-secondary)] border border-[var(--border)] rounded-lg shadow-xl z-50 py-1">
+                                <div className="absolute right-0 top-7 w-[200px] max-h-[60vh] overflow-y-auto bg-[var(--bg-secondary)] border border-[var(--border)] rounded-lg shadow-xl z-50 py-1">
                                   <button
                                     onClick={async () => {
                                       const res = await fetch('/api/skills/local', { method: 'POST', headers: { 'Content-Type': 'application/json' },
@@ -743,7 +743,7 @@ export default function SkillsPanel({ projectFilter }: { projectFilter?: string
                                       setInstallTarget({ skill: '', show: false });
                                       fetchSkills();
                                     }}
-                                    className="w-full text-left text-[10px] px-3 py-1.5 hover:bg-[var(--bg-tertiary)] text-[var(--text-primary)]"
+                                    className="w-full text-left text-[10px] px-3 py-1.5 hover:bg-[var(--bg-tertiary)] text-[var(--text-primary)] sticky top-0 bg-[var(--bg-secondary)]"
                                   >Global (~/.claude)</button>
                                   <div className="border-t border-[var(--border)] my-0.5" />
                                   {projects.map(p => (
@@ -792,10 +792,10 @@ export default function SkillsPanel({ projectFilter }: { projectFilter?: string
                         {installTarget.skill === skill.name && installTarget.show && (
                           <>
                             <div className="fixed inset-0 z-40" onClick={() => setInstallTarget({ skill: '', show: false })} />
-                            <div className="absolute right-0 top-7 w-[180px] bg-[var(--bg-secondary)] border border-[var(--border)] rounded-lg shadow-xl z-50 py-1">
+                            <div className="absolute right-0 top-7 w-[180px] max-h-[60vh] overflow-y-auto bg-[var(--bg-secondary)] border border-[var(--border)] rounded-lg shadow-xl z-50 py-1">
                               <button
                                 onClick={() => install(skill.name, 'global')}
-                                className={`w-full text-left text-[10px] px-3 py-1.5 hover:bg-[var(--bg-tertiary)] ${
+                                className={`w-full text-left text-[10px] px-3 py-1.5 hover:bg-[var(--bg-tertiary)] sticky top-0 bg-[var(--bg-secondary)] ${
                                   skill.installedGlobal ? 'text-[var(--green)]' : 'text-[var(--text-primary)]'
                                 }`}
                               >

package/lib/chat/agent-loop.ts

@@ -431,7 +431,7 @@ export async function runTurn(args: RunTurnArgs): Promise<{ ok: boolean; error?:
       memStore.listBlocks({ pinned: true, scope: 'both' }),
       memStore.listBlocks({ scope: 'both' }),
       memStore.search(args.userText, 8),
-      buildMemoryContext({ store: memStore, currentUserMessage: args.userText }),
+      buildMemoryContext({ store: memStore, currentUserMessage: args.userText, currentSessionId: args.sessionId }),
     ]);
     const pinnedBlocks = bp.status === 'fulfilled' ? bp.value : [];
     const allBlocks = ba.status === 'fulfilled' ? ba.value : [];
@@ -497,17 +497,38 @@ export async function runTurn(args: RunTurnArgs): Promise<{ ok: boolean; error?:
     ...memTools.map((m) => m.def),
     watchTool.def,
   ];
-  const allTools: LlmTool[] = [
-    ...builtinDefsAll.map((t) => ({
-      name: t.name,
-      description: t.description,
-      input_schema: t.input_schema,
-    })),
-    ...connectorTools,
-  ];
+  const builtinToolDefs: LlmTool[] = builtinDefsAll.map((t) => ({
+    name: t.name,
+    description: t.description,
+    input_schema: t.input_schema,
+  }));
+
+  // ── Sticky narrow helper ─────────────────────────────────────────
+  // After a turn that called connector tools, on the NEXT turn we
+  // restrict tool list to ONLY the connectors that were used. This
+  // shrinks tools from 99 → ~10 in a typical mantis or nac flow,
+  // saving ~18K tokens per turn AND letting the model focus its
+  // attention (helps local models avoid hallucination).
+  function pickConnectorNamespacesUsed(blocks: ContentBlock[]): Set<string> {
+    const ns = new Set<string>();
+    for (const b of blocks) {
+      if (b.type === 'tool_use' && b.name.includes('.')) {
+        ns.add(b.name.split('.')[0]!);
+      }
+    }
+    return ns;
+  }
+  const sessionSystemPrompt = session.system_prompt;
+  function buildSystem(tools: LlmTool[]): string {
+    let s = buildSystemPrompt(tools, builtinDefsAll, sessionSystemPrompt);
+    if (narrowDirective) s += narrowDirective;
+    return s;
+  }
+
+  const baseConnectorTools = connectorTools;  // post-initial-narrow snapshot
+  let allTools: LlmTool[] = [...builtinToolDefs, ...baseConnectorTools];
 
-  let system = buildSystemPrompt(connectorTools, builtinDefsAll, session.system_prompt);
-  if (narrowDirective) system += narrowDirective;
+  let system = buildSystem(baseConnectorTools);
   if (memContext) system += '\n\n─── Memory context (auto-loaded) ───\n' + memContext;
   if (memStore.enabled) {
     const searchHint = memStore.kind === 'local'
@@ -538,9 +559,39 @@ export async function runTurn(args: RunTurnArgs): Promise<{ ok: boolean; error?:
         return { ok: false, error: 'empty history' };
       }
 
+      // ── Sticky narrow: shrink tools to only what last turn actually used.
+      // First iteration: keep the user-mention-narrowed list. Iter 2+:
+      // if previous assistant turn called e.g. mantis.get_bug, restrict
+      // to mantis.* only — local models behave much better with focused
+      // tool set, and we save ~18K tokens per turn.
+      if (iter > 1 && assistantBlocksAccum.length > 0) {
+        const usedNs = pickConnectorNamespacesUsed(assistantBlocksAccum);
+        if (usedNs.size > 0) {
+          const narrowedConn = baseConnectorTools.filter((t) =>
+            usedNs.has(t.name.split('.')[0]!));
+          if (narrowedConn.length > 0 && narrowedConn.length < baseConnectorTools.length) {
+            allTools = [...builtinToolDefs, ...narrowedConn];
+            system = buildSystem(narrowedConn);
+            if (memContext) system += '\n\n─── Memory context (auto-loaded) ───\n' + memContext;
+            console.log(`[chat] sticky narrow → ${[...usedNs].join(',')} (${narrowedConn.length}/${baseConnectorTools.length} connector tools)`);
+          }
+        }
+      }
+
       assistantBlocksAccum = [];
       let currentTextBuf = '';
 
+      // ── Token composition log (input side, BEFORE the call) ──
+      // Heuristic char/4. Lets you correlate later with the provider's
+      // real usage.input_tokens — if the gap widens turn-over-turn, the
+      // memory/tools blob is silently growing.
+      const _systemTok = Math.ceil(system.length / 4);
+      const _memCtxTok = Math.ceil(memContext.length / 4);
+      const _toolsTok  = Math.ceil(JSON.stringify(allTools).length / 4);
+      const _historyTok = history.reduce((s, m) => s + estimateTokens(m), 0);
+      const _historyMsgs = history.length;
+      console.log(`[chat-tokens] session=${args.sessionId} turn=${iter} est_in=${_systemTok + _historyTok + _toolsTok} system=${_systemTok} history=${_historyTok}(${_historyMsgs}msgs) memory=${_memCtxTok} tools=${_toolsTok}`);
+
       const result = await streamLlm(
         {
           provider: provider.type,
@@ -563,6 +614,12 @@ export async function runTurn(args: RunTurnArgs): Promise<{ ok: boolean; error?:
         },
       );
 
+      // ── Real usage from the provider (when reported) ──
+      if (result.usage) {
+        const u = result.usage;
+        console.log(`[chat-tokens] session=${args.sessionId} turn=${iter} REAL in=${u.inputTokens ?? '?'} out=${u.outputTokens ?? '?'} cache_read=${u.cacheReadTokens ?? 0} cache_create=${u.cacheCreationTokens ?? 0} stop=${result.stopReason}`);
+      }
+
       lastStop = result.stopReason;
       assistantBlocksAccum = result.content;
 

package/lib/chat/build-memory-context.ts

@@ -31,6 +31,10 @@ export interface BuildMemoryContextOpts {
   /** Prefixes that mark internal-only blocks (cursor / health / etc).
    *  Defaults to lib/memory/keys.INTERNAL_KEY_PREFIXES. */
   excludeKeyPrefixes?: readonly string[];
+  /** Current chat session id. When set, blocks keyed `chat:<otherId>:*`
+   *  are dropped — other sessions' summaries are noise in this chat and
+   *  were the primary source of "old data bleeding into new chat". */
+  currentSessionId?: string;
 }
 
 export interface BuildMemoryContextResult {
@@ -46,18 +50,22 @@ export async function buildMemoryContext(opts: BuildMemoryContextOpts): Promise<
     topK = 6,
     maxBlocks = 50,
     excludeKeyPrefixes = INTERNAL_KEY_PREFIXES,
+    currentSessionId,
   } = opts;
 
-  const blocks = filterInternal(
-    await safe(() => store.listBlocks({ pinned: true }), [] as MemoryBlock[]),
-    excludeKeyPrefixes,
+  const blocks = dropForeignChat(
+    filterInternal(
+      await safe(() => store.listBlocks({ pinned: true }), [] as MemoryBlock[]),
+      excludeKeyPrefixes,
+    ),
+    currentSessionId,
   ).slice(0, maxBlocks);
 
   const q = (currentUserMessage || '').trim();
   let hits: SearchHit[] = [];
   if (q) {
     const rawHits = await safe(() => store.search(q, topK), [] as SearchHit[]);
-    hits = filterInternalHits(rawHits, excludeKeyPrefixes);
+    hits = dropForeignChatHits(filterInternalHits(rawHits, excludeKeyPrefixes), currentSessionId);
   }
 
   return { text: renderMemoryContext(blocks, hits), blocks, hits };
@@ -81,6 +89,30 @@ function filterInternalHits(hits: SearchHit[], prefixes: readonly string[]): Sea
   });
 }
 
+/** Strip `chat:<otherSessionId>:*` blocks. Summary blocks contain raw
+ *  past-conversation excerpts; surfacing them in a different chat is
+ *  what made "new empty chat" leak old session content. Facts
+ *  (`fact:*`) and any non-chat-prefixed pinned blocks stay — they're
+ *  the intentional cross-session signal. No-op if no sessionId given. */
+function dropForeignChat(blocks: MemoryBlock[], sessionId?: string): MemoryBlock[] {
+  if (!sessionId) return blocks;
+  return blocks.filter((b) => isOwnChatOrNotChat(b.key, sessionId));
+}
+
+function dropForeignChatHits(hits: SearchHit[], sessionId?: string): SearchHit[] {
+  if (!sessionId) return hits;
+  return hits.filter((h) => {
+    if (!h.id?.startsWith('block:')) return true; // Graphiti hit, no key to inspect — keep
+    return isOwnChatOrNotChat(h.id.slice('block:'.length), sessionId);
+  });
+}
+
+function isOwnChatOrNotChat(key: string, sessionId: string): boolean {
+  if (!key.startsWith('chat:')) return true;
+  // key shape: chat:<sessionId>:summary:<ts> → split[1] === sessionId
+  return key.split(':', 2)[1] === sessionId;
+}
+
 async function safe<T>(fn: () => Promise<T>, fallback: T): Promise<T> {
   try {
     return await fn();

package/lib/chat/llm/anthropic.ts

@@ -132,14 +132,30 @@ export const anthropicAdapter: LlmAdapter = {
     // execute — chat owns dispatch (destructive confirm, browser bridge,
     // memory tools etc all live in agent-loop). Setting stopWhen with
     // stepCountIs(1) prevents the SDK from auto-rolling a second step.
+    // Build tool record. Mark the LAST tool with cache_control so
+    // Anthropic-family backends (or LiteLLM proxies that forward it)
+    // cache the system+tools prefix. Subsequent turns within the 5-min
+    // TTL pay 0.1× input price for the cached portion instead of 1×.
+    // Backends that don't honor cache_control silently ignore it,
+    // costing nothing.
+    const toolNames = req.tools.map((t) => t.name);
+    const lastName = toolNames[toolNames.length - 1];
     const tools: Record<string, any> = {};
     for (const t of req.tools) {
       tools[encodeToolName(t.name)] = {
         description: t.description,
         inputSchema: jsonSchema(t.input_schema),
+        ...(t.name === lastName ? {
+          providerOptions: {
+            anthropic: { cacheControl: { type: 'ephemeral' } },
+          },
+        } : {}),
       };
     }
 
+    // Single cache breakpoint at end-of-tools — Anthropic caches the
+    // prefix (system + tools) since system comes first in the wire
+    // format. No need to add a separate marker on system.
     const result = streamText({
       model: client(req.model),
       system: req.system,
@@ -169,6 +185,19 @@ export const anthropicAdapter: LlmAdapter = {
     if (textBuf.length > 0) content.push({ type: 'text', text: textBuf });
 
     const finishReason = await result.finishReason;
-    return { stopReason: mapStop(finishReason), content };
+    let usage;
+    try {
+      const u: any = await result.usage;
+      if (u) {
+        usage = {
+          inputTokens: u.inputTokens ?? u.promptTokens,
+          outputTokens: u.outputTokens ?? u.completionTokens,
+          cacheReadTokens: u.cachedInputTokens ?? u.cacheReadInputTokens,
+          cacheCreationTokens: u.cacheCreationInputTokens,
+          totalTokens: u.totalTokens,
+        };
+      }
+    } catch {}
+    return { stopReason: mapStop(finishReason), content, usage };
   },
 };

package/lib/chat/llm/openai.ts

@@ -108,6 +108,17 @@ export const openaiAdapter: LlmAdapter = {
     if (textBuf.length > 0) content.push({ type: 'text', text: textBuf });
 
     const finishReason = await result.finishReason;
-    return { stopReason: mapStop(finishReason), content };
+    let usage;
+    try {
+      const u: any = await result.usage;
+      if (u) {
+        usage = {
+          inputTokens: u.inputTokens ?? u.promptTokens,
+          outputTokens: u.outputTokens ?? u.completionTokens,
+          totalTokens: u.totalTokens,
+        };
+      }
+    } catch {}
+    return { stopReason: mapStop(finishReason), content, usage };
   },
 };

package/lib/chat/llm/types.ts

@@ -21,9 +21,20 @@ export interface LlmCallbacks {
 
 export type StopReason = 'end_turn' | 'tool_use' | 'max_tokens' | 'refusal' | 'error' | 'other';
 
+export interface LlmTurnUsage {
+  inputTokens?: number;
+  outputTokens?: number;
+  cacheReadTokens?: number;
+  cacheCreationTokens?: number;
+  totalTokens?: number;
+}
+
 export interface LlmTurnResult {
   stopReason: StopReason;
   content: ContentBlock[];
+  /** Token usage from the provider, if reported. May be partially-filled
+   *  or absent for proxies that don't expose it. */
+  usage?: LlmTurnUsage;
 }
 
 export interface LlmRequest {

package/lib/chat/session-store.ts

@@ -327,16 +327,67 @@ export function listMessagesCapped(
   // loop (provider will see a single message — still valid).
   const keptGroups: Message[][] = [];
   let used = 0;
+  let evictedCount = 0;
   for (let i = groups.length - 1; i >= 0; i--) {
     const g = groups[i];
     const cost = g.reduce((s, m) => s + estimateTokens(m), 0);
-    if (keptGroups.length > 0 && used + cost > tokenBudget) break;
+    if (keptGroups.length > 0 && used + cost > tokenBudget) {
+      evictedCount = i + 1; // groups [0..i] would have been evicted
+      break;
+    }
     keptGroups.unshift(g);
     used += cost;
   }
+
+  // ── Pin the SESSION's first user message (task brief) ──────────
+  // Even if eviction would normally drop it, the user's opening prompt
+  // defines the task. Losing it causes the model to lose track of
+  // what was asked — symptom: model writes "summarize all X" and
+  // hallucinates instead of processing the specific list the user
+  // gave. Re-fetch the absolute first user message, prepend if not
+  // already in keptGroups. Cap its tokens so a truly enormous brief
+  // can't break the call — keep first ~2k tokens.
+  if (evictedCount > 0) {
+    const firstUserRow = db().prepare(`
+      SELECT * FROM chat_messages WHERE session_id = ? AND role = 'user'
+      ORDER BY ts ASC LIMIT 1
+    `).get(session_id) as MessageRow | undefined;
+    if (firstUserRow) {
+      const firstUserMsg = rowToMessage(firstUserRow);
+      const alreadyKept = keptGroups.some((g) => g.some((m) => m.id === firstUserMsg.id));
+      if (!alreadyKept) {
+        // Cap to ~2000 tokens of brief (≈8KB) — tasks longer than that
+        // should be split anyway; preserving the head is enough to
+        // anchor the model to the original ask.
+        const FIRST_BRIEF_TOKEN_CAP = 2000;
+        let pinned = firstUserMsg;
+        if (estimateTokens(firstUserMsg) > FIRST_BRIEF_TOKEN_CAP) {
+          pinned = clipMessageToTokens(firstUserMsg, FIRST_BRIEF_TOKEN_CAP);
+        }
+        keptGroups.unshift([pinned]);
+        console.log(`[session-cap] pinned first user message (id=${firstUserMsg.id}) — ${evictedCount} groups evicted, ${used} tokens used / ${tokenBudget} budget`);
+      }
+    } else {
+      console.log(`[session-cap] ${evictedCount} groups evicted, no first user message found to pin`);
+    }
+  }
   return keptGroups.flat();
 }
 
+/** Clip a message's text content to a soft token cap. Tool blocks are
+ *  preserved verbatim (they're usually small structural data); only
+ *  long text blocks get a head-only truncation with a marker. */
+function clipMessageToTokens(m: Message, tokenCap: number): Message {
+  const charCap = tokenCap * 4; // matches estimateTokens char/4 heuristic
+  const blocks = m.blocks.map((b) => {
+    if (b.type === 'text' && b.text.length > charCap) {
+      return { ...b, text: b.text.slice(0, charCap) + '\n\n[…task brief truncated to keep in-context]' };
+    }
+    return b;
+  });
+  return { ...m, blocks };
+}
+
 export function deleteMessage(id: string): boolean {
   ensureSchema();
   const r = db().prepare(`DELETE FROM chat_messages WHERE id = ?`).run(id);

package/lib/watch/watch-runner.ts

@@ -40,6 +40,45 @@ function parseResult(content: string): any {
   try { return JSON.parse(content); } catch { return { _raw: content }; }
 }
 
+/** Heuristic: spot common "this work is finished" shapes from a poll
+ *  result, regardless of whether the connector author thought to set
+ *  `terminal: true` or pre-declare done conditions. Walks well-known
+ *  state-bearing fields (state / status / phase / result / done /
+ *  finished / complete / completed) and matches their values against
+ *  a curated vocabulary used across CI, Jenkins, k8s, generic build
+ *  systems, etc.
+ *  Returns { failure } when a hit is found, null otherwise. Intended
+ *  to run AFTER user's explicit done_match/done_path, so a caller who
+ *  configured "done when status == running" (rare but legal) still
+ *  wins. */
+function detectTerminalState(obj: any): { failure: boolean; source: string; value: string } | null {
+  if (!obj || typeof obj !== 'object') return null;
+  // Boolean done-ish flags
+  for (const f of ['done', 'finished', 'complete', 'completed']) {
+    if (truthy(obj[f])) return { failure: false, source: f, value: 'true' };
+  }
+  // State-bearing fields with a terminal vocabulary
+  const fields = ['state', 'status', 'phase', 'result', 'conclusion', 'lifecycle_state'];
+  const failureWords = new Set([
+    'failed', 'failure', 'error', 'errored', 'cancelled', 'canceled',
+    'aborted', 'killed', 'terminated', 'timeout', 'timed_out', 'rejected',
+    'unstable', 'broken',
+  ]);
+  const successWords = new Set([
+    'done', 'success', 'succeeded', 'complete', 'completed', 'finished',
+    'passed', 'ok', 'green', 'healthy',
+  ]);
+  for (const f of fields) {
+    const raw = obj[f];
+    if (raw == null) continue;
+    const v = String(raw).toLowerCase().trim();
+    if (!v) continue;
+    if (failureWords.has(v)) return { failure: true, source: f, value: v };
+    if (successWords.has(v)) return { failure: false, source: f, value: v };
+  }
+  return null;
+}
+
 const g = globalThis as any;
 
 export function startWatchRunner(hooks: WatchRunnerHooks = {}): void {
@@ -120,7 +159,27 @@ export function startWatchRunner(hooks: WatchRunnerHooks = {}): void {
     if (w.fail_path && truthy(getPath(obj, w.fail_path))) {
       return finish(w, 'failed', obj, `${w.label}: failure condition met.`);
     }
-    // done check
+    // Hard terminal check — if the poll tool itself says "this is a
+    // terminal state" (cancelled / failed / done / etc.), believe it
+    // regardless of the user-configured done condition. Without this,
+    // a watch on get_pipeline_status with done_match={status:"done"}
+    // would keep polling after the user cancels the pipeline, because
+    // status="cancelled" never matches "done" — wasting polls until
+    // max_polls / timeout. The builtin status tools (get_pipeline_status,
+    // get_task_status) all set obj.terminal = true on cancelled/failed
+    // too, so honoring it here drops the watch the moment the user
+    // intervenes.
+    if (truthy(getPath(obj, 'terminal'))) {
+      const statusVal = String(getPath(obj, 'status') || '').toLowerCase();
+      const isFailureLike = statusVal === 'failed' || statusVal === 'cancelled';
+      return finish(
+        w,
+        isFailureLike ? 'failed' : 'done',
+        obj,
+        `${w.label}: ${statusVal || 'reached a terminal state'}.`,
+      );
+    }
+    // done check (user-configured)
     let done = false;
     if (w.done_match) {
       const v = getPath(obj, w.done_match.path);
@@ -132,6 +191,22 @@ export function startWatchRunner(hooks: WatchRunnerHooks = {}): void {
     if (done) {
       return finish(w, 'done', obj, `${w.label}: done.`);
     }
+    // Heuristic terminal detection — fallback for connector pollers
+    // that don't set obj.terminal AND whose authors didn't anticipate
+    // a particular done condition. If the poll result has a common
+    // "I'm finished" shape (state/status/phase/result with a known
+    // terminal word, or done:true / finished:true), trust it. User's
+    // explicit done_match/done_path runs first (above), so a watch
+    // wanting "done when status==running" still works as intended.
+    const term = detectTerminalState(obj);
+    if (term) {
+      return finish(
+        w,
+        term.failure ? 'failed' : 'done',
+        obj,
+        `${w.label}: detected ${term.source}=${term.value} — closing watch.`,
+      );
+    }
     // not done — bound by polls / timeout, else reschedule
     if (polls >= w.max_polls || now - w.created_at > w.timeout_sec * 1000) {
       return finish(w, 'timed_out', obj, `${w.label}: not done within ${w.max_polls} polls / ${w.timeout_sec}s — please verify manually.`);

package/package.json

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