@aion0/forge 0.10.89 → 0.11.0

package/components/KanbanBoard.tsx

@@ -0,0 +1,354 @@
+'use client';
+
+/**
+ * Home Kanban board — connector cards rendered from a prompt-driven WidgetSpec.
+ * Two render modes share one block renderer:
+ *   - compact (Style A): fixed-size card — accent bar, stat tiles, stripe lists.
+ *   - rich (Style B):    floating modal — big tiles, callouts, progress, avatars.
+ * See obsidian forge/kanban-design-mockup.html for the locked design.
+ */
+
+import { useCallback, useEffect, useRef, useState } from 'react';
+import type { KanbanCard, WidgetSpec, WidgetBlock, WidgetColor } from '@/lib/kanban/types';
+
+const CARD_W = 300;
+const CARD_H = 208;
+
+// Vivid accent palette (reads well on light + dark). Structural colors use CSS vars.
+const HEX: Record<WidgetColor, string> = {
+  gray: '#8b97a6', red: '#f0626b', amber: '#f5b14c', yellow: '#eab308',
+  green: '#46c993', emerald: '#10b981', blue: '#5aa9ff', violet: '#a78bfa',
+};
+function hx(c?: WidgetColor): string { return (c && HEX[c]) || '#5aa9ff'; }
+function tint(c?: WidgetColor, a = '22'): string { return `${hx(c)}${a}`; }
+
+// ─── tiny markdown (escape → bold / code / links / bullets / headers) ──
+function mdInline(s: string): string {
+  let t = s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+  t = t.replace(/\[([^\]]+)\]\((https?:[^)]+)\)/g, '<a href="$2" target="_blank" rel="noreferrer" style="color:var(--accent)">$1</a>');
+  t = t.replace(/\*\*([^*]+)\*\*/g, '<b>$1</b>');
+  t = t.replace(/`([^`]+)`/g, '<code style="background:var(--bg-tertiary);padding:1px 4px;border-radius:4px;font-size:.9em">$1</code>');
+  return t;
+}
+function Markdown({ text }: { text: string }) {
+  const lines = (text || '').split('\n');
+  return (
+    <div className="space-y-1">
+      {lines.map((ln, i) => {
+        const t = ln.trim();
+        if (!t) return null;
+        if (/^#{1,3}\s/.test(t)) return <div key={i} className="text-[11px] font-semibold tracking-wide uppercase text-[var(--text-secondary)] mt-1" dangerouslySetInnerHTML={{ __html: mdInline(t.replace(/^#{1,3}\s/, '')) }} />;
+        if (/^[-*]\s/.test(t)) return <div key={i} className="text-[12px] flex gap-1.5"><span className="text-[var(--text-secondary)]">•</span><span dangerouslySetInnerHTML={{ __html: mdInline(t.replace(/^[-*]\s/, '')) }} /></div>;
+        // A short, fully-bold line acts as a section header.
+        if (/^\*\*.+\*\*$/.test(t)) return <div key={i} className="text-[10.5px] font-semibold uppercase tracking-[0.08em] text-[var(--text-secondary)] mt-2 mb-0.5" dangerouslySetInnerHTML={{ __html: mdInline(t) }} />;
+        return <div key={i} className="text-[12px] leading-relaxed text-[var(--text-primary)]" dangerouslySetInnerHTML={{ __html: mdInline(t) }} />;
+      })}
+    </div>
+  );
+}
+
+// ─── block renderer (rich toggles tile/avatar sizes) ──────
+function Block({ b, rich }: { b: WidgetBlock; rich?: boolean }) {
+  switch (b.type) {
+    case 'metric_row':
+      // Always one row: columns = item count (capped).
+      return (
+        <div className="grid gap-2" style={{ gridTemplateColumns: `repeat(${Math.min(b.items.length, rich ? 6 : 4)}, minmax(0,1fr))` }}>
+          {b.items.map((it, i) => (
+            <div key={i} className="rounded-lg border border-[var(--border)] bg-[var(--bg-tertiary)] text-center overflow-hidden"
+              style={{ padding: rich ? '8px 6px' : '3px 3px' }}>
+              <div className="font-bold leading-none" style={{ color: it.color ? hx(it.color) : 'var(--text-primary)', fontSize: rich ? 19 : 13 }}>{it.value}</div>
+              <div className="text-[var(--text-secondary)] uppercase tracking-wide truncate" style={{ fontSize: rich ? 9.5 : 7.5, marginTop: rich ? 4 : 1 }}>{it.label}</div>
+            </div>
+          ))}
+        </div>
+      );
+    case 'callout':
+      return (
+        <div className={`flex items-center gap-2 rounded-lg ${rich ? 'px-3 py-2.5 text-[12px]' : 'px-2.5 py-1.5 text-[11px]'}`}
+          style={{ background: tint(b.color, '1a'), border: `1px solid ${tint(b.color, '55')}`, color: 'var(--text-primary)' }}>
+          <span className="leading-none" style={{ fontSize: rich ? 16 : 12 }}>{b.icon || '⚠️'}</span>
+          <span className={rich ? '' : 'truncate'} dangerouslySetInnerHTML={{ __html: mdInline(b.text) }} />
+        </div>
+      );
+    case 'list':
+      return (
+        <div>
+          {b.items.map((it, i) => (
+            <div key={i} className={`flex gap-2.5 border-b border-[var(--border)]/40 last:border-0 ${rich ? 'py-1.5' : 'py-[3px]'}`}>
+              {rich && it.avatar
+                ? <span className="shrink-0 grid place-items-center rounded-full font-bold" style={{ width: 24, height: 24, fontSize: 9.5, background: hx(it.badgeColor), color: '#0e1116' }}>{it.avatar}</span>
+                : <span className="shrink-0 rounded-full mt-1" style={{ width: 3, alignSelf: 'stretch', background: hx(it.badgeColor) }} />}
+              <div className="min-w-0 flex-1">
+                <div className={`text-[12px] leading-snug text-[var(--text-primary)] ${rich ? '' : 'truncate'}`}>
+                  {it.badge && <span className="inline-block font-bold align-middle mr-1.5 rounded-full" style={{ fontSize: 8.5, padding: '2px 6px', background: tint(it.badgeColor), color: hx(it.badgeColor) }}>{it.badge}</span>}
+                  {it.href ? <a href={it.href} target="_blank" rel="noreferrer" className="hover:underline" style={{ color: 'var(--text-primary)' }}>{it.text}</a> : it.text}
+                </div>
+                {it.sub && <div className={`text-[10.5px] text-[var(--text-secondary)] mt-0.5 ${rich ? '' : 'truncate'}`}>{it.sub}</div>}
+              </div>
+            </div>
+          ))}
+        </div>
+      );
+    case 'progress': {
+      const pct = Math.max(0, Math.min(100, b.max ? (b.value / b.max) * 100 : 0));
+      const c = hx(b.color || 'green');
+      return (
+        <div>
+          <div className="flex justify-between text-[11px] text-[var(--text-secondary)] mb-1"><span>{b.label}</span><span>{b.value}/{b.max}</span></div>
+          <div className="rounded-full overflow-hidden bg-[var(--bg-tertiary)]" style={{ height: rich ? 8 : 6 }}>
+            <div className="h-full rounded-full" style={{ width: `${pct}%`, background: `linear-gradient(90deg, ${c}, ${hx('blue')})` }} />
+          </div>
+        </div>
+      );
+    }
+    case 'stat':
+      return (
+        <div>
+          <div className="font-bold" style={{ fontSize: rich ? 30 : 24, color: 'var(--text-primary)' }}>{b.value}</div>
+          <div className="text-[10.5px] text-[var(--text-secondary)]">{b.label}{b.delta && <span style={{ color: hx(b.deltaColor) }}> {b.delta}</span>}</div>
+        </div>
+      );
+    case 'table':
+      return (
+        <table className="w-full text-[10.5px]">
+          <thead><tr>{b.columns.map((c, i) => <th key={i} className="text-left font-medium text-[var(--text-secondary)] pb-1">{c}</th>)}</tr></thead>
+          <tbody>{b.rows.map((r, ri) => <tr key={ri} className="border-t border-[var(--border)]/40">{r.map((c, ci) => <td key={ci} className="pr-2 py-1 align-top">{c}</td>)}</tr>)}</tbody>
+        </table>
+      );
+    case 'badges':
+      return (
+        <div className="flex flex-wrap gap-1.5">
+          {b.items.map((it, i) => <span key={i} className="font-medium rounded-full" style={{ fontSize: 9.5, padding: '3px 8px', background: tint(it.color), color: hx(it.color) }}>{it.text}</span>)}
+        </div>
+      );
+    case 'text':
+    default:
+      return <Markdown text={(b as any).markdown ?? ''} />;
+  }
+}
+
+function WidgetView({ spec, rich }: { spec: WidgetSpec; rich?: boolean }) {
+  return (
+    <div className={rich ? 'space-y-3.5' : 'space-y-1.5'}>
+      {spec.blocks.map((b, i) => <Block key={i} b={b} rich={rich} />)}
+      {/* footer is low-value detail — only show it in the expanded modal. */}
+      {spec.footer && rich && <div className="text-[10px] text-[var(--text-secondary)] pt-1 border-t border-[var(--border)]/40">{spec.footer}</div>}
+    </div>
+  );
+}
+
+// ─── helpers ──────────────────────────────────────────────
+function ago(iso?: string | null): string {
+  if (!iso) return 'never';
+  const s = Math.floor((Date.now() - new Date(iso).getTime()) / 1000);
+  if (s < 60) return `${s}s`; if (s < 3600) return `${Math.floor(s / 60)}m`;
+  if (s < 86400) return `${Math.floor(s / 3600)}h`; return `${Math.floor(s / 86400)}d`;
+}
+function statusDot(s: KanbanCard['status']): string {
+  return s === 'error' ? HEX.red : s === 'running' ? HEX.amber : s === 'ok' ? HEX.green : 'var(--text-secondary)';
+}
+
+// ─── compact card (Style A) ───────────────────────────────
+function Card({ card, onOpen, onRefresh, onDelete }: {
+  card: KanbanCard; onOpen: () => void; onRefresh: () => void; onDelete: () => void;
+}) {
+  const running = card.status === 'running';
+  const accent = card.lastResult?.accent;
+  const stop = (e: React.MouseEvent) => e.stopPropagation();
+  return (
+    <button onClick={onOpen}
+      className="shrink-0 flex flex-col rounded-xl border border-[var(--border)] bg-[var(--bg-secondary)] overflow-hidden text-left hover:border-[var(--accent)]/50 transition-colors shadow-sm"
+      style={{ width: CARD_W, height: CARD_H }} title="Click to expand">
+      <div className="h-[3px] w-full shrink-0" style={{ background: hx(accent) }} />
+      <div className="flex items-center gap-2 px-3 py-2 shrink-0">
+        <span className="grid place-items-center rounded-lg shrink-0" style={{ width: 24, height: 24, background: tint(accent, '28'), fontSize: 13 }}>{card.icon || '🔧'}</span>
+        <span className="text-[12.5px] font-semibold text-[var(--text-primary)] truncate flex-1">{card.title}</span>
+        <span className="w-1.5 h-1.5 rounded-full shrink-0" style={{ background: statusDot(card.status) }} />
+        <span className="text-[9px] text-[var(--text-secondary)] shrink-0">{running ? '…' : ago(card.lastRunAt)}</span>
+        {card.connectorUrl && <a href={card.connectorUrl} target="_blank" rel="noreferrer" onClick={stop} title="Open connector" className="text-[var(--text-secondary)] hover:text-[var(--text-primary)] text-[11px]">↗</a>}
+        <span onClick={(e) => { stop(e); onRefresh(); }} title="Refresh" className={`text-[var(--text-secondary)] hover:text-[var(--text-primary)] text-[11px] ${running ? 'opacity-40 pointer-events-none' : ''}`}>⟳</span>
+        <span onClick={(e) => { stop(e); onDelete(); }} title="Delete" className="text-[var(--text-secondary)] hover:text-red-500 text-[11px]">✕</span>
+      </div>
+      <div className="relative flex-1 overflow-hidden px-3 pb-2">
+        {card.lastResult ? <WidgetView spec={card.lastResult} />
+          : card.status === 'error' ? <div className="text-[10px] text-red-500 line-clamp-3">{card.lastError || 'failed'}</div>
+            : <div className="text-[10px] text-[var(--text-secondary)]">{running ? 'Running…' : 'No data yet — click ⟳.'}</div>}
+        <div className="pointer-events-none absolute bottom-0 inset-x-0 h-7 bg-gradient-to-t from-[var(--bg-secondary)] to-transparent" />
+      </div>
+    </button>
+  );
+}
+
+// ─── rich modal (Style B) ─────────────────────────────────
+function CardModal({ card, onClose, onRefresh, onSaved }: {
+  card: KanbanCard; onClose: () => void; onRefresh: () => void; onSaved: () => void;
+}) {
+  const [editing, setEditing] = useState(false);
+  const [prompt, setPrompt] = useState(card.prompt);
+  const [periodMin, setPeriodMin] = useState(Math.round(card.periodSec / 60));
+  const [execMode, setExecMode] = useState<'inline' | 'task'>(card.execMode);
+  const [saving, setSaving] = useState(false);
+  const panelRef = useRef<HTMLDivElement>(null);
+  const accent = card.lastResult?.accent;
+
+  const [size] = useState<{ w: number; h: number }>(() => {
+    if (typeof window === 'undefined') return { w: 760, h: 680 };
+    try { const s = JSON.parse(localStorage.getItem('forge.kanban.modalSize') || ''); if (s?.w && s?.h) return s; } catch {}
+    return { w: Math.min(760, window.innerWidth - 64), h: Math.min(720, Math.round(window.innerHeight * 0.84)) };
+  });
+
+  useEffect(() => {
+    const onKey = (e: KeyboardEvent) => { if (e.key === 'Escape') onClose(); };
+    window.addEventListener('keydown', onKey);
+    return () => window.removeEventListener('keydown', onKey);
+  }, [onClose]);
+  useEffect(() => {
+    const el = panelRef.current;
+    if (!el || typeof ResizeObserver === 'undefined') return;
+    const ro = new ResizeObserver(() => { try { localStorage.setItem('forge.kanban.modalSize', JSON.stringify({ w: el.offsetWidth, h: el.offsetHeight })); } catch {} });
+    ro.observe(el);
+    return () => ro.disconnect();
+  }, []);
+
+  const save = async (thenRun: boolean) => {
+    setSaving(true);
+    await fetch(`/api/kanban?id=${card.id}`, {
+      method: 'PATCH', headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ prompt, periodSec: Math.max(60, periodMin * 60), execMode }),
+    }).catch(() => {});
+    setSaving(false); setEditing(false); onSaved();
+    if (thenRun) onRefresh();
+  };
+
+  return (
+    <div className="fixed inset-0 z-50 flex items-center justify-center bg-black/40 p-4">
+      <div ref={panelRef} className="flex flex-col rounded-2xl border border-[var(--border)] bg-[var(--bg-secondary)] shadow-2xl"
+        style={{ width: size.w, height: size.h, maxWidth: '95vw', maxHeight: '92vh', minWidth: 480, minHeight: 320, resize: 'both', overflow: 'hidden' }}
+        onClick={(e) => e.stopPropagation()}>
+        <div className="h-[3px] w-full shrink-0" style={{ background: hx(accent) }} />
+        <div className="flex items-center gap-2.5 px-4 py-3 border-b border-[var(--border)]">
+          <span className="grid place-items-center rounded-lg" style={{ width: 30, height: 30, background: tint(accent, '28'), fontSize: 16 }}>{card.icon || '🔧'}</span>
+          <span className="text-[15px] font-semibold text-[var(--text-primary)] flex-1 truncate">{card.title}</span>
+          <span className="text-[10px] text-[var(--text-secondary)]">{card.status} · {ago(card.lastRunAt)}</span>
+          {card.connectorUrl && <a href={card.connectorUrl} target="_blank" rel="noreferrer" className="text-[11px] text-[var(--accent)] hover:underline">open ↗</a>}
+          <button onClick={() => onRefresh()} disabled={card.status === 'running'} className="text-[var(--text-secondary)] hover:text-[var(--text-primary)] text-sm disabled:opacity-40" title="Run now">⟳</button>
+          <button onClick={onClose} className="text-[var(--text-secondary)] hover:text-[var(--text-primary)] text-sm" title="Close">✕</button>
+        </div>
+
+        <div className="flex-1 overflow-auto p-4">
+          {editing ? (
+            <div className="space-y-3">
+              <div>
+                <label className="text-[10px] uppercase tracking-wide text-[var(--text-secondary)]">Prompt</label>
+                <textarea value={prompt} onChange={(e) => setPrompt(e.target.value)} rows={11}
+                  className="mt-1 w-full text-[12px] rounded-md border border-[var(--border)] bg-[var(--bg-primary)] p-2 font-mono text-[var(--text-primary)] resize-y" />
+              </div>
+              <div className="flex items-center gap-2">
+                <label className="text-[10px] uppercase tracking-wide text-[var(--text-secondary)]">Refresh every</label>
+                <input type="number" min={1} value={periodMin} onChange={(e) => setPeriodMin(Math.max(1, parseInt(e.target.value || '1', 10)))}
+                  className="w-20 text-[12px] rounded-md border border-[var(--border)] bg-[var(--bg-primary)] px-2 py-1 text-[var(--text-primary)]" />
+                <span className="text-[11px] text-[var(--text-secondary)]">minutes</span>
+              </div>
+              <div className="flex items-center gap-2">
+                <label className="text-[10px] uppercase tracking-wide text-[var(--text-secondary)]">Run mode</label>
+                <select value={execMode} onChange={(e) => setExecMode(e.target.value as 'inline' | 'task')}
+                  className="text-[12px] rounded-md border border-[var(--border)] bg-[var(--bg-primary)] px-2 py-1 text-[var(--text-primary)]">
+                  <option value="inline">inline — fast (simple cards)</option>
+                  <option value="task">task — heavier, multi-step</option>
+                </select>
+              </div>
+              <div className="flex gap-2 pt-1">
+                <button onClick={() => save(true)} disabled={saving} className="text-[11px] px-3 py-1 rounded-md bg-[var(--accent)] text-white disabled:opacity-50">{saving ? 'Saving…' : 'Save & run'}</button>
+                <button onClick={() => save(false)} disabled={saving} className="text-[11px] px-3 py-1 rounded-md border border-[var(--border)] text-[var(--text-primary)]">Save</button>
+                <button onClick={() => { setEditing(false); setPrompt(card.prompt); setPeriodMin(Math.round(card.periodSec / 60)); setExecMode(card.execMode); }} className="text-[11px] px-3 py-1 rounded-md text-[var(--text-secondary)]">Cancel</button>
+              </div>
+            </div>
+          ) : (
+            <div className="space-y-3">
+              {card.lastResult ? <WidgetView spec={card.lastResult} rich />
+                : <div className="text-[11px] text-[var(--text-secondary)]">{card.status === 'running' ? 'Running…' : 'No data yet — run it with ⟳.'}</div>}
+              {card.status === 'error' && <div className="text-[10px] text-red-500/80 border-t border-[var(--border)] pt-2">last run failed: {card.lastError}</div>}
+            </div>
+          )}
+        </div>
+
+        {!editing && (
+          <div className="px-4 py-2 border-t border-[var(--border)] flex items-center">
+            <button onClick={() => setEditing(true)} className="text-[11px] text-[var(--accent)] hover:underline">Edit prompt / period</button>
+            <span className="flex-1" />
+            <span className="text-[10px] text-[var(--text-secondary)]">{card.connectorId} · {card.execMode} · every {Math.round(card.periodSec / 60)}m</span>
+          </div>
+        )}
+      </div>
+    </div>
+  );
+}
+
+// ─── board ────────────────────────────────────────────────
+export default function KanbanBoard() {
+  const [cards, setCards] = useState<KanbanCard[] | null>(null);
+  const [collapsed, setCollapsed] = useState(false);
+  const [openId, setOpenId] = useState<string | null>(null);
+  const scroller = useRef<HTMLDivElement>(null);
+
+  useEffect(() => { try { setCollapsed(localStorage.getItem('forge.kanban.collapsed') === '1'); } catch {} }, []);
+  const toggle = () => setCollapsed((c) => { const n = !c; try { localStorage.setItem('forge.kanban.collapsed', n ? '1' : '0'); } catch {} return n; });
+
+  const load = useCallback(async () => {
+    try { const r = await fetch('/api/kanban'); const j = await r.json(); setCards(Array.isArray(j.cards) ? j.cards : []); }
+    catch { setCards([]); }
+  }, []);
+  useEffect(() => { void load(); }, [load]);
+  useEffect(() => { const t = setInterval(() => { if (!collapsed) void load(); }, 15000); return () => clearInterval(t); }, [collapsed, load]);
+
+  const refresh = async (id: string) => {
+    setCards((cs) => cs?.map((c) => c.id === id ? { ...c, status: 'running' } : c) ?? cs);
+    await fetch(`/api/kanban/${id}/run`, { method: 'POST' }).catch(() => {});
+    void load();
+  };
+  const del = async (id: string) => {
+    if (!confirm('Delete this card?')) return;
+    await fetch(`/api/kanban?id=${id}`, { method: 'DELETE' }).catch(() => {});
+    if (openId === id) setOpenId(null);
+    void load();
+  };
+  const seed = async () => { await fetch('/api/kanban/seed', { method: 'POST' }).catch(() => {}); void load(); };
+  const scrollBy = (dx: number) => scroller.current?.scrollBy({ left: dx, behavior: 'smooth' });
+
+  if (cards === null) return null;
+  const open = openId ? cards.find((c) => c.id === openId) || null : null;
+
+  return (
+    <div className="shrink-0 border-b border-[var(--border)] bg-[var(--bg-primary)]">
+      <div className="flex items-center gap-2 px-3 py-1.5">
+        <button onClick={toggle} className="text-[11px] font-medium text-[var(--text-primary)] flex items-center gap-1">
+          <span className="text-[var(--text-secondary)]">{collapsed ? '▸' : '▾'}</span> Kanban
+        </button>
+        <span className="text-[10px] text-[var(--text-secondary)]">{cards.length}</span>
+        <div className="flex-1" />
+        {!collapsed && cards.length > 0 && (
+          <>
+            <button onClick={() => scrollBy(-CARD_W * 2)} title="Scroll left" className="text-[var(--text-secondary)] hover:text-[var(--text-primary)] text-xs px-1">‹</button>
+            <button onClick={() => scrollBy(CARD_W * 2)} title="Scroll right" className="text-[var(--text-secondary)] hover:text-[var(--text-primary)] text-xs px-1">›</button>
+          </>
+        )}
+        <button onClick={seed} title="Add default cards from installed connectors" className="text-[10px] text-[var(--text-secondary)] hover:text-[var(--text-primary)] px-1">+ defaults</button>
+      </div>
+
+      {!collapsed && (
+        cards.length === 0 ? (
+          <div className="px-3 pb-2 text-[10px] text-[var(--text-secondary)]">
+            No cards yet. <button onClick={seed} className="text-[var(--accent)] hover:underline">Seed from connectors</button> to auto-create cards.
+          </div>
+        ) : (
+          <div ref={scroller} className="flex gap-3 px-3 pb-3 overflow-x-auto">
+            {cards.map((c) => <Card key={c.id} card={c} onOpen={() => setOpenId(c.id)} onRefresh={() => refresh(c.id)} onDelete={() => del(c.id)} />)}
+          </div>
+        )
+      )}
+
+      {open && <CardModal card={open} onClose={() => setOpenId(null)} onRefresh={() => refresh(open.id)} onSaved={() => load()} />}
+    </div>
+  );
+}

package/lib/chat/agent-loop.ts

@@ -513,7 +513,7 @@ function detectMentionedConnectors(
   return { strong, medium };
 }
 
-function buildConnectorTools(): LlmTool[] {
+export function buildConnectorTools(): LlmTool[] {
   const out: LlmTool[] = [];
   for (const inst of listInstalledConnectors()) {
     if (!inst.enabled) continue;

package/lib/claude-process.ts

@@ -6,7 +6,10 @@
  */
 
 import { spawn, execSync, type ChildProcess } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
 import { loadSettings } from './settings';
+import { getConfigDir } from './dirs';
 
 export interface ClaudeMessage {
   type: 'system' | 'assistant' | 'result';
@@ -93,6 +96,15 @@ export function sendToClaudeSession(
   const env = { ...process.env };
   delete env.CLAUDECODE;
 
+  // Corporate SSL: behind an intercepting proxy the spawned CLI fails with
+  // "SSL certificate verification failed" unless it trusts the corp CA. If the
+  // server was launched without NODE_EXTRA_CA_CERTS but a CA bundle is dropped
+  // at <configDir>/corporate-ca.pem, wire it through so the child inherits it.
+  if (!env.NODE_EXTRA_CA_CERTS) {
+    const corpCa = join(getConfigDir(), 'corporate-ca.pem');
+    if (existsSync(corpCa)) env.NODE_EXTRA_CA_CERTS = corpCa;
+  }
+
   // Resolve full path so spawn works without shell for PATH lookup.
   // Was a lazy require() — fired ReferenceError on Claude task spawn
   // under ESM concurrent loads. Now top-level imported.

package/lib/help-docs/14-kanban.md

@@ -0,0 +1,59 @@
+# Home Kanban
+
+The home page shows a collapsible **Kanban** board of connector-driven cards.
+Each card runs a prompt against one connector on its own schedule and renders the
+result as a compact widget. Nothing is hardcoded per connector — a card is just
+*connector + prompt + period*, and the prompt's output drives what's drawn.
+
+## Cards
+
+- **Compact + fixed-size**: cards are small previews so the board never dominates
+  the page. Click a card to open a floating modal with the full widget.
+- **Status dot**: grey idle · amber running · green ok · red error.
+- **⟳ refresh** runs the card now. **✕** deletes it. **↗** opens the connector site.
+- **+ defaults** seeds cards from your installed connectors' declared defaults
+  (idempotent — re-running won't duplicate).
+
+## Editing a card (no connector republish)
+
+A card's prompt and period live in Forge's local database, seeded from the
+connector manifest's `kanban:` block only on first install / `+ defaults`. To
+tune a card, open it and click **Edit prompt / period** — change the prompt text,
+the refresh interval, or the run mode, then **Save & run**. This only changes the
+local card; you never need to edit or republish the connector.
+
+## Run modes
+
+- **inline** (default): a fast single LLM turn using your default API profile.
+  Best for simple count/list cards.
+- **task**: the card is dispatched as a one-shot CLI task (the same backend as
+  normal Forge tasks) that can work over many steps, call the connector via the
+  Forge MCP tools, and write the final widget to
+  `<dataDir>/kanban/<cardId>/widget.json`. Best for heavy connectors (many tools)
+  or richer, multi-step content. The task may also write supplementary files
+  (e.g. `report.md`) into the same folder and link to them from the widget via
+  `href` `/api/kanban/<cardId>/artifact/<filename>`.
+
+Heavy connectors can declare `mode: task` per card in their manifest; you can
+also flip any card's mode in the Edit panel.
+
+## Declaring cards in a connector
+
+A connector manifest may carry kanban defaults (read by Forge's seeder, ignored
+by the connector loader — fully additive, old Forge versions skip it):
+
+```yaml
+kanban:
+  cards:
+    - title: "My widget"
+      icon: "📊"
+      prompt: |
+        What to gather + how to summarize.
+      period_sec: 1800     # refresh cadence (default 1800)
+      mode: task           # optional: 'inline' (default) | 'task'
+```
+
+## Refresh cadence
+
+Cards refresh on their own period via the same scheduler tick as Schedules, plus
+manual ⟳. Snapshots are stored, so a card shows its last result until the next run.

package/lib/kanban/artifacts.ts

@@ -0,0 +1,52 @@
+/**
+ * Per-card artifact directory under <dataDir>/kanban/<cardId>/. A task-mode run
+ * writes its final widget to widget.json here, plus optional supplementary
+ * files (report.md, data, …) the widget can link to via the artifact route.
+ */
+
+import { join, normalize } from 'node:path';
+import { existsSync, mkdirSync, readFileSync, rmSync } from 'node:fs';
+import { getDataDir } from '../dirs';
+import type { WidgetSpec } from './types';
+
+const WIDGET_FILE = 'widget.json';
+
+export function cardArtifactDir(cardId: string): string {
+  return join(getDataDir(), 'kanban', cardId);
+}
+
+export function ensureArtifactDir(cardId: string): string {
+  const dir = cardArtifactDir(cardId);
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+export function widgetFilePath(cardId: string): string {
+  return join(cardArtifactDir(cardId), WIDGET_FILE);
+}
+
+/** Remove a stale widget.json before a run so we never read a previous result. */
+export function clearWidgetFile(cardId: string): void {
+  try { rmSync(widgetFilePath(cardId), { force: true }); } catch { /* ignore */ }
+}
+
+/** Read + validate the widget.json a task wrote. Null if missing/invalid. */
+export function readWidgetFile(cardId: string): WidgetSpec | null {
+  const p = widgetFilePath(cardId);
+  if (!existsSync(p)) return null;
+  try {
+    const v = JSON.parse(readFileSync(p, 'utf-8'));
+    if (v && typeof v === 'object' && Array.isArray((v as any).blocks)) return v as WidgetSpec;
+  } catch { /* invalid */ }
+  return null;
+}
+
+/** Resolve a requested artifact name to an absolute path INSIDE the card dir,
+ *  or null on traversal / escape. Used by the artifact-serving route. */
+export function safeArtifactPath(cardId: string, name: string): string | null {
+  const base = cardArtifactDir(cardId);
+  const full = normalize(join(base, name));
+  if (full !== base && !full.startsWith(base + '/')) return null; // escaped the dir
+  if (!existsSync(full)) return null;
+  return full;
+}

package/lib/kanban/executor.ts

@@ -0,0 +1,141 @@
+/**
+ * Kanban card executor (P2). Runs a card's prompt as a headless,
+ * connector-scoped LLM turn: only the target connector's tools are exposed,
+ * the system prompt constrains output to a WidgetSpec JSON, and the loop
+ * dispatches any tool calls until the model returns a final widget.
+ *
+ * Reuses the chat primitives — streamLlm (LLM adapter), resolveProvider
+ * (default API profile), buildConnectorTools (tool specs), dispatchTool
+ * (connector execution) — so it stays consistent with the chat agent loop
+ * without dragging in the session machinery.
+ */
+
+import { randomUUID } from 'node:crypto';
+import { streamLlm } from '../chat/llm';
+import { resolveProvider, buildConnectorTools } from '../chat/agent-loop';
+import { dispatchTool } from '../chat/tool-dispatcher';
+import type { Message, ContentBlock } from '../chat/types';
+import type { WidgetSpec } from './types';
+import { getCard, setCardRunning, setCardResult, setCardError } from './store';
+
+const MAX_TOOL_ROUNDS = 6;
+const MAX_TOKENS = 2000;
+
+/** The WidgetSpec schema, shared by the inline system prompt and the task-mode
+ *  contract prompt so both paths produce the same shape. */
+export const WIDGET_SCHEMA_TEXT = [
+  'A widget is a single JSON object matching:',
+  '{ "accent"?: Color, "blocks": Block[], "footer"?: string }',
+  'Color = "gray"|"red"|"amber"|"yellow"|"green"|"emerald"|"blue"|"violet"',
+  'Block is one of:',
+  '  {"type":"metric_row","items":[{"label":string,"value":string|number,"color"?:Color}]}',
+  '  {"type":"list","items":[{"text":string,"badge"?:string,"badgeColor"?:Color,"sub"?:string,"href"?:string,"avatar"?:string}]}',
+  '  {"type":"stat","value":string|number,"label":string,"delta"?:string,"deltaColor"?:Color}',
+  '  {"type":"progress","label":string,"value":number,"max":number,"color"?:Color}',
+  '  {"type":"table","columns":string[],"rows":string[][]}',
+  '  {"type":"badges","items":[{"text":string,"color"?:Color}]}',
+  '  {"type":"callout","text":string,"color"?:Color,"icon"?:string}   // highlighted alert box, e.g. "2 items overdue"',
+  '  {"type":"text","markdown":string}   // a short **bold** line works as a section header; supports bold/`code`/[links](url)/- bullets',
+  '',
+  'Guidance: lead with a metric_row (counts) and/or a callout for anything urgent. Use a progress block for "X of Y done / release readiness" — it renders as a nice bar. For people, set list item "avatar" to their initials (e.g. "YC"). Group long lists under short **bold** text headers.',
+  'BE TERSE: the card is small. List item "text" should be short (aim ≤ 6 words / fits one line — the compact card truncates the rest); put any extra detail in "sub", also short. Prefer keywords over sentences. metric labels ≤ 1-2 words.',
+].join('\n');
+
+function systemPrompt(): string {
+  return [
+    'You generate a Forge dashboard "kanban card". Use the available connector tools to gather exactly what the user prompt asks for, then summarize into a compact, glanceable widget.',
+    '',
+    'Output ONLY a single JSON object (no prose, no markdown fences) matching:',
+    WIDGET_SCHEMA_TEXT.split('\n').slice(1).join('\n'),
+    '',
+    'Keep it glanceable: short labels, at most ~6 list items. Choose block types that fit the data (e.g. counts → metric_row, items → list). If a tool errors or returns nothing, still return a valid widget (a text block explaining the state).',
+  ].join('\n');
+}
+
+function msg(role: 'user' | 'assistant', cardId: string, blocks: ContentBlock[]): Message {
+  return { id: randomUUID(), session_id: `kanban:${cardId}`, role, blocks, ts: Date.now() };
+}
+
+/** Run one card. Persists the result/error snapshot; never throws. */
+export async function runKanbanCard(cardId: string): Promise<{ ok: boolean; error?: string }> {
+  const card = getCard(cardId);
+  if (!card) return { ok: false, error: 'card not found' };
+
+  const provider = resolveProvider(null, null);
+  if ('error' in provider) {
+    setCardError(cardId, `provider: ${provider.error}`);
+    return { ok: false, error: provider.error };
+  }
+
+  const tools = buildConnectorTools().filter((t) => t.name.split('.')[0] === card.connectorId);
+  if (tools.length === 0) {
+    setCardError(cardId, `connector '${card.connectorId}' has no usable tools (installed + enabled?)`);
+    return { ok: false, error: 'no connector tools' };
+  }
+
+  setCardRunning(cardId);
+  const history: Message[] = [msg('user', cardId, [{ type: 'text', text: card.prompt }])];
+
+  try {
+    for (let round = 0; round < MAX_TOOL_ROUNDS; round++) {
+      const res = await streamLlm(
+        {
+          provider: provider.type,
+          apiKey: provider.apiKey,
+          baseUrl: provider.baseUrl,
+          model: provider.model,
+          system: systemPrompt(),
+          history,
+          tools,
+          maxTokens: MAX_TOKENS,
+        },
+        { onTextDelta: () => {}, onToolUse: () => {} },
+      );
+      history.push(msg('assistant', cardId, res.content));
+
+      const toolUses = res.content.filter(
+        (b): b is Extract<ContentBlock, { type: 'tool_use' }> => b.type === 'tool_use',
+      );
+      if (res.stopReason === 'tool_use' && toolUses.length > 0) {
+        const results: ContentBlock[] = [];
+        for (const tu of toolUses) {
+          const r = await dispatchTool({ id: tu.id, name: tu.name, input: tu.input });
+          results.push({ type: 'tool_result', tool_use_id: tu.id, content: r.content, is_error: r.is_error });
+        }
+        history.push(msg('user', cardId, results));
+        continue;
+      }
+
+      const text = res.content
+        .filter((b): b is Extract<ContentBlock, { type: 'text' }> => b.type === 'text')
+        .map((b) => b.text)
+        .join('')
+        .trim();
+      const spec = parseWidget(text);
+      if (!spec) {
+        setCardError(cardId, 'LLM did not return a valid widget JSON');
+        return { ok: false, error: 'invalid widget' };
+      }
+      setCardResult(cardId, spec);
+      return { ok: true };
+    }
+    setCardError(cardId, `exceeded ${MAX_TOOL_ROUNDS} tool rounds without a final widget`);
+    return { ok: false, error: 'max rounds' };
+  } catch (e) {
+    setCardError(cardId, (e as Error).message);
+    return { ok: false, error: (e as Error).message };
+  }
+}
+
+/** Tolerant extract: strip optional code fences, take the outermost {...}. */
+export function parseWidget(text: string): WidgetSpec | null {
+  const stripped = text.replace(/^```(?:json)?/i, '').replace(/```$/, '').trim();
+  const start = stripped.indexOf('{');
+  const end = stripped.lastIndexOf('}');
+  if (start === -1 || end === -1 || end <= start) return null;
+  try {
+    const v = JSON.parse(stripped.slice(start, end + 1));
+    if (v && typeof v === 'object' && Array.isArray((v as any).blocks)) return v as WidgetSpec;
+  } catch { /* not valid JSON */ }
+  return null;
+}