@aion0/forge 0.9.16 → 0.9.19

package/RELEASE_NOTES.md

@@ -1,14 +1,18 @@
-# Forge v0.9.16
+# Forge v0.9.19
 
-Released: 2026-05-28
+Released: 2026-05-29
 
-## Changes since v0.9.15
-
-### Bug Fixes
-- fix: convert all @/ aliases in lib/ and src/ to relative paths
+## Changes since v0.9.18
 
 ### Other
-- fix(chat): replace @/src/* aliases with relative paths in lib/
+- feat(memory): writeEpisode dual-write + Memory drawer in /chat web
+- feat(monitor): D3 — Memory Worker row in Settings Monitor
+- feat(chat): Phase C — agent-loop reads summarized memory + token-budget history
+- feat(memory): B11 — spawn memory-standalone from forge-server + dev supervisor
+- fix(memory): bypass ai-sdk for summarizer LLM call — raw fetch instead
+- feat(memory): Phase B — memory-standalone process + Temper Summary sub-task
+- feat(memory): Phase A — key conventions + buildMemoryContext + OR-match search
+- fix(chat): cap LLM history at last 40 messages and drop orphan tool_results
 
 
-**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.9.15...v0.9.16
+**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.9.18...v0.9.19

package/app/api/connectors/[id]/settings/route.ts

@@ -41,17 +41,76 @@ function defaultsFor(id: string): Record<string, any> {
 
 const SECRET_MASK = '••••••••';
 
-function isSecretField(schema: ConnectorFieldSchema | undefined): boolean {
-  if (!schema) return false;
-  return schema.type === 'secret' || (schema.type as string) === 'password';
+/**
+ * Walk `value` against `schema`, applying `mask` (plaintext → ••••) or
+ * `restore` (•••• → stored plaintext). Recurses into `type: 'instances'`
+ * arrays so per-row sub-secrets get the same mask treatment as flat
+ * top-level secrets. Mirrors the encrypt/decrypt walker in
+ * lib/connectors/registry.ts so the on-disk and over-the-wire
+ * representations stay symmetric.
+ */
+function transformFieldSecrets(
+  value: any,
+  schema: ConnectorFieldSchema | undefined,
+  existingValue: any,
+  op: 'mask' | 'restore',
+): any {
+  if (!schema) return value;
+  const t = String((schema as any)?.type || '');
+
+  if (t === 'secret' || t === 'password') {
+    if (op === 'mask') {
+      return typeof value === 'string' && value ? SECRET_MASK : value;
+    }
+    // restore
+    if (value === SECRET_MASK) {
+      return typeof existingValue === 'string' ? existingValue : undefined;
+    }
+    return value;
+  }
+
+  if (t === 'instances' && (schema as any).fields) {
+    const wasString = typeof value === 'string';
+    let rows: any;
+    if (wasString) {
+      try { rows = JSON.parse(value); } catch { return value; }
+    } else {
+      rows = value;
+    }
+    if (!Array.isArray(rows)) return value;
+
+    // Build name→row map of the existing stored value so per-instance
+    // mask restoration can find the corresponding row by name.
+    let existingRows: any[] = [];
+    if (typeof existingValue === 'string') {
+      try { existingRows = JSON.parse(existingValue); } catch { existingRows = []; }
+    } else if (Array.isArray(existingValue)) {
+      existingRows = existingValue;
+    }
+    const existingByName = new Map<string, any>();
+    for (const r of existingRows) {
+      if (r && typeof r === 'object' && typeof r.name === 'string') existingByName.set(r.name, r);
+    }
+
+    const transformed = rows.map((row: any) => {
+      if (!row || typeof row !== 'object') return row;
+      const existingRow = (typeof row.name === 'string' && existingByName.get(row.name)) || {};
+      const out: any = { ...row };
+      for (const [k, sub] of Object.entries((schema as any).fields)) {
+        out[k] = transformFieldSecrets(out[k], sub as ConnectorFieldSchema, existingRow[k], op);
+      }
+      return out;
+    });
+    return wasString ? JSON.stringify(transformed) : transformed;
+  }
+
+  return value;
 }
 
 function maskSecrets(settings: Record<string, any>, schema: Record<string, ConnectorFieldSchema>): Record<string, any> {
   const out: Record<string, any> = { ...settings };
   for (const [k, v] of Object.entries(schema)) {
-    if (isSecretField(v) && typeof out[k] === 'string' && out[k]) {
-      out[k] = SECRET_MASK;
-    }
+    out[k] = transformFieldSecrets(out[k], v, undefined, 'mask');
   }
   return out;
 }
