@aion0/forge 0.10.34 → 0.10.36

package/README.md

@@ -27,6 +27,14 @@
 
 ## Install
 
+**One-liner** (macOS + Linux — installs node deps, tmux, claude code, then Forge):
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/aiwatching/forge/main/scripts/install-deps.sh | bash
+```
+
+Or manually:
+
 ```bash
 npm install -g @aion0/forge
 forge server start
@@ -35,6 +43,7 @@ forge server start
 Open `http://localhost:8403`. First launch prompts you to set an admin password.
 
 **Requirements:** Node.js ≥ 20, tmux, [Claude Code CLI](https://docs.anthropic.com/en/docs/claude-code)
+**Optional:** jq, glab, gh (used by some pipelines)
 
 ## What is Forge?
 

package/RELEASE_NOTES.md

@@ -1,14 +1,16 @@
-# Forge v0.10.34
+# Forge v0.10.36
 
-Released: 2026-06-03
+Released: 2026-06-04
 
-## Changes since v0.10.33
+## Changes since v0.10.35
+
+### Documentation
+- docs: README install section gets one-liner + optional deps line
 
 ### 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
+- scripts: add install-deps.sh cross-platform installer
+- feat(chat): add 5 schedule builtin tools (create/list/delete/run/update)
+- feat(vscode-ext): add Chat + Schedules views + session switcher
 
 
-**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.10.33...v0.10.34
+**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.10.35...v0.10.36

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,160 @@ const BUILTINS: Record<string, BuiltinHandler> = {
       ? content.slice(0, MAX) + `\n\n…[truncated — doc is ${content.length} chars]`
       : content;
   },
+
+  // ── Schedules CRUD ─────────────────────────────────────────
+  // All five direct in-process via lib/schedules/store — no HTTP, no auth.
+  // Use these instead of dispatch_task + curl: cleaner, no token shenanigans.
+
+  create_schedule: async (input) => {
+    const p = (input as any) || {};
+    const name = String(p.name || '').trim();
+    const workflow = String(p.workflow || p.body_ref || '').trim();
+    if (!name) return JSON.stringify({ ok: false, error: 'name is required' });
+    if (!workflow) return JSON.stringify({ ok: false, error: 'workflow (pipeline name) is required' });
+
+    // Trigger normalization: prefer every_minutes; accept at (once) or cron.
+    let schedule_kind: 'period' | 'once' | 'cron' = 'period';
+    let schedule_interval_minutes: number | undefined;
+    let schedule_at: string | null | undefined;
+    let schedule_cron: string | null | undefined;
+    if (p.every_minutes != null) {
+      schedule_kind = 'period';
+      schedule_interval_minutes = Number(p.every_minutes);
+    } else if (p.at) {
+      schedule_kind = 'once';
+      schedule_at = String(p.at);
+    } else if (p.cron) {
+      schedule_kind = 'cron';
+      schedule_cron = String(p.cron);
+    } else {
+      return JSON.stringify({ ok: false, error: 'one of every_minutes / at / cron is required' });
+    }
+
+    const { createSchedule, seedNextRunAt } = await import('../schedules/store');
+    try {
+      const s = createSchedule({
+        name,
+        body_kind: 'pipeline',
+        body_ref: workflow,
+        input: (p.input && typeof p.input === 'object') ? p.input : {},
+        skills: Array.isArray(p.skills) ? p.skills : undefined,
+        enabled: p.enabled !== false,
+        schedule_kind,
+        schedule_interval_minutes,
+        schedule_at: schedule_at ?? null,
+        schedule_cron: schedule_cron ?? null,
+        action_kind: p.action || 'none',
+      });
+      seedNextRunAt(s.id);
+      return JSON.stringify({
+        ok: true,
+        schedule_id: s.id,
+        name: s.name,
+        enabled: s.enabled,
+        kind: s.schedule_kind,
+        next_run_at: s.next_run_at,
+        message: `Schedule "${s.name}" created. ${schedule_kind === 'period' ? `Fires every ${schedule_interval_minutes} minutes.` : schedule_kind === 'once' ? `Fires once at ${schedule_at}.` : `Fires on cron "${schedule_cron}".`}`,
+      });
+    } catch (e: any) {
+      return JSON.stringify({ ok: false, error: e?.message || String(e) });
+    }
+  },
+
+  list_schedules: async () => {
+    const { listSchedules } = await import('../schedules/store');
+    const { decorateSchedule } = await import('../schedules/state');
+    const all = listSchedules().map(decorateSchedule);
+    return JSON.stringify({
+      schedules: all.map((s) => ({
+        id: s.id,
+        name: s.name,
+        enabled: s.enabled,
+        active_state: s.active_state,
+        schedule_kind: s.schedule_kind,
+        body_ref: s.body_ref,
+        next_run_at: s.next_run_at,
+        last_run_at: s.last_run_at,
+      })),
+      total: all.length,
+    });
+  },
+
+  delete_schedule: async (input) => {
+    const id = String((input as any)?.id || '').trim();
+    if (!id) return JSON.stringify({ ok: false, error: 'id is required' });
+    const { deleteSchedule } = await import('../schedules/store');
+    const ok = deleteSchedule(id);
+    return JSON.stringify({ ok, message: ok ? `Schedule ${id} deleted.` : `Schedule ${id} not found.` });
+  },
+
+  run_schedule_now: async (input) => {
+    const id = String((input as any)?.id || '').trim();
+    if (!id) return JSON.stringify({ ok: false, error: 'id is required' });
+    const { getSchedule } = await import('../schedules/store');
+    const s = getSchedule(id);
+    if (!s) return JSON.stringify({ ok: false, error: `Schedule ${id} not found` });
+    const { executeSchedule } = await import('../schedules/scheduler');
+    try {
+      const runId = await executeSchedule(s, 'manual');
+      return JSON.stringify({ ok: true, schedule_id: id, run_id: runId, message: `Schedule "${s.name}" fired. Run id: ${runId}.` });
+    } catch (e: any) {
+      return JSON.stringify({ ok: false, error: e?.message || String(e) });
+    }
+  },
+
+  update_schedule: async (input) => {
+    const p = (input as any) || {};
+    const id = String(p.id || '').trim();
+    if (!id) return JSON.stringify({ ok: false, error: 'id is required' });
+    const patch: Record<string, unknown> = {};
+    if (typeof p.enabled === 'boolean') patch.enabled = p.enabled;
+    if (typeof p.name === 'string') patch.name = p.name;
+    if (p.input && typeof p.input === 'object') patch.input = p.input;
+    if (Array.isArray(p.skills)) patch.skills = p.skills;
+    if (typeof p.every_minutes === 'number') {
+      patch.schedule_kind = 'period';
+      patch.schedule_interval_minutes = p.every_minutes;
+    } else if (typeof p.at === 'string') {
+      patch.schedule_kind = 'once';
+      patch.schedule_at = p.at;
+    } else if (typeof p.cron === 'string') {
+      patch.schedule_kind = 'cron';
+      patch.schedule_cron = p.cron;
+    }
+    if (Object.keys(patch).length === 0) {
+      return JSON.stringify({ ok: false, error: 'no fields to update (try enabled / name / input / skills / every_minutes / at / cron)' });
+    }
+    const { updateSchedule, seedNextRunAt } = await import('../schedules/store');
+    const ok = updateSchedule(id, patch as any);
+    if (ok && (patch.schedule_kind || patch.enabled === true)) seedNextRunAt(id);
+    return JSON.stringify({ ok, message: ok ? `Schedule ${id} updated.` : `Schedule ${id} not found.` });
+  },
+
+  // 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 +600,80 @@ export const BUILTIN_TOOL_DEFS: BuiltinToolDef[] = [
       required: ['doc'],
     },
   },
