@aion0/forge 0.10.33 → 0.10.35

package/RELEASE_NOTES.md

@@ -1,23 +1,12 @@
-# Forge v0.10.33
+# Forge v0.10.35
 
-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.34
 
 ### 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
+- chat: namespace gating — connector tools load on demand via connector_open
+- DocTerminal: New/Resume buttons use configured agent, not hardcoded claude
 
 
-**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.10.32...v0.10.33
+**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.10.34...v0.10.35

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/DocTerminal.tsx

@@ -166,13 +166,13 @@ export default function DocTerminal({ docRoot, agent }: { docRoot: string; agent
         </span>
         <div className="ml-auto flex items-center gap-1">
           <button
-            onClick={() => { const sf = skipPermRef.current ? ' --dangerously-skip-permissions' : ''; runCommand(`cd "${docRoot}" && claude${sf}`); }}
+            onClick={() => { const sf = skipPermRef.current ? ' --dangerously-skip-permissions' : ''; runCommand(`cd "${docRoot}" && ${agentCmdRef.current}${sf}`); }}
             className="text-[10px] px-2 py-0.5 text-[var(--accent)] hover:bg-[#2a2a4a] rounded"
           >
             New
           </button>
           <button
-            onClick={() => { const sf = skipPermRef.current ? ' --dangerously-skip-permissions' : ''; runCommand(`cd "${docRoot}" && claude -c${sf}`); }}
+            onClick={() => { const sf = skipPermRef.current ? ' --dangerously-skip-permissions' : ''; runCommand(`cd "${docRoot}" && ${agentCmdRef.current} -c${sf}`); }}
             className="text-[10px] px-2 py-0.5 text-gray-400 hover:text-white hover:bg-[#2a2a4a] rounded"
           >
             Resume

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

@@ -207,7 +207,50 @@ export function resolveProvider(sessionProvider: string | null, sessionModel: st
   };
 }
 
-function buildSystemPrompt(connectorTools: LlmTool[], builtinDefs: typeof BUILTIN_TOOL_DEFS, sessionSystemPrompt: string | null): string {
+/**
+ * Build the connector catalog block — one entry per installed connector,
+ * showing what it can do. The LLM reads this to decide whether to call
+ * connector_open(<id>) before reaching for a tool.
+ *
+ * Prefers `catalog_summary` from the manifest (curated 2-4 line English
+ * blurb). Falls back to first 5 tool names if absent, so older manifests
+ * still produce something usable.
+ */
+function buildConnectorCatalog(openSet: Set<string>): string[] {
+  const lines: string[] = [];
+  for (const inst of listInstalledConnectors()) {
+    if (!inst.enabled) continue;
+    const def = inst.definition;
+    let toolCount = 0;
+    const sampleNames: string[] = [];
+    for (const entry of getConnectorEntries(def)) {
+      for (const tname of Object.keys(entry.tools || {})) {
+        toolCount += 1;
+        if (sampleNames.length < 5) sampleNames.push(tname);
+      }
+    }
+    const status = openSet.has(def.id) ? ' [OPEN]' : '';
+    const summary = (def.catalog_summary || '').trim();
+    if (summary) {
+      lines.push(`▸ ${def.id}${status} (${toolCount} tools):`);
+      for (const ln of summary.split('\n')) {
+        const trimmed = ln.trim();
+        if (trimmed) lines.push(`    ${trimmed}`);
+      }
+    } else {
+      const sample = sampleNames.join(', ');
+      lines.push(`▸ ${def.id}${status}: ${toolCount} tools (e.g. ${sample}${toolCount > 5 ? ', …' : ''})`);
+    }
+  }
+  return lines;
+}
+
+function buildSystemPrompt(
+  openConnectorTools: LlmTool[],
+  openSet: Set<string>,
+  builtinDefs: typeof BUILTIN_TOOL_DEFS,
+  sessionSystemPrompt: string | null,
+): string {
   const now = new Date().toISOString();
 
   // Inject a brief Forge context block (project names only) so the LLM can
@@ -227,8 +270,10 @@ function buildSystemPrompt(connectorTools: LlmTool[], builtinDefs: typeof BUILTI
     `Current time: ${now}`,
     '',
     'Tool usage — IMPORTANT:',
-    '- If the user mentions a system name (e.g. "teams", "mantis", "gitlab", "pmdb") — even casually like "在 teams 中..." / "from mantis" — you MUST attempt the matching connector tool FIRST.',
-    '  Don\'t explain how to do something manually before trying the tool. The tools below run inside the user\'s actual logged-in browser session — they CAN do things you might think only the user can do manually.',
+    '- Connector tools (mantis.*, gitlab.*, nac.*, tp.*, etc.) are NOT in your active tool list by default. The "Connector catalog" below shows what each connector can do.',
+    '  Call connector_open({name: "<id>"}) FIRST to load a connector — its tools become callable on your next turn. The open set resets at every new user message, so re-open as the user pivots topics.',
+    '- If the user mentions a system name (e.g. "teams", "mantis", "gitlab", "pmdb") — even casually like "在 teams 中..." / "from mantis" — open that connector and use its tools.',
+    '  Don\'t explain how to do something manually before trying the tool. The connector tools run inside the user\'s actual logged-in browser session — they CAN do things you might think only the user can do manually.',
     '- For Teams in particular: send_message can target any chat by name; if the chat doesn\'t exist yet, the tool will return a specific error and THEN you can advise. Don\'t pre-judge.',
     '- If a tool call fails, read its error carefully — it usually tells you what to fix (wrong arg, missing setting, login required). Retry with the fix. Only give up after the tool explicitly says it cannot do the task.',
     '- For trigger_pipeline / dispatch_task: when the user names a "project" (e.g. "FortiNAC"), pass it as input.project verbatim. The names in the "Forge projects" list below ARE the valid values. Call list_forge_context only if you need paths / agents / skills.',
@@ -250,14 +295,16 @@ function buildSystemPrompt(connectorTools: LlmTool[], builtinDefs: typeof BUILTI
     lines.push('', `Forge projects (valid input.project values): ${projectNames.join(', ')}`);
   }
 
-  if (connectorTools.length > 0) {
-    lines.push('', 'Connector tools available:');
-    for (const t of connectorTools) {
-      lines.push(`- ${t.name}: ${t.description.slice(0, 100)}`);
+  const catalog = buildConnectorCatalog(openSet);
+  if (catalog.length > 0) {
+    lines.push('', 'Connector catalog — call connector_open({name}) to load tools:');
+    lines.push(...catalog);
+    if (openConnectorTools.length > 0) {
+      lines.push('', `Currently open connectors (${[...openSet].join(', ')}) — their tools ARE in your active tool list this turn.`);
     }
   }
   if (builtinDefs.length > 0) {
-    lines.push('', 'Builtin tools:');
+    lines.push('', 'Builtin tools (always available):');
     for (const t of builtinDefs) {
       lines.push(`- ${t.name}: ${t.description.slice(0, 100)}`);
     }
@@ -431,7 +478,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 : [];
@@ -460,36 +507,36 @@ export async function runTurn(args: RunTurnArgs): Promise<{ ok: boolean; error?:
     });
   }
 
-  let connectorTools = buildConnectorTools();
-
-  // ── Narrowing: if the user named connectors (/teams, "in mantis", ...)
-  // restrict the tool list so the LLM can't wander to unrelated connectors.
-  // Strong (slash-prefix) signals also emit a directive in the system prompt
-  // so the model treats it as a command, not a hint.
-  const allConnectorIds = [...new Set(connectorTools.map((t) => t.name.split('.')[0]!))];
+  // ── Full connector tool inventory ────────────────────────────────
+  // We build the full set ONCE. The active `tools` field sent to the LLM
+  // is computed per iteration by filtering to the "open set" (connectors
+  // the LLM has opened via connector_open OR the user explicitly named).
+  const allConnectorTools = buildConnectorTools();
+  const allConnectorIds = [...new Set(allConnectorTools.map((t) => t.name.split('.')[0]!))];
   const pluginCatalog = allConnectorIds.map((id) => {
     const def = getConnector(id);
     return { id, name: def?.name };
   });
+
+  // User-mention auto-open: if the user's message names a connector (slash
+  // or bare), seed the open set so the LLM doesn't need an extra
+  // connector_open round-trip for the obvious cases. Strong signals
+  // (/connector) also emit a directive so the model treats it as a command.
   const mentioned = detectMentionedConnectors(args.userText, pluginCatalog);
-  const narrowSet = mentioned.strong.size > 0 ? mentioned.strong
-                  : mentioned.medium.size > 0 ? mentioned.medium
-                  : null;
+  const autoOpenFromUserText: Set<string> = mentioned.strong.size > 0 ? mentioned.strong
+                                          : mentioned.medium.size > 0 ? mentioned.medium
+                                          : new Set();
   let narrowDirective = '';
-  if (narrowSet) {
-    connectorTools = connectorTools.filter((t) => narrowSet.has(t.name.split('.')[0]!));
-    const list = [...narrowSet].join(', ');
-    if (mentioned.strong.size > 0) {
-      narrowDirective = `\n\nUSER MENTIONED CONNECTOR(S) EXPLICITLY (slash-prefix): ${list}. You MUST use these connector tools for this turn — do NOT answer without trying them first, and do NOT consider other connectors.`;
-      console.log(`[chat] narrow STRONG → ${list}`);
-    } else {
-      console.log(`[chat] narrow MEDIUM → ${list}`);
-    }
+  if (mentioned.strong.size > 0) {
+    const list = [...mentioned.strong].join(', ');
+    narrowDirective = `\n\nUSER MENTIONED CONNECTOR(S) EXPLICITLY (slash-prefix): ${list}. These are already open for this turn — use their tools directly, do NOT call connector_open for them.`;
+    console.log(`[chat] auto-open STRONG → ${list}`);
+  } else if (mentioned.medium.size > 0) {
+    console.log(`[chat] auto-open MEDIUM → ${[...mentioned.medium].join(', ')}`);
   }
 
   console.log(
-    `[chat] tools=${connectorTools.length} → ` +
-    connectorTools.map((t) => t.name).join(', ').slice(0, 600),
+    `[chat] total connector tools=${allConnectorTools.length} across ${allConnectorIds.length} connectors`,
   );
 
   const builtinDefsAll = [
@@ -497,17 +544,70 @@ 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,
+  }));
+
+  // ── Open set computation ─────────────────────────────────────────
+  // A connector is "open" for this user-task if the LLM has called
+  // connector_open(name=<id>) OR has called <id>.<tool> in any assistant
+  // turn since the most recent user TEXT message. User text messages mark
+  // task boundaries — on the next user message, the open set resets to
+  // just what user-text auto-opens seed.
+  //
+  // assistantBlocksAccum captures the in-progress turn's blocks (not yet
+  // in history during the iteration). We OR them with the history scan.
+  function computeOpenSet(history: Message[], currentBlocks: ContentBlock[]): Set<string> {
+    const ns = new Set<string>(autoOpenFromUserText);
+    // Find the most recent user message that has text content. Tool-result
+    // user messages don't count as task boundaries.
+    let lastUserIdx = -1;
+    for (let i = history.length - 1; i >= 0; i--) {
+      const m = history[i]!;
+      if (m.role !== 'user') continue;
+      if (m.blocks.some((b) => b.type === 'text')) { lastUserIdx = i; break; }
+    }
+    const start = lastUserIdx + 1;
+    for (let i = start; i < history.length; i++) {
+      const m = history[i]!;
+      if (m.role !== 'assistant') continue;
+      for (const b of m.blocks) {
+        if (b.type !== 'tool_use') continue;
+        if (b.name === 'connector_open') {
+          const opened = (b.input as { name?: string } | undefined)?.name;
+          if (opened) ns.add(String(opened));
+        } else if (b.name.includes('.')) {
+          ns.add(b.name.split('.')[0]!);
+        }
+      }
+    }
+    for (const b of currentBlocks) {
+      if (b.type !== 'tool_use') continue;
+      if (b.name === 'connector_open') {
+        const opened = (b.input as { name?: string } | undefined)?.name;
+        if (opened) ns.add(String(opened));
+      } else if (b.name.includes('.')) {
+        ns.add(b.name.split('.')[0]!);
+      }
+    }
+    return ns;
+  }
+
+  const sessionSystemPrompt = session.system_prompt;
+  function buildSystem(openTools: LlmTool[], openSet: Set<string>): string {
+    let s = buildSystemPrompt(openTools, openSet, builtinDefsAll, sessionSystemPrompt);
+    if (narrowDirective) s += narrowDirective;
+    return s;
+  }
 
-  let system = buildSystemPrompt(connectorTools, builtinDefsAll, session.system_prompt);
-  if (narrowDirective) system += narrowDirective;
+  // Initial open set (before any iteration): just user-text auto-open seeds
+  let openSet: Set<string> = new Set(autoOpenFromUserText);
+  let openConnectorTools = allConnectorTools.filter((t) => openSet.has(t.name.split('.')[0]!));
+  let allTools: LlmTool[] = [...builtinToolDefs, ...openConnectorTools];
+
+  let system = buildSystem(openConnectorTools, openSet);
   if (memContext) system += '\n\n─── Memory context (auto-loaded) ───\n' + memContext;
   if (memStore.enabled) {
     const searchHint = memStore.kind === 'local'
@@ -538,9 +638,37 @@ export async function runTurn(args: RunTurnArgs): Promise<{ ok: boolean; error?:
         return { ok: false, error: 'empty history' };
       }
 
+      // ── 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.
+      // First iteration: only user-text auto-opens seed the set. After
+      // the LLM calls connector_open, subsequent iterations pick that up.
+      const newOpenSet = computeOpenSet(history, assistantBlocksAccum);
+      const setChanged = newOpenSet.size !== openSet.size ||
+        [...newOpenSet].some((n) => !openSet.has(n));
+      if (setChanged) {
+        openSet = newOpenSet;
+        openConnectorTools = allConnectorTools.filter((t) => openSet.has(t.name.split('.')[0]!));
+        allTools = [...builtinToolDefs, ...openConnectorTools];
+        system = buildSystem(openConnectorTools, openSet);
+        if (memContext) system += '\n\n─── Memory context (auto-loaded) ───\n' + memContext;
+        console.log(`[chat] open set → {${[...openSet].join(',')}} (${openConnectorTools.length} connector tools active)`);
+      }
+
       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 +691,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/chat/tool-dispatcher.ts

@@ -336,6 +336,31 @@ const BUILTINS: Record<string, BuiltinHandler> = {
       ? content.slice(0, MAX) + `\n\n…[truncated — doc is ${content.length} chars]`
       : content;
   },
+
+  // Namespace gating meta-tool. Connector tools (mantis.*, gitlab.*, etc.)
+  // are NOT in the active tools list by default — only their catalog entry
+  // is visible in the system prompt. Calling connector_open({name}) makes
+  // that connector's tools available for the rest of this user-task (until
+  // the next user message). The handler returns a tiny confirmation; the
+  // actual side-effect is that agent-loop scans assistant history for
+  // these calls (and direct namespaced calls) to compute the "open set"
+  // each turn.
+  connector_open: async (input) => {
+    const { name } = (input as { name?: string } | undefined) || {};
+    if (!name) return JSON.stringify({ ok: false, error: 'name is required (e.g. "mantis", "gitlab", "nac")' });
+    const def = getConnector(String(name));
+    if (!def) return JSON.stringify({ ok: false, error: `unknown connector: ${name}. Call connector_open with a name from the catalog in the system prompt.` });
+    let toolCount = 0;
+    for (const entry of getConnectorEntries(def)) {
+      toolCount += Object.keys(entry.tools || {}).length;
+    }
+    return JSON.stringify({
+      ok: true,
+      connector: name,
+      tool_count: toolCount,
+      message: `${name} loaded — ${toolCount} tools available next turn. Call them as ${name}.<tool_name>.`,
+    });
+  },
 };
 
 export interface BuiltinToolDef {
@@ -446,6 +471,20 @@ export const BUILTIN_TOOL_DEFS: BuiltinToolDef[] = [
       required: ['doc'],
     },
   },
+  {
+    name: 'connector_open',
+    description: 'Load a connector to make its tools (e.g. mantis.search_bugs, gitlab.list_my_todos) available for use. REQUIRED before calling any connector tool — the catalog block in the system prompt shows what each connector can do. Tools stay loaded only for the current user task; the next user message resets the open set, so re-open as needed.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        name: {
+          type: 'string',
+          description: 'Connector id from the catalog (e.g. "mantis", "gitlab", "nac", "tp", "jenkins", "teams", "pmdb", "github-api").',
+        },
+      },
+      required: ['name'],
+    },
+  },
 ];
 
 // ─── Connector dispatch ──────────────────────────────────

package/lib/connectors/types.ts

@@ -477,6 +477,14 @@ export interface ConnectorDefinition {
   author?: string;
   description?: string;
 
+  /**
+   * 2-4 line English summary of what this connector can do, shown in the
+   * chat system prompt's "Connector catalog" block. Drives the LLM's
+   * decision to call connector_open(<id>). When absent, the agent falls
+   * back to listing the first few tool names — informative but flat.
+   */
+  catalog_summary?: string;
+
   /**
    * Minimum Forge version this manifest expects. The registry filter
    * hides newer-than-supported manifests so users on older Forge

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.35",
   "description": "Unified AI workflow platform — multi-model task orchestration, persistent sessions, web terminal, remote access",
   "type": "module",
   "scripts": {