@@ -63,10 +122,9 @@ function restoreSecrets(
 ): Record<string, any> {
   const out: Record<string, any> = { ...incoming };
   for (const [k, v] of Object.entries(schema)) {
-    if (isSecretField(v) && out[k] === SECRET_MASK) {
-      if (typeof existing[k] === 'string') out[k] = existing[k];
-      else delete out[k];
-    }
+    const restored = transformFieldSecrets(out[k], v, existing[k], 'restore');
+    if (restored === undefined) delete out[k];
+    else out[k] = restored;
   }
   return out;
 }

package/app/api/connectors/[id]/test/route.ts

@@ -34,6 +34,7 @@ import {
 } from '@/lib/connectors/registry';
 import { expandSettingsTokens, expandAllTokens } from '@/lib/plugins/templates';
 import { bridgeRpc } from '@/lib/chat/bridge-client';
+import { applyAuth } from '@/lib/chat/protocols/http';
 import type { ConnectorDefinition, ConnectorTest, HttpRequestSpec } from '@/lib/connectors/types';
 
 const DEFAULT_TIMEOUT_MS = 15_000;
@@ -106,17 +107,39 @@ interface TestResult {
   body_preview?: string;
 }
 
-async function runHttpProbe(test: ConnectorTest, settings: Record<string, unknown>): Promise<TestResult> {
+async function runHttpProbe(test: ConnectorTest, settings: Record<string, unknown>, def: ConnectorDefinition): Promise<TestResult> {
   const spec = test.request;
   if (!spec?.url) return { ok: false, error: 'test.request.url is required for http probe' };
 
+  // Multi-instance overlay: test probe always uses the first instance
+  // (same guard as tool-dispatcher — only kicks in when instances is a
+  // well-formed array, so single-instance connectors are unaffected).
+  let effectiveSettings = settings as Record<string, any>;
+  let instances = effectiveSettings?.instances;
+  // type: json fields persist as strings — parse before checking.
+  if (typeof instances === 'string') {
+    try { instances = JSON.parse(instances); } catch { instances = null; }
+  }
+  if (
+    Array.isArray(instances) &&
+    instances.length > 0 &&
+    instances.every((i: any) => i && typeof i === 'object' && typeof i.name === 'string')
+  ) {
+    effectiveSettings = { ...effectiveSettings, ...instances[0] };
+  }
+
   const method = (spec.method || 'GET').toUpperCase();
-  const url = buildUrl(spec, settings);
-  const headers = buildHeaders(spec, settings);
-  const { body, contentType } = buildBody(spec, settings);
+  let url = buildUrl(spec, effectiveSettings);
+  const headers = buildHeaders(spec, effectiveSettings);
+  const { body, contentType } = buildBody(spec, effectiveSettings);
   if (body != null && contentType && !headers.has('content-type')) {
     headers.set('content-type', contentType);
   }
+  // Apply connector-level auth so the test probe uses the same scheme
+  // as live tool calls (e.g. Basic auth for Jenkins). Manifests that
+  // hand-craft Authorization in test.request.headers still work — the
+  // auth scheme would just overwrite the header.
+  url = applyAuth(url, headers, def.auth, effectiveSettings);
 
   const timeoutMs = test.timeout_ms || DEFAULT_TIMEOUT_MS;
   const okStatus = test.ok_status?.length ? test.ok_status : [200];
@@ -255,6 +278,6 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
   const probe = def.test.probe || 'http';
   const r = probe === 'browser'
     ? await runBrowserProbe(def, inst.config)
-    : await runHttpProbe(def.test, inst.config);
+    : await runHttpProbe(def.test, inst.config, def);
   return NextResponse.json(r);
 }

package/app/api/memory/blocks/route.ts

@@ -0,0 +1,56 @@
+/**
+ * GET /api/memory/blocks?q=&limit=&scope=
+ *
+ * Lists memory blocks from the active backend (Temper or Local).
+ * Powers the Memory drawer in /chat — no editing, just inspection.
+ *
+ * Query params:
+ *   q       — optional search query; routed to store.search() so the
+ *             active backend's relevance ranking applies (Temper KG,
+ *             LocalMemoryStore LIKE). Omit to list everything.
+ *   limit   — cap on rows returned (default 200, max 500)
+ *   scope   — 'own' | 'global' | 'both' (default 'both'), forwarded
+ *             to listBlocks. Ignored when q is set.
+ */
+
+import { NextResponse } from 'next/server';
+import { getMemoryStore } from '@/lib/chat/memory-store';
+
+export async function GET(req: Request) {
+  const url = new URL(req.url);
+  const q = (url.searchParams.get('q') || '').trim();
+  const limit = Math.min(500, Math.max(1, Number(url.searchParams.get('limit') || 200)));
+  const scopeParam = url.searchParams.get('scope');
+  const scope: 'own' | 'global' | 'both' =
+    scopeParam === 'own' || scopeParam === 'global' || scopeParam === 'both' ? scopeParam : 'both';
+
+  const store = getMemoryStore();
+  if (!store.enabled) {
+    return NextResponse.json({ backend: store.kind, enabled: false, blocks: [], hits: [] });
+  }
+
+  if (q) {
+    // Search path — backend chooses ranking (Temper KG vs Local LIKE).
+    // listBlocks is also fetched so the UI can show "all blocks" once
+    // the user clears the query without a second roundtrip; capped.
+    const [hits, all] = await Promise.allSettled([
+      store.search(q, limit),
+      store.listBlocks({ scope }),
+    ]);
+    return NextResponse.json({
+      backend: store.kind,
+      enabled: true,
+      query: q,
+      hits: hits.status === 'fulfilled' ? hits.value : [],
+      blocks: all.status === 'fulfilled' ? all.value.slice(0, limit) : [],
+    });
+  }
+
+  const blocks = await store.listBlocks({ scope });
+  return NextResponse.json({
+    backend: store.kind,
+    enabled: true,
+    blocks: blocks.slice(0, limit),
+    hits: [],
+  });
+}

package/app/api/monitor/route.ts

@@ -24,6 +24,7 @@ export async function GET() {
   const workspace = countProcess('workspace-standalone');
   const chat = countProcess('chat-standalone');
   const browserBridge = countProcess('browser-bridge-standalone');
+  const memoryWorker = countProcess('memory-standalone');
   const tunnel = countProcess('cloudflared tunnel');
 
   // Chat backend health (port 8408 — process can be alive but crashed)
@@ -83,6 +84,7 @@ export async function GET() {
       telegram: { running: telegram.count > 0, pid: telegram.pid, startedAt: telegram.startedAt },
       workspace: { running: workspace.count > 0, pid: workspace.pid, startedAt: workspace.startedAt },
       browserBridge: { running: browserBridge.count > 0, pid: browserBridge.pid, startedAt: browserBridge.startedAt },
+      memory: { running: memoryWorker.count > 0, pid: memoryWorker.pid, startedAt: memoryWorker.startedAt },
       chat: {
         running: chatStatus.running,
         pid: chat.pid,

package/app/chat/page.tsx

@@ -50,6 +50,7 @@ export default function ChatPage() {
   const [streaming, setStreaming] = useState(false);
   const [partial, setPartial] = useState('');
   const [memory, setMemory] = useState<MemoryStatus | null>(null);
+  const [memoryOpen, setMemoryOpen] = useState(false);
   const [error, setError] = useState('');
 
   const eventSrcRef = useRef<EventSource | null>(null);
@@ -282,7 +283,11 @@ export default function ChatPage() {
         </div>
 
         <div className="px-4 py-3 border-t border-[var(--border)] text-xs text-[var(--text-secondary)] space-y-1">
-          <div className="flex items-center gap-2">
+          <button
+            type="button"
+            onClick={() => setMemoryOpen(true)}
+            className="flex items-center gap-2 w-full text-left hover:text-[var(--text-primary)] transition-colors"
+          >
             <span>Memory</span>
             <span
               className={`px-1.5 py-[1px] rounded text-[10px] uppercase tracking-wide border ${
@@ -295,7 +300,8 @@ export default function ChatPage() {
             >
               {memory?.backend ?? '…'}
             </span>
-          </div>
+            <span className="ml-auto text-[10px] opacity-60">view →</span>
+          </button>
           {memory && (
             <div className="text-[11px]">
               {memory.pinnedCount ?? 0} pinned · {memory.blocksCount ?? 0} blocks
@@ -307,6 +313,8 @@ export default function ChatPage() {
         </div>
       </aside>
 
+      {memoryOpen && <MemoryDrawer onClose={() => setMemoryOpen(false)} />}
+
       {/* ─── Main pane ───────────────────────────────────── */}
       <main className="flex-1 flex flex-col min-w-0">
         <header className="border-b border-[var(--border)] px-6 py-3 flex items-center justify-between">
@@ -529,3 +537,182 @@ function tryPrettyJson(s: string): string {
     return s;
   }
 }
+
+// ─── Memory drawer ───────────────────────────────────────────
+//
+// Inspector for whatever the active memory backend (Temper / Local)
+// has. Read-only: search + list + click-to-expand JSON. The internal
+// summarizer bookkeeping (cursor / health) is hidden by default to
+// reduce noise; toggle reveals it.
+
+const INTERNAL_PREFIXES = ['forge.summarizer.cursor:', 'forge.summarizer.health:'];
+
+interface MemoryBlockRow {
+  key: string;
+  value: unknown;
+  pinned?: boolean;
+  description?: string;
+  scope?: string;
+}
+
+interface MemoryHitRow {
+  id: string;
+  kind: string;
+  fact?: string;
+  score?: number;
+  valid_at?: string | null;
+}
+
+interface MemoryBlocksResponse {
+  backend: 'temper' | 'local';
+  enabled: boolean;
+  blocks: MemoryBlockRow[];
+  hits: MemoryHitRow[];
+  query?: string;
+}
+
+function MemoryDrawer({ onClose }: { onClose: () => void }) {
+  const [data, setData] = useState<MemoryBlocksResponse | null>(null);
+  const [loading, setLoading] = useState(false);
+  const [err, setErr] = useState('');
+  const [q, setQ] = useState('');
+  const [showInternal, setShowInternal] = useState(false);
+  const [expanded, setExpanded] = useState<Record<string, boolean>>({});
+
+  const fetchBlocks = useCallback(async (query: string) => {
+    setLoading(true);
+    setErr('');
+    try {
+      const url = query
+        ? `/api/memory/blocks?q=${encodeURIComponent(query)}&limit=300`
+        : `/api/memory/blocks?limit=300`;
+      const r = await fetch(url);
+      if (!r.ok) throw new Error(`${r.status}`);
+      const j = (await r.json()) as MemoryBlocksResponse;
+      setData(j);
+    } catch (e) {
+      setErr(e instanceof Error ? e.message : String(e));
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+
+  useEffect(() => { fetchBlocks(''); }, [fetchBlocks]);
+
+  // Debounce search input → API
+  useEffect(() => {
+    const t = setTimeout(() => fetchBlocks(q.trim()), 250);
+    return () => clearTimeout(t);
+  }, [q, fetchBlocks]);
+
+  const visibleBlocks = useMemo(() => {
+    const all = data?.blocks ?? [];
+    if (showInternal) return all;
+    return all.filter((b) => !INTERNAL_PREFIXES.some((p) => b.key.startsWith(p)));
+  }, [data, showInternal]);
+
+  const visibleHits = data?.hits ?? [];
+
+  return (
+    <div className="fixed inset-0 z-50 flex items-center justify-center bg-black/50" onClick={onClose}>
+      <div
+        className="bg-[var(--bg-secondary)] border border-[var(--border)] rounded-lg w-[720px] max-w-[95vw] max-h-[85vh] flex flex-col shadow-xl"
+        onClick={(e) => e.stopPropagation()}
+        style={{ fontFamily: SANS_FONT }}
+      >
+        <div className="px-4 py-3 border-b border-[var(--border)] flex items-center gap-3">
+          <h2 className="text-sm font-bold text-[var(--text-primary)]">Memory</h2>
+          {data && (
+            <span
+              className={`px-1.5 py-[1px] rounded text-[10px] uppercase tracking-wide border ${
+                data.backend === 'temper'
+                  ? 'border-green-500/60 text-green-400'
+                  : 'border-[var(--accent)] text-[var(--accent)]'
+              }`}
+            >
+              {data.backend}
+            </span>
+          )}
+          <input
+            value={q}
+            onChange={(e) => setQ(e.target.value)}
+            placeholder="search…"
+            className="flex-1 bg-[var(--bg-primary)] border border-[var(--border)] rounded px-2 py-1 text-xs text-[var(--text-primary)] focus:outline-none focus:border-[var(--accent)]"
+          />
+          <label className="flex items-center gap-1 text-[10px] text-[var(--text-secondary)]">
+            <input
+              type="checkbox"
+              checked={showInternal}
+              onChange={(e) => setShowInternal(e.target.checked)}
+              className="accent-[var(--accent)]"
+            />
+            show internal
+          </label>
+          <button onClick={onClose} className="text-xs text-[var(--text-secondary)] hover:text-[var(--text-primary)]">Close</button>
+        </div>
+
+        <div className="flex-1 overflow-y-auto">
+          {loading && <div className="px-4 py-6 text-xs text-[var(--text-secondary)]">Loading…</div>}
+          {err && <div className="px-4 py-6 text-xs text-red-400">Error: {err}</div>}
+
+          {visibleHits.length > 0 && (
+            <div className="px-4 py-2 border-b border-[var(--border)]">
+              <div className="text-[10px] uppercase tracking-wide text-[var(--text-secondary)] mb-1">
+                Search hits ({visibleHits.length})
+              </div>
+              <div className="space-y-1">
+                {visibleHits.slice(0, 20).map((h) => (
+                  <div key={h.id} className="text-[11px] text-[var(--text-primary)]">
+                    <span className="text-[var(--text-secondary)] font-mono mr-2">{h.id}</span>
+                    {h.fact || '(no fact)'}
+                  </div>
+                ))}
+              </div>
+            </div>
+          )}
+
+          <div className="px-2 py-1 text-[10px] uppercase tracking-wide text-[var(--text-secondary)] sticky top-0 bg-[var(--bg-secondary)]">
+            Blocks ({visibleBlocks.length}{data && data.blocks.length !== visibleBlocks.length ? ` of ${data.blocks.length}` : ''})
+          </div>
+          {visibleBlocks.length === 0 && !loading && (
+            <div className="px-4 py-6 text-xs text-[var(--text-secondary)] italic">No blocks{q ? ' match' : ''}.</div>
+          )}
+          {visibleBlocks.map((b) => {
+            const isOpen = !!expanded[b.key];
+            const valStr = typeof b.value === 'string' ? b.value : JSON.stringify(b.value);
+            const preview = valStr.length > 140 ? valStr.slice(0, 140) + '…' : valStr;
+            return (
+              <div key={b.key} className="border-b border-[var(--border)]">
+                <button
+                  type="button"
+                  onClick={() => setExpanded((s) => ({ ...s, [b.key]: !isOpen }))}
+                  className="w-full text-left px-3 py-2 hover:bg-[var(--bg-primary)] transition-colors"
+                >
+                  <div className="flex items-baseline gap-2">
+                    <span className="text-[11px] font-mono text-[var(--accent)] truncate flex-1">{b.key}</span>
+                    {b.pinned && <span className="text-[9px] text-yellow-400">📌</span>}
+                  </div>
+                  <div className="text-[11px] text-[var(--text-secondary)] mt-0.5 truncate">
+                    {preview}
+                  </div>
+                  {b.description && (
+                    <div className="text-[10px] text-gray-500 italic mt-0.5 truncate">{b.description}</div>
+                  )}
+                </button>
+                {isOpen && (
+                  <pre className="px-3 pb-3 text-[10px] font-mono whitespace-pre-wrap break-words text-[var(--text-secondary)]">
+                    {tryPrettyJson(valStr)}
+                  </pre>
+                )}
+              </div>
+            );
+          })}
+        </div>
+
+        <div className="px-4 py-2 border-t border-[var(--border)] text-[10px] text-[var(--text-secondary)]">
+          Read-only. Edit / delete via Settings → Memory (Temper UI for KG).
+        </div>
+      </div>
+    </div>
+  );
+}

package/bin/forge-server.mjs

@@ -349,7 +349,7 @@ function cleanupOrphans() {
     }
     // Kill standalone processes: our instance's + orphans without any tag
     try {
-      const out = execSync(`ps aux | grep -E 'telegram-standalone|terminal-standalone|workspace-standalone|browser-bridge-standalone|chat-standalone' | grep -v grep`, {
+      const out = execSync(`ps aux | grep -E 'telegram-standalone|terminal-standalone|workspace-standalone|browser-bridge-standalone|chat-standalone|memory-standalone' | grep -v grep`, {
         encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'],
       }).trim();
       for (const line of out.split('\n').filter(Boolean)) {
@@ -376,7 +376,7 @@ function cleanupOrphans() {
           cmd = execSync(`ps -p ${pid} -o command=`, { encoding: 'utf-8', timeout: 2000, stdio: ['pipe', 'pipe', 'pipe'] }).trim();
         } catch { continue; }
         // Skip legit holders: next-server + our standalones (handled above)
-        if (/next-server|next start|telegram-standalone|terminal-standalone|workspace-standalone|browser-bridge-standalone|chat-standalone/.test(cmd)) continue;
+        if (/next-server|next start|telegram-standalone|terminal-standalone|workspace-standalone|browser-bridge-standalone|chat-standalone|memory-standalone/.test(cmd)) continue;
         // Only kill tsx-loaded scripts (typical zombie debug runner shape)
         if (!/tsx/.test(cmd)) continue;
         console.log(`[forge] Killing zombie task-runner (pid=${pid}): ${cmd.slice(0, 120)}`);
@@ -425,6 +425,7 @@ function startServices(daemonize = false) {
   spawnService('Workspace daemon', join(ROOT, 'lib', 'workspace-standalone.ts'));
   spawnService('Browser bridge',  join(ROOT, 'lib', 'browser-bridge-standalone.ts'));
   spawnService('Chat',            join(ROOT, 'lib', 'chat-standalone.ts'));
+  spawnService('Memory worker',   join(ROOT, 'lib', 'memory-standalone.ts'));
 
   const childPids = services.map(c => c.pid).filter(Boolean);
   savePids(childPids);

package/components/ConnectorsPanel.tsx

@@ -44,6 +44,8 @@ interface FieldSchema {
   required?: boolean;
   default?: any;
   options?: string[];
+  /** For type: 'instances' — schema of each row's inner fields. */
+  fields?: Record<string, FieldSchema>;
 }
 
 interface ConnectorTool {
@@ -532,7 +534,13 @@ export default function ConnectorsPanel() {
                           <label className="text-[10px] text-[var(--text-secondary)] block mb-0.5">
                             {sc.label || key} {sc.required && <span className="text-red-400">*</span>}
                           </label>
-                          {sc.type === 'boolean' ? (
+                          {sc.type === 'instances' ? (
+                            <InstancesField
+                              schema={sc}
+                              rawValue={values[key]}
+                              onChange={(v) => setValues({ ...values, [key]: v })}
+                            />
+                          ) : sc.type === 'boolean' ? (
                             <input
                               type="checkbox"
                               checked={values[key] === true || values[key] === 'true'}
@@ -634,3 +642,135 @@ export default function ConnectorsPanel() {
     </div>
   );
 }
+
+/**
+ * Generic renderer for `type: instances` — a list of named records
+ * configured per-connector (Jenkins instances, GitLab tenants, etc.).
+ * Each row collapses into the connector's declared sub-fields. Value
+ * is round-tripped as a JSON-stringified array so the existing
+ * connector-configs.json shape (the textarea-saved string) keeps
+ * working unchanged.
+ */
+function InstancesField({
+  schema,
+  rawValue,
+  onChange,
+}: {
+  schema: FieldSchema;
+  rawValue: any;
+  onChange: (next: string) => void;
+}) {
+  const subFields = schema.fields || {};
+  const subKeys = Object.keys(subFields);
+
+  // Parse incoming value: accept stored JSON string, in-memory array,
+  // null, or anything malformed (treat as empty).
+  const rows: Record<string, any>[] = (() => {
+    let v: any = rawValue;
+    if (v == null || v === '') return [];
+    if (typeof v === 'string') {
+      try { v = JSON.parse(v); } catch { return []; }
+    }
+    return Array.isArray(v) ? v : [];
+  })();
+
+  const commit = (next: Record<string, any>[]) => onChange(JSON.stringify(next));
+
+  const addRow = () => {
+    const blank: Record<string, any> = {};
+    for (const k of subKeys) blank[k] = subFields[k]?.default ?? '';
+    commit([...rows, blank]);
+  };
+  const removeRow = (i: number) => commit(rows.filter((_, idx) => idx !== i));
+  const updateRow = (i: number, key: string, val: any) => {
+    const next = rows.map((r, idx) => (idx === i ? { ...r, [key]: val } : r));
+    commit(next);
+  };
+
+  return (
+    <div className="space-y-1.5">
+      {rows.length === 0 && (
+        <div className="text-[10px] text-[var(--text-secondary)] italic py-1">
+          No entries yet — click “+ Add” to create one.
+        </div>
+      )}
+      {rows.map((row, i) => {
+        const rowLabel =
+          (typeof row.name === 'string' && row.name.trim()) || `(unnamed #${i + 1})`;
+        return (
+          <div
+            key={i}
+            className="border border-[var(--border)] rounded p-2 bg-[var(--bg-secondary)]"
+          >
+            <div className="flex items-center justify-between mb-1.5">
+              <span className="text-[10px] font-semibold text-[var(--text-primary)]">
+                {rowLabel}
+              </span>
+              <button
+                type="button"
+                onClick={() => removeRow(i)}
+                title="Remove this entry"
+                className="text-[10px] text-red-400 hover:text-red-300"
+              >
+                ✕
+              </button>
+            </div>
+            <div className="space-y-1.5">
+              {subKeys.map((k) => {
+                const f = subFields[k];
+                // Nested instances — render the same component recursively.
+                // Lets a connector model "rows of rows" (e.g. Jenkins
+                // instances each with a list of inject_params key/value
+                // pairs).
+                if (f.type === 'instances') {
+                  return (
+                    <div key={k}>
+                      <label className="text-[9px] text-[var(--text-secondary)] block mb-0.5">
+                        {f.label || k} {f.required && <span className="text-red-400">*</span>}
+                      </label>
+                      <InstancesField
+                        schema={f}
+                        rawValue={row[k]}
+                        onChange={(next) => updateRow(i, k, next)}
+                      />
+                      {f.description && (
+                        <p className="text-[9px] text-[var(--text-secondary)] mt-0.5">{f.description}</p>
+                      )}
+                    </div>
+                  );
+                }
+                const inputType =
+                  f.type === 'secret' || f.type === 'password'
+                    ? 'password'
+                    : f.type === 'number'
+                      ? 'number'
+                      : 'text';
+                return (
+                  <div key={k}>
+                    <label className="text-[9px] text-[var(--text-secondary)] block mb-0.5">
+                      {f.label || k} {f.required && <span className="text-red-400">*</span>}
+                    </label>
+                    <input
+                      type={inputType}
+                      value={row[k] ?? ''}
+                      onChange={(e) => updateRow(i, k, e.target.value)}
+                      placeholder={f.description || ''}
+                      className="w-full bg-[var(--bg-tertiary)] border border-[var(--border)] rounded px-2 py-1 text-[10px] text-[var(--text-primary)] font-mono"
+                    />
+                  </div>
+                );
+              })}
+            </div>
+          </div>
+        );
+      })}
+      <button
+        type="button"
+        onClick={addRow}
+        className="text-[10px] px-2 py-1 rounded border border-dashed border-[var(--border)] text-[var(--text-secondary)] hover:border-[var(--accent)] hover:text-[var(--accent)] transition-colors w-full"
+      >
+        + Add {schema.label || 'instance'}
+      </button>
+    </div>
+  );
+}