@aion0/forge 0.10.34 → 0.10.35

package/RELEASE_NOTES.md

@@ -1,14 +1,12 @@
-# Forge v0.10.34
+# Forge v0.10.35
 
 Released: 2026-06-03
 
-## Changes since v0.10.33
+## Changes since v0.10.34
 
 ### Other
-- 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
+- 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.33...v0.10.34
+**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.10.34...v0.10.35

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/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)}`);
     }
@@ -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 = [
@@ -503,32 +550,64 @@ export async function runTurn(args: RunTurnArgs): Promise<{ ok: boolean; error?:
     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('.')) {
+  // ── 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(tools: LlmTool[]): string {
-    let s = buildSystemPrompt(tools, builtinDefsAll, sessionSystemPrompt);
+  function buildSystem(openTools: LlmTool[], openSet: Set<string>): string {
+    let s = buildSystemPrompt(openTools, openSet, builtinDefsAll, sessionSystemPrompt);
     if (narrowDirective) s += narrowDirective;
     return s;
   }
 
-  const baseConnectorTools = connectorTools;  // post-initial-narrow snapshot
-  let allTools: LlmTool[] = [...builtinToolDefs, ...baseConnectorTools];
+  // 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(baseConnectorTools);
+  let system = buildSystem(openConnectorTools, openSet);
   if (memContext) system += '\n\n─── Memory context (auto-loaded) ───\n' + memContext;
   if (memStore.enabled) {
     const searchHint = memStore.kind === 'local'
@@ -559,23 +638,21 @@ 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)`);
-          }
-        }
+      // ── 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 = [];

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/package.json

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