@aion0/forge 0.10.35 → 0.10.37

package/components/SettingsModal.tsx

@@ -831,6 +831,31 @@ export default function SettingsModal({ onClose }: { onClose: () => void }) {
           />
         </div>
 
+        {/* Re-run Onboarding */}
+        <div className="space-y-2">
+          <label className="text-xs text-[var(--text-secondary)] font-semibold uppercase">
+            Onboarding
+          </label>
+          <button
+            type="button"
+            onClick={async () => {
+              await fetch('/api/onboarding', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ action: 'reset' }),
+              });
+              // Reload so the Dashboard banner re-renders.
+              window.location.reload();
+            }}
+            className="text-[11px] px-2.5 py-1 border border-[var(--accent)] text-[var(--accent)] rounded hover:bg-[var(--accent)] hover:text-white"
+          >
+            ↺ Re-run Onboarding wizard
+          </button>
+          <p className="text-[10px] text-[var(--text-secondary)]">
+            Re-opens the first-run setup banner. Existing values are preserved — the wizard never overwrites non-empty fields.
+          </p>
+        </div>
+
         {/* Admin Password */}
         <div className="space-y-2">
           <label className="text-xs text-[var(--text-secondary)] font-semibold uppercase">
@@ -1041,6 +1066,23 @@ function ProfileRow({ id, cfg, inputClass, onUpdate, onDelete, isApi: isApiProp
                   className={inputClass + ' font-mono'}
                 />
               </div>
+              <div>
+                <label className="text-[8px] text-[var(--text-secondary)]">
+                  Max input tokens — total prompt cap (system + memory + history + tools). Default 200000 (Claude Code working window). Anything beyond gets strictly compressed: memory tail dropped first, then oldest history. Lower it (e.g. 12000) for 16k-context legacy models.
+                </label>
+                <input
+                  type="number"
+                  min={4000}
+                  value={cfg.maxInputTokens ?? ''}
+                  onChange={e => {
+                    const raw = e.target.value.trim();
+                    const n = raw === '' ? undefined : Number(raw);
+                    onUpdate({ ...cfg, maxInputTokens: Number.isFinite(n) ? n : undefined });
+                  }}
+                  placeholder="200000  (default — Claude Code 200k)"
+                  className={inputClass + ' font-mono'}
+                />
+              </div>
               <div className="flex items-center gap-2 pt-1">
                 <button
                   onClick={runTest}

package/components/WebTerminal.tsx

@@ -268,6 +268,16 @@ const WebTerminal = forwardRef<WebTerminalHandle, WebTerminalProps>(function Web
   const [expandedRoot, setExpandedRoot] = useState<string | null>(null);
   const [availableAgents, setAvailableAgents] = useState<{ id: string; name: string; detected?: boolean }[]>([]);
   const [selectedAgent, setSelectedAgent] = useState<string>('');
+  // Cached default-agent cliCmd. Resolved once on mount (fast in theory but
+  // the route can take 1–5s when many concurrent fetches saturate workers).
+  // openSessionInTerminal reads this directly — no await per session restore.
+  const defaultAgentCmdRef = useRef<string>('claude');
+  useEffect(() => {
+    fetch('/api/agents?resolve=')
+      .then(r => r.json())
+      .then(info => { if (info?.cliCmd) defaultAgentCmdRef.current = info.cliCmd; })
+      .catch(() => { /* keep bare 'claude' */ });
+  }, []);
   const [defaultAgentId, setDefaultAgentId] = useState('claude');
 
   // Restore shared state from server after mount
@@ -359,7 +369,12 @@ const WebTerminal = forwardRef<WebTerminalHandle, WebTerminalProps>(function Web
       const sf = skipPermissions ? ' --dangerously-skip-permissions' : '';
       let mcpFlag = '';
       try { const { getMcpFlag } = await import('@/lib/session-utils'); mcpFlag = await getMcpFlag(projectPath); } catch {}
-      const cmd = `cd "${projectPath}" && claude --resume ${sessionId}${sf}${mcpFlag}\n`;
+      // Use the cached default-agent cliCmd. Pre-fetched on mount above;
+      // if still 'claude' (fetch slow / pending), we use bare claude — old
+      // behavior, wrong if conda-base shadows the real one, but at least
+      // doesn't block the command from appearing.
+      const agentCmd = defaultAgentCmdRef.current;
+      const cmd = `cd "${projectPath}" && ${agentCmd} --resume ${sessionId}${sf}${mcpFlag}\n`;
       pendingCommands.set(paneId, cmd);
       const projectName = projectPath.split('/').pop() || 'Terminal';
       const newTab: TabState = {

package/lib/chat/agent-loop.ts

@@ -47,15 +47,25 @@ import type {
 // sentinel message below so the user knows why the turn stopped.
 const MAX_ITERATIONS = 24;
 const MAX_TOKENS = 16000;
-// Working-window budgets for the LLM history. Capped by message count
-// AND by token estimate (whichever hits first), see design §8. Older
-// raw is summarized by the memory-standalone Temper Summary sub-task
-// and recalled via buildMemoryContext as compact blocks instead.
+// Working-window message-count cap. Token cap is dynamic per-profile
+// (see DEFAULT_MAX_INPUT_TOKENS + ApiProfile.maxInputTokens). Older raw
+// is summarized by the memory-standalone Temper Summary sub-task and
+// recalled via buildMemoryContext as compact blocks.
 const HISTORY_MSG_BUDGET = 60;
-// Bumped 8000 → 32000 — modern models all ≥ 200k context; 8000 was
-// stripping single oversized tool results (e.g. mantis.search_bugs
-// returning 20k chars), leaving history empty after orphan-trim.
-const HISTORY_TOKEN_BUDGET = 32000;
+// Default total input ceiling when the profile doesn't set one. Matches
+// Claude Code's 200k working window — modern Claude / DeepSeek-V3 /
+// Qwen-Max all expose ≥ 200k context. Anything beyond this gets strictly
+// compressed (memory tail trimmed first, then oldest history evicted).
+// Lower it per-profile (e.g. 12000) for older 16k-context models —
+// Forge auto-trims memory then history to fit.
+const DEFAULT_MAX_INPUT_TOKENS = 200_000;
+// Reserved for the model's reply so we don't have to fight Anthropic
+// hard limits where max_tokens is part of the context budget.
+const OUTPUT_RESERVE_TOKENS = MAX_TOKENS;
+// Absolute floor — if even after trimming memory we can't fit this
+// many tokens of history, the profile's ceiling is unworkable and we
+// surface a clear error instead of sending a useless request.
+const MIN_HISTORY_TOKENS = 2_000;
 // Hard cap on a single tool_result stored into the conversation (chars).
 // A giant result (e.g. a connector returning a full test tree) would
 // otherwise blow the whole HISTORY_TOKEN_BUDGET, push its paired
@@ -112,6 +122,9 @@ export interface ProviderResolution {
   apiKey: string;
   baseUrl: string;
   model: string;
+  /** Total input-token ceiling for chat (system + memory + history + tools).
+   *  Falls back to DEFAULT_MAX_INPUT_TOKENS when the profile leaves it unset. */
+  maxInputTokens?: number;
 }
 
 /**
@@ -204,6 +217,7 @@ export function resolveProvider(sessionProvider: string | null, sessionModel: st
     apiKey: profile.apiKey,
     baseUrl: profile.baseUrl || defaultBaseUrl(profile.provider),
     model,
+    maxInputTokens: profile.maxInputTokens,
   };
 }
 
@@ -607,8 +621,11 @@ export async function runTurn(args: RunTurnArgs): Promise<{ ok: boolean; error?:
   let openConnectorTools = allConnectorTools.filter((t) => openSet.has(t.name.split('.')[0]!));
   let allTools: LlmTool[] = [...builtinToolDefs, ...openConnectorTools];
 
+  // Keep memContext separate from `system` — we may need to trim it
+  // per-iteration when the profile's maxInputTokens is tight. The
+  // assembled string is recomputed each iter (after open-set + memory
+  // trim). `system` here holds the base (no memory section).
   let system = buildSystem(openConnectorTools, openSet);
-  if (memContext) system += '\n\n─── Memory context (auto-loaded) ───\n' + memContext;
   if (memStore.enabled) {
     const searchHint = memStore.kind === 'local'
       ? '• memory_search is keyword LIKE over local blocks + episodes — useful for finding past notes; prefer memory_get_block / memory_list_blocks for first-person facts.'
@@ -627,23 +644,17 @@ export async function runTurn(args: RunTurnArgs): Promise<{ ok: boolean; error?:
     while (iter < MAX_ITERATIONS) {
       iter += 1;
 
-      const history = trimOrphanToolResults(
-        listMessagesCapped(args.sessionId, HISTORY_MSG_BUDGET, HISTORY_TOKEN_BUDGET, estimateTokens),
-      );
-      // Belt-and-suspenders: tool_result truncation should keep a complete
-      // pair in-window, but if history is somehow empty, fail clearly
-      // instead of letting the provider throw "messages must not be empty".
-      if (history.length === 0) {
-        cb({ type: 'error', data: { error: 'Conversation context is empty after trimming an oversized result. Clear the chat or retry with a narrower query.' } });
-        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);
+      // (Computed off a preview slice of history — refined below once
+      // we have the real history under budget.)
+      const previewHistory = trimOrphanToolResults(
+        listMessagesCapped(args.sessionId, HISTORY_MSG_BUDGET, 8_000, estimateTokens),
+      );
+      const newOpenSet = computeOpenSet(previewHistory, assistantBlocksAccum);
       const setChanged = newOpenSet.size !== openSet.size ||
         [...newOpenSet].some((n) => !openSet.has(n));
       if (setChanged) {
@@ -651,23 +662,69 @@ export async function runTurn(args: RunTurnArgs): Promise<{ ok: boolean; error?:
         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)`);
       }
 
+      // ── Dynamic context budget ──────────────────────────────────
+      // Total profile cap (default 60k, override per profile). Subtract
+      // fixed contributors (system, tools schema) and reservation for
+      // the model's reply → what's left splits between memory + history.
+      // Memory gets trimmed (from tail = least-pinned recall hits) when
+      // history would dip below the floor.
+      const maxInputTokens = provider.maxInputTokens || DEFAULT_MAX_INPUT_TOKENS;
+      const systemTok = Math.ceil(system.length / 4);
+      const toolsTok = Math.ceil(JSON.stringify(allTools).length / 4);
+      const fixedTok = systemTok + toolsTok + OUTPUT_RESERVE_TOKENS;
+
+      let memCtxTrimmed = memContext;
+      let memCtxTok = Math.ceil(memCtxTrimmed.length / 4);
+      let historyBudget = maxInputTokens - fixedTok - memCtxTok;
+
+      if (historyBudget < MIN_HISTORY_TOKENS) {
+        // Need to recover from memory. Each token = ~4 chars; cut from the
+        // END of memContext (renderMemoryContext emits pinned blocks first,
+        // recall hits last → tail is the least-pinned, easiest to drop).
+        const shortBy = MIN_HISTORY_TOKENS - historyBudget;
+        const charsToDrop = Math.min(memCtxTrimmed.length, shortBy * 4);
+        if (charsToDrop > 0) {
+          memCtxTrimmed = memCtxTrimmed.slice(0, memCtxTrimmed.length - charsToDrop)
+            + (memCtxTrimmed.length - charsToDrop > 0 ? '\n[… memory context trimmed to fit profile.maxInputTokens]' : '');
+          memCtxTok = Math.ceil(memCtxTrimmed.length / 4);
+          historyBudget = maxInputTokens - fixedTok - memCtxTok;
+        }
+      }
+
+      if (historyBudget < 500) {
+        cb({ type: 'error', data: { error:
+          `API profile maxInputTokens=${maxInputTokens} too small: ` +
+          `baseline (system=${systemTok} + tools=${toolsTok} + memory=${memCtxTok} + reserve=${OUTPUT_RESERVE_TOKENS}) ` +
+          `already takes ${fixedTok + memCtxTok} tokens. ` +
+          `Raise maxInputTokens in Settings → API Profiles, or pick a model with a larger context window.`
+        } });
+        return { ok: false, error: 'profile context budget exhausted' };
+      }
+
+      const history = trimOrphanToolResults(
+        listMessagesCapped(args.sessionId, HISTORY_MSG_BUDGET, historyBudget, estimateTokens),
+      );
+      if (history.length === 0) {
+        cb({ type: 'error', data: { error: 'Conversation context is empty after trimming an oversized result. Clear the chat or retry with a narrower query.' } });
+        return { ok: false, error: 'empty history' };
+      }
+
+      // Stitch trimmed memContext onto base system for this call only.
+      const systemForCall = memCtxTrimmed
+        ? `${system}\n\n─── Memory context (auto-loaded) ───\n${memCtxTrimmed}`
+        : system;
+
       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 _est_in = systemTok + memCtxTok + toolsTok + _historyTok;
+      console.log(`[chat-tokens] session=${args.sessionId} turn=${iter} cap=${maxInputTokens} est_in=${_est_in} system=${systemTok} memory=${memCtxTok}${memCtxTrimmed.length < memContext.length ? '(trimmed)' : ''} tools=${toolsTok} history=${_historyTok}(${_historyMsgs}msgs) reserve=${OUTPUT_RESERVE_TOKENS}`);
 
       const result = await streamLlm(
         {
@@ -675,7 +732,7 @@ export async function runTurn(args: RunTurnArgs): Promise<{ ok: boolean; error?:
           apiKey: provider.apiKey,
           baseUrl: provider.baseUrl,
           model: provider.model,
-          system,
+          system: systemForCall,
           history,
           tools: allTools,
           maxTokens: MAX_TOKENS,

package/lib/chat/llm/openai.ts

@@ -80,8 +80,12 @@ export const openaiAdapter: LlmAdapter = {
     // Some providers (litellm/vLLM) reject `tools: []` — they want the
     // field omitted entirely when there are no tools.
     const hasTools = Object.keys(tools).length > 0;
+    // Force /v1/chat/completions. @ai-sdk/openai v3 routes the default
+    // factory to the Responses API (/v1/responses), which only OpenAI
+    // first-party hosts — DeepSeek/Qianwen/LiteLLM proxies/vLLM/Ollama
+    // all 400 on it. .chat() picks the universally-supported endpoint.
     const result = streamText({
-      model: client(req.model),
+      model: client.chat(req.model),
       system: req.system,
       messages: historyToModelMessages(req.history),
       ...(hasTools ? { tools } : {}),

package/lib/chat/session-store.ts

@@ -231,6 +231,18 @@ function touchSession(id: string): void {
 
 // ─── Messages ────────────────────────────────────────────
 
+// Cap any single field to 64KB before it hits sqlite. LLM proxies (LiteLLM,
+// vLLM) sometimes return error payloads listing every message that failed
+// validation — a 188-turn chat trips 6000+ entries and the JSON balloons
+// to 25+ MB. One bad row drags out every UI page-load that touches it,
+// so truncate at write time.
+const FIELD_BYTE_CAP = 64 * 1024;
+function capLargeText(s: string | undefined | null): string | null {
+  if (s == null) return null;
+  if (s.length <= FIELD_BYTE_CAP) return s;
+  return s.slice(0, FIELD_BYTE_CAP) + `\n… (truncated, full length ${s.length} chars)`;
+}
+
 export function appendMessage(opts: {
   session_id: string;
   role: Role;
@@ -238,13 +250,21 @@ export function appendMessage(opts: {
   error?: string;
 }): Message {
   ensureSchema();
+  // Truncate any text block that's gone runaway (e.g. a streamed error
+  // message stuffed into the assistant turn for UI display).
+  const cappedBlocks = opts.blocks.map(b => {
+    if (b.type === 'text' && b.text.length > FIELD_BYTE_CAP) {
+      return { ...b, text: capLargeText(b.text)! };
+    }
+    return b;
+  });
   const row: MessageRow = {
     id: randomUUID(),
     session_id: opts.session_id,
     role: opts.role,
-    blocks: JSON.stringify(opts.blocks),
+    blocks: JSON.stringify(cappedBlocks),
     ts: Date.now(),
-    error: opts.error ?? null,
+    error: capLargeText(opts.error),
   };
   db().prepare(`
     INSERT INTO chat_messages (id, session_id, role, blocks, ts, error)

package/lib/chat/tool-dispatcher.ts

@@ -337,6 +337,135 @@ const BUILTINS: Record<string, BuiltinHandler> = {
       : 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
@@ -471,6 +600,66 @@ 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.',
@@ -520,7 +709,7 @@ function findConnectorTool(qualified: string): {
  * the extension's runner finishes those at execution time.
  */
 function buildConnectorPayload(
-  def: { id: string; name: string; runner?: 'main' | 'isolated'; host_match?: string; login_redirect?: string },
+  def: { id: string; name: string; runner?: 'main' | 'isolated'; host_match?: string; login_redirect?: string; tab_strategy?: 'reuse' | 'ephemeral' },
   entry: ConnectorEntry,
   settings: Record<string, any>,
 ) {
@@ -558,6 +747,11 @@ function buildConnectorPayload(
     host_match: hostMatch,
     login_redirect: loginRedirect,
     runner: def.runner || entry.runner || 'main',
+    // Connector-level opt-in: 'ephemeral' = always open a fresh background
+    // tab, close after. Missing/'reuse' = pick an existing matching tab.
+    // Was being silently dropped — extension never saw it, so manifests
+    // with tab_strategy:ephemeral (mantis, tp) ran in reuse mode.
+    ...(def.tab_strategy ? { tab_strategy: def.tab_strategy } : {}),
     entries: [expandedEntry],
   };
 }

package/lib/help-docs/17-connectors.md

@@ -340,6 +340,57 @@ X-Forge-Token: …
 or `multipart/form-data` with a `file` field accepting `.yaml`,
 `.yml`, or `.zip`. Zip must have `manifest.yaml` at the root.
 
+### POST /api/connectors/import-config-template
+
+Bulk-fill `connector-configs.json` from a JSON template. The Settings →
+Connectors panel exposes this as the **↥ Import Template** button.
+
+The template format:
+
+```json
+{
+  "_README": "...",
+  "_prompts": {
+    "gitlab_pat": {
+      "label": "GitLab PAT",
+      "hint": "where to grab it",
+      "secret": true,
+      "required": true
+    }
+  },
+  "gitlab": {
+    "config": { "base_url": "https://...", "token": "${gitlab_pat}" },
+    "enabled": true
+  }
+}
+```
+
+Behavior:
+
+- Two-phase: `multipart/form-data` (analyze) returns deduplicated list of
+  `${key}` placeholders the user still needs to fill. `application/json
+  {template, values}` (apply) substitutes and merges.
+- Same placeholder key referenced from multiple connectors (e.g.
+  `gitlab_pat` used by `gitlab.token` AND `jenkins.instances[0].gitlab_pat`)
+  is asked **once** and applied to every target.
+- Static values (non-placeholder) are applied as-is.
+- **Existing non-empty fields are preserved** — the template never
+  overwrites a real token a user already configured (a `TODO_*` carry-over
+  is treated as empty and gets overwritten).
+- Connectors whose manifest is not installed yet are skipped and reported
+  in the result. Sync the marketplace first, then re-import.
+- Keys starting with `_` (`_README`, `_prompts`, etc.) are metadata.
+
+Forge ships a default template at `templates/connector-config-template.json`,
+bundled into the build. The Import button always works out of the box.
+Users can override the bundled one by dropping their own at
+`<dataDir>/config-template.json` — the GET endpoint picks the override
+first, else falls back to the bundle.
+
+Each prompt may include `url` + `url_label`, surfaced in the modal as
+a "↗ Get token" link next to the field so the user can jump straight
+to the page that issues the value.
+
 ## Migration from pre-v0.9
 
 Pre-v0.9 Forge stored connectors as built-in plugins under

package/lib/settings.ts

@@ -64,6 +64,15 @@ export interface ApiProfile {
   model: string;
   apiKey: string;
   baseUrl?: string;
+  /**
+   * Total input-token ceiling for chat. Includes system prompt + connector
+   * catalog + memory context (summary + Temper recall) + history. Forge
+   * dynamically trims (memory tail dropped first, then oldest history)
+   * to keep the assembled prompt under this. Defaults to 200k (Claude
+   * Code's working window) when unset; lower it (e.g. 12000) for older
+   * 16k-context models that would otherwise truncate server-side.
+   */
+  maxInputTokens?: number;
 }
 
 /**
@@ -186,6 +195,12 @@ export interface Settings {
   pipelineTmpKeepFailedDays: number;
   pipelineTmpKeepCancelledDays: number;
   pipelineTmpGcIntervalHours: number;
+  /**
+   * First-run onboarding wizard. False (or absent) → Forge shows the
+   * wizard on every launch until the user completes it or skips. True
+   * → silent. Settings → "Re-run Onboarding" sets it back to false.
+   */
+  onboardingCompleted: boolean;
 }
 
 const defaults: Settings = {
@@ -236,6 +251,7 @@ const defaults: Settings = {
   pipelineTmpKeepFailedDays: 3,
   pipelineTmpKeepCancelledDays: 3,
   pipelineTmpGcIntervalHours: 6,
+  onboardingCompleted: false,
 };
 
 /** Decrypt nested apiKey fields in agents (legacy migration window) +

package/package.json

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