+  {
+    name: 'create_schedule',
+    description: 'Create a recurring (or one-off) schedule that fires a Forge pipeline on a timer. NO HTTP, NO auth — runs in-process. Use this when the user says "every N minutes/hours" / "watch X" / "monitor Y" / "auto-run pipeline on schedule". REQUIRED args: name + workflow + ONE of {every_minutes, at, cron}. Returns { ok, schedule_id, next_run_at }.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'Human-readable name shown in the Schedules UI.' },
+        workflow: { type: 'string', description: 'Pipeline workflow name (file basename of flows/<name>.yaml). Run trigger_pipeline() with NO args first if unsure what names are available.' },
+        input: { type: 'object', description: 'Pipeline input fields. Same shape as trigger_pipeline.input. OMIT optional fields to use defaults.' },
+        skills: { type: 'array', items: { type: 'string' }, description: 'Skill names to inject into every Claude task this schedule spawns.' },
+        every_minutes: { type: 'number', description: 'Period in minutes (e.g. 60 = hourly). Most common trigger.' },
+        at: { type: 'string', description: 'ISO timestamp for one-shot run (e.g. "2026-06-05T09:00:00Z"). Mutually exclusive with every_minutes / cron.' },
+        cron: { type: 'string', description: 'Cron expression for complex schedules (e.g. "0 9 * * 1-5" = weekdays 9am). Mutually exclusive with every_minutes / at.' },
+        enabled: { type: 'boolean', description: 'Whether to start enabled. Default true.' },
+        action: { type: 'string', enum: ['none', 'chat', 'email', 'telegram'], description: 'Post-run notification action. Default "none".' },
+      },
+      required: ['name', 'workflow'],
+    },
+  },
+  {
+    name: 'list_schedules',
+    description: 'List all configured schedules with status (active_state: idle / running / last_failed / paused), kind, next_run_at, last_run_at. Use to find a schedule\'s id before update/delete/run.',
+    input_schema: { type: 'object', properties: {} },
+  },
+  {
+    name: 'delete_schedule',
+    description: 'Permanently delete a schedule by id. Cannot be undone. Find id via list_schedules first.',
+    input_schema: {
+      type: 'object',
+      properties: { id: { type: 'string', description: 'Schedule id from list_schedules.' } },
+      required: ['id'],
+    },
+  },
+  {
+    name: 'run_schedule_now',
+    description: 'Fire a schedule\'s configured pipeline immediately (manual trigger), regardless of when it would next fire on its timer. Returns the run_id.',
+    input_schema: {
+      type: 'object',
+      properties: { id: { type: 'string', description: 'Schedule id from list_schedules.' } },
+      required: ['id'],
+    },
+  },
+  {
+    name: 'update_schedule',
+    description: 'Patch fields on an existing schedule (enable/disable, rename, change input, swap trigger). Only the fields you pass are changed.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        id: { type: 'string', description: 'Schedule id from list_schedules.' },
+        enabled: { type: 'boolean', description: 'true to enable, false to pause without deleting.' },
+        name: { type: 'string' },
+        input: { type: 'object', description: 'New pipeline input fields (replaces existing).' },
+        skills: { type: 'array', items: { type: 'string' } },
+        every_minutes: { type: 'number', description: 'Switch trigger to interval.' },
+        at: { type: 'string', description: 'Switch trigger to one-shot at this ISO time.' },
+        cron: { type: 'string', description: 'Switch trigger to cron expression.' },
+      },
+      required: ['id'],
+    },
+  },
+  {
+    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.36",
   "description": "Unified AI workflow platform — multi-model task orchestration, persistent sessions, web terminal, remote access",
   "type": "module",
   "scripts": {