@jhizzard/termdeck 0.12.0 → 0.14.0

package/packages/server/src/agent-adapters/grok-models.js

@@ -0,0 +1,115 @@
+// Grok model selection — Sprint 45 T3
+//
+// `grok-dev` (the superagent-ai CLI) ships an 11-model lineup spanning
+// $0.2/$0.5 cheap-fast tiers up to $3/$15 flagship. The wrong default
+// silently 10x's a bill on routine tasks: a "look at this file and tell me
+// what's wrong" lane on `grok-4.20-0309-reasoning` (Heavy, $2/$6) costs the
+// same as ten lanes on `grok-4-1-fast-non-reasoning`. The orchestrator picks
+// per-lane via `chooseModel(taskHint)` at boot-prompt construction time
+// (see SPRINT-45-PREP-NOTES.md § "Concern 2: Model selection heuristic").
+// The adapter's `spawn.env.GROK_MODEL` defaults to the cheap-fast model and
+// is overridden per-lane by the launcher.
+//
+// Tier table (price = USD per 1M tokens, in/out):
+//
+//   tier               | model id                          | price    | use case
+//   ───────────────────┼───────────────────────────────────┼──────────┼──────────────────────
+//   fast-non-reasoning | grok-4-1-fast-non-reasoning       | $0.2/0.5 | DEFAULT — routine
+//   fast-reasoning     | grok-4-1-fast-reasoning           | $0.2/0.5 | light CoT under budget
+//   code               | grok-code-fast-1                  | $0.2/1.5 | code gen / refactor
+//   reasoning-deep     | grok-4.20-0309-reasoning          | $2/6     | hard problems, audit
+//   reasoning-non-cot  | grok-4.20-0309-non-reasoning      | $2/6     | high-quality non-CoT
+//   multi-agent        | grok-4.20-multi-agent-0309        | $2/6     | parallel sub-agent fan-out
+//   flagship           | grok-4-0709                       | $3/15    | when Heavy isn't enough
+//   budget-compact     | grok-3-mini                       | $0.3/0.5 | rare — usually wrong
+//
+// `grok-4-fast-non-reasoning`, `grok-4-fast-reasoning`, and `grok-3` are
+// legacy aliases retained for completeness but not in the heuristic switch.
+
+'use strict';
+
+// Canonical model ids. Use the symbolic key in code; the heuristic resolves
+// to the live id below. Keep these as data, not constants — Sprint 46+ may
+// gain a `taskHint -> model` override file in `~/.termdeck/`.
+const MODELS = {
+  'fast-non-reasoning': 'grok-4-1-fast-non-reasoning',
+  'fast-reasoning': 'grok-4-1-fast-reasoning',
+  'code': 'grok-code-fast-1',
+  'reasoning-deep': 'grok-4.20-0309-reasoning',
+  'reasoning-non-cot': 'grok-4.20-0309-non-reasoning',
+  'multi-agent': 'grok-4.20-multi-agent-0309',
+  'flagship': 'grok-4-0709',
+  'budget-compact': 'grok-3-mini',
+};
+
+// Legacy aliases — accepted as input to chooseModel for back-compat with
+// Joshua's earlier `grok models` outputs. Resolution table:
+const LEGACY_ALIASES = {
+  'grok-4-fast-non-reasoning': MODELS['fast-non-reasoning'],
+  'grok-4-fast-reasoning': MODELS['fast-reasoning'],
+  'grok-beta': MODELS['reasoning-deep'],
+  'grok-4.20-multi-agent': MODELS['multi-agent'],
+  'grok-3': MODELS['flagship'],
+};
+
+// chooseModel — orchestrator-side heuristic. Pass `taskHint` from the lane
+// brief (Sprint 46 frontmatter `model-hint: code|reasoning-deep|...`) or omit
+// for the cheap-fast default. Unknown hints fall back to the default rather
+// than throwing — the bill consequence of a typo silently routing to Heavy
+// is worse than the latency hit of cheap-fast on a hard task.
+function chooseModel(taskHint) {
+  switch (taskHint) {
+    case 'code':
+      return MODELS.code;
+    case 'multi-agent':
+      return MODELS['multi-agent'];
+    case 'reasoning-deep':
+      return MODELS['reasoning-deep'];
+    case 'reasoning-quick':
+    case 'fast-reasoning':
+      return MODELS['fast-reasoning'];
+    case 'reasoning-non-cot':
+      return MODELS['reasoning-non-cot'];
+    case 'flagship':
+      return MODELS.flagship;
+    case 'budget-compact':
+      return MODELS['budget-compact'];
+    case 'fast-non-reasoning':
+    case undefined:
+    case null:
+    case '':
+      return MODELS['fast-non-reasoning'];
+    default:
+      // Accept legacy aliases verbatim; otherwise fall back to cheap-fast.
+      if (LEGACY_ALIASES[taskHint]) return LEGACY_ALIASES[taskHint];
+      return MODELS['fast-non-reasoning'];
+  }
+}
+
+// getModelInfo — for the launcher / dashboard cost annotations (Sprint 46).
+// Returns the price band so the UI can render a $-tier indicator alongside
+// the model name without each caller knowing the table.
+function getModelInfo(modelId) {
+  const cheap = new Set([
+    MODELS['fast-non-reasoning'],
+    MODELS['fast-reasoning'],
+    MODELS.code,
+  ]);
+  const heavy = new Set([
+    MODELS['reasoning-deep'],
+    MODELS['reasoning-non-cot'],
+    MODELS['multi-agent'],
+  ]);
+  if (cheap.has(modelId)) return { tier: 'cheap', priceIn: 0.2, priceOut: modelId === MODELS.code ? 1.5 : 0.5 };
+  if (heavy.has(modelId)) return { tier: 'heavy', priceIn: 2, priceOut: 6 };
+  if (modelId === MODELS.flagship) return { tier: 'flagship', priceIn: 3, priceOut: 15 };
+  if (modelId === MODELS['budget-compact']) return { tier: 'budget', priceIn: 0.3, priceOut: 0.5 };
+  return { tier: 'unknown', priceIn: null, priceOut: null };
+}
+
+module.exports = {
+  MODELS,
+  LEGACY_ALIASES,
+  chooseModel,
+  getModelInfo,
+};

package/packages/server/src/agent-adapters/grok.js

@@ -0,0 +1,253 @@
+// Grok adapter (superagent-ai grok-dev CLI) — Sprint 45 T3
+//
+// Implements the 7-field adapter contract documented in ./claude.js and
+// docs/AGENT-RUNTIMES.md § 5. TUI mode by default — conversation persists
+// inside the PTY process for the lifetime of the panel, matching the Claude
+// Code pattern. Headless `grok --prompt` is reserved for orchestrator
+// background tasks (Sprint 46+) and is NOT this adapter's spawn shape.
+//
+// Lane-time empirical findings (Sprint 45 T3, 2026-05-01) — see
+// docs/multi-agent-substrate/SPRINT-45-PREP-NOTES.md and Sprint 45 STATUS.md
+// for the full investigation:
+//
+//   • grok-dev v1.1.5, binary `/usr/local/bin/grok` (#!/usr/bin/env bun)
+//   • Session storage: SQLite at ~/.grok/grok.db, NOT JSON files in
+//     ~/.grok/sessions/. Tables (STRICT, requires SQLite ≥3.37):
+//       sessions(id, workspace_id, title, model, mode, status, created_at, ...)
+//       messages(session_id, seq, role, message_json, created_at)
+//       tool_calls, tool_results, usage_events, compactions
+//     `messages.message_json` is a JSON blob in AI SDK provider shape:
+//       { role: 'user'|'assistant'|'tool', content: string | Array<...> }
+//     where array parts are { type: 'text', text } | { type: 'tool-call', ... }
+//     | { type: 'tool-result', ... }. Sprint 45 T4 wires the memory hook to
+//     extract from grok.db and feed parseTranscript a JSON envelope.
+//
+//   • TUI shimmer text strings (the canonical "thinking" indicator):
+//       "Planning next moves"  — default isProcessing without stream content
+//       "Generating plan..."   — plan-mode label
+//       "Answering…"           — /btw overlay
+//   • Tool indicators: TUI renders `→ <label>` (InlineTool component);
+//     headless mode emits `▸ <label>`. Both forms accepted.
+//   • Sub-agents: 5 built-in (general / explore / vision / verify / computer)
+//     plus up to 12 user-defined customs on grok-4.20-multi-agent-0309
+//     (16-agent ceiling). Sub-agent fan-out is internal to grok-dev — the
+//     adapter doesn't need to surface per-sub-agent status; the parent CLI
+//     emits SubagentTaskLine entries that show through as inline tool calls.
+//   • Empty-state placeholder: "Message Grok…" — used only as a weak idle
+//     hint, not a load-bearing pattern.
+//
+// Cost band: 'subscription'. Joshua's SuperGrok Heavy carries the rate
+// limits; non-Heavy users supply GROK_API_KEY / XAI_API_KEY via secrets.env
+// (which the spawn inherits from process.env automatically — no need to
+// re-list it in spawn.env).
+
+'use strict';
+
+const { chooseModel } = require('./grok-models');
+
+// ──────────────────────────────────────────────────────────────────────────
+// Patterns — observed from grok-dev@1.1.5 source (dist/ui/app.js) plus
+// Joshua's smoke test on 2026-05-01. TUI is OpenTUI/React-rendered with
+// frequent redraws; patterns must survive ANSI strip and partial chunks.
+// Conservative bias: false negatives (missed status updates) are cheaper
+// than false positives (badge flapping or spurious 'errored' status).
+// ──────────────────────────────────────────────────────────────────────────
+
+// Prompt indicator — the TUI's empty-state placeholder. Weak signal but the
+// only stable string that appears reliably in TUI output. Sprint 46 T4 may
+// refine if a more precise marker is observed.
+const PROMPT = /Message Grok[….]/;
+
+// Thinking — Grok's three known "isProcessing" shimmer states. Hits any of
+// the literal labels. The trailing variants on "Generating" / "Answering"
+// cover both ASCII `...` and Unicode ellipsis.
+const THINKING = /Planning next moves|Generating plan[….]|Answering[….]/;
+
+// Tool — TUI inline-tool prefix `→ ` (in box layout) OR headless `▸ `
+// (yellow ANSI in dist/headless/output.js:23). Anchored on the leading
+// glyph + space to avoid mid-line `→` in prose markdown firing as a tool.
+// Also catches the activity strings emitted by long-running tools.
+const TOOL = /(?:^|\n)\s*[→▸]\s|Running command[….]|Starting process[….]/;
+
+// Editing — Grok's TUI prefixes file-mutation tool calls with `Edit` /
+// `Write` / `Read` / `Run` labels rendered through InlineTool. Match these
+// after the tool glyph; the toolLabel function uses these verbatim.
+const EDITING = /(?:^|\n)\s*[→▸]\s+(Edit|Write|Read|Run|Create|Update|Delete)\b/;
+const EDITING_DETAIL = /(?:^|\n)\s*[→▸]\s+((?:Edit|Write|Read|Run|Create|Update|Delete)\b[^\n]*)/;
+
+// Idle — empty-state shows the placeholder and the cwd footer line. Use the
+// placeholder only — cwd shape varies by terminal width and home expansion.
+const IDLE = /Message Grok[….]\s*$/m;
+
+// Error — line-anchored variant matching Claude's strategy. Grok's tool
+// output (grep, test logs, lsp diagnostics) routinely carries "Error" /
+// "error" mid-line in a way that should NOT flip the panel to errored. Only
+// fire on line-leading failure phrases — same conservative shape as Claude
+// uses, plus the Grok-specific BtwOverlay error fallback "Something went
+// wrong." literal (rendered in t.diffRemovedFg).
+const ERROR = /(?:^|\n)\s*(?:(?:error|Error|ERROR|exception|Exception|Traceback|fatal|Fatal|FATAL|panic|EACCES|ECONNREFUSED|ENOENT|command not found|cannot find module|failed with exit code|Permission denied|Something went wrong)\b)/m;
+
+// ──────────────────────────────────────────────────────────────────────────
+// statusFor — replaces the absent grok branch in session.js _updateStatus.
+// Order matches Claude's: thinking → editing → tool → idle. First match
+// wins. Returns null on no-match so the caller leaves status untouched
+// (preserves the "no fallthrough" semantics _updateStatus relies on).
+// ──────────────────────────────────────────────────────────────────────────
+
+function statusFor(data) {
+  if (typeof data !== 'string') return null;
+  if (THINKING.test(data)) {
+    return { status: 'thinking', statusDetail: 'Grok is reasoning...' };
+  }
+  if (EDITING.test(data)) {
+    const match = data.match(EDITING_DETAIL);
+    return {
+      status: 'editing',
+      statusDetail: match ? match[1].slice(0, 80) : 'Editing files',
+    };
+  }
+  if (TOOL.test(data)) {
+    return { status: 'active', statusDetail: 'Using tools' };
+  }
+  if (IDLE.test(data)) {
+    return { status: 'idle', statusDetail: 'Waiting for input' };
+  }
+  return null;
+}
+
+// ──────────────────────────────────────────────────────────────────────────
+// parseTranscript — Grok stores messages in SQLite (~/.grok/grok.db), not
+// in a JSONL file. The adapter contract is `(raw: string) => Memory[]`, so
+// the caller (the memory-session-end hook, refactored in Sprint 45 T4) is
+// responsible for extracting `messages.message_json` rows from grok.db and
+// passing them in as a JSON string envelope. Two accepted shapes:
+//
+//   1. JSON array of message objects (preferred):
+//        '[{"role":"user","content":"hi"},{"role":"assistant","content":[...]}]'
+//   2. JSONL — one message JSON per line (back-compat with hooks that
+//      replay grok.db rows verbatim):
+//        '{"role":"user","content":"hi"}\n{"role":"assistant","content":[...]}'
+//
+// Both fall through to the same per-message loop. message.content matches
+// the AI SDK provider shape: string OR array of { type: 'text', text } |
+// { type: 'tool-call', ... } | { type: 'tool-result', ... }. We extract the
+// text parts only — tool calls and results are surfaced via the `tool_calls`
+// and `tool_results` tables in grok.db, which the hook layer treats
+// separately if it wants tool-trace memories.
+// ──────────────────────────────────────────────────────────────────────────
+
+function _extractText(content) {
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    return content
+      .filter((c) => c && c.type === 'text' && typeof c.text === 'string')
+      .map((c) => c.text)
+      .join(' ');
+  }
+  return '';
+}
+
+function parseTranscript(raw) {
+  if (typeof raw !== 'string' || raw.length === 0) return [];
+
+  // Try JSON-array first — the preferred envelope.
+  let messages = null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (Array.isArray(parsed)) messages = parsed;
+  } catch (_) { /* fall through to JSONL */ }
+
+  // JSONL fallback — line-by-line parse, skip malformed lines (matches
+  // Claude adapter's tolerance).
+  if (!messages) {
+    messages = [];
+    for (const line of raw.split('\n')) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        const obj = JSON.parse(trimmed);
+        if (obj && typeof obj === 'object') messages.push(obj);
+      } catch (_) { continue; }
+    }
+  }
+
+  const out = [];
+  for (const msg of messages) {
+    if (!msg || typeof msg !== 'object') continue;
+    const role = msg.role;
+    if (role !== 'user' && role !== 'assistant') continue;
+    const text = _extractText(msg.content);
+    if (text) out.push({ role, content: text.slice(0, 400) });
+  }
+  return out;
+}
+
+// ──────────────────────────────────────────────────────────────────────────
+// bootPromptTemplate — Grok reads `AGENTS.md` (per docs/AGENT-RUNTIMES.md
+// § 4: convergent file with Codex via the sync-agent-instructions.js
+// generator). The boot block points the lane at AGENTS.md instead of
+// CLAUDE.md and uses the same `memory_recall + read instructional file +
+// read sprint docs` shape as Claude. Sprint 46 T2 will refine per-agent
+// boot prompts further; this is the contract-complete placeholder.
+// ──────────────────────────────────────────────────────────────────────────
+
+function bootPromptTemplate(lane = {}, sprint = {}) {
+  const tn = lane.id || 'T?';
+  const sprintNum = sprint.number || '?';
+  const sprintName = sprint.name || 'unnamed';
+  const project = lane.project || sprint.project || 'termdeck';
+  const briefing = lane.briefingPath || `docs/sprint-${sprintNum}-${sprintName}/${tn}-<lane>.md`;
+  const topic = lane.topic || lane.briefingPath || sprintName;
+  return [
+    `You are ${tn} in Sprint ${sprintNum} (${sprintName}). Boot sequence:`,
+    `1. memory_recall(project="${project}", query="${topic}")`,
+    `2. memory_recall(query="recent decisions and bugs")`,
+    `3. Read ~/.claude/CLAUDE.md and ./AGENTS.md`,
+    `4. Read docs/sprint-${sprintNum}-${sprintName}/PLANNING.md`,
+    `5. Read docs/sprint-${sprintNum}-${sprintName}/STATUS.md`,
+    `6. Read ${briefing}`,
+    '',
+    'Then begin. Stay in your lane. Post FINDING / FIX-PROPOSED / DONE in STATUS.md.',
+    "Don't bump versions, don't touch CHANGELOG, don't commit.",
+  ].join('\n');
+}
+
+// ──────────────────────────────────────────────────────────────────────────
+// Adapter export. spawn.env.GROK_MODEL defaults to the cheap-fast tier;
+// per-lane override is the launcher's job at session-spawn time (Sprint 46
+// reads `agent: grok` + optional `model-hint: code|reasoning-deep|...` from
+// the lane brief frontmatter and overlays). GROK_API_KEY isn't repeated in
+// spawn.env because the PTY inherits it from the TermDeck server's process
+// env; the secrets.env load at server boot is the canonical path.
+// ──────────────────────────────────────────────────────────────────────────
+
+const grokAdapter = {
+  name: 'grok',
+  sessionType: 'grok',
+  matches: (cmd) => typeof cmd === 'string' && /(?:^|\s|\/)grok(?:\b|$)/i.test(cmd),
+  spawn: {
+    binary: 'grok',
+    defaultArgs: [],
+    env: {
+      GROK_MODEL: chooseModel(),
+    },
+  },
+  patterns: {
+    prompt: PROMPT,
+    thinking: THINKING,
+    editing: EDITING,
+    tool: TOOL,
+    idle: IDLE,
+    error: ERROR,
+  },
+  patternNames: {
+    error: 'grok-error',
+    tool: 'grok-tool',
+  },
+  statusFor,
+  parseTranscript,
+  bootPromptTemplate,
+  costBand: 'subscription',
+};
+
+module.exports = grokAdapter;

package/packages/server/src/agent-adapters/index.js

@@ -0,0 +1,61 @@
+// Agent adapter registry — Sprint 44 T3
+//
+// Single source of truth for per-agent terminal behavior. Each adapter
+// implements the contract documented in ./claude.js (and the memorialization
+// doc § 4) — type detection, status patterns, transcript parsing, boot prompt
+// templating, cost band. session.js consults this registry when analyzing
+// PTY output so adding a new agent (Codex / Gemini / Grok in Sprint 45) is a
+// new file in this directory + one entry in `AGENT_ADAPTERS` below — no
+// switch statements to extend.
+//
+// Sprint 44 lands the Claude adapter only. The other agents stay on the
+// in-file shim path in session.js until Sprint 45 T1-T3 ship their adapters
+// and Sprint 45 T4 wires the launcher UI through the same registry.
+
+const claude = require('./claude');
+const codex = require('./codex');
+const gemini = require('./gemini');
+const grok = require('./grok');
+
+// Keyed by adapter name (NOT session.meta.type — adapters expose their own
+// `sessionType` field for that mapping). Order is iteration order for the
+// detect loop in session.js, so list more-specific adapters before less.
+const AGENT_ADAPTERS = {
+  claude,
+  codex,
+  gemini,
+  grok,
+};
+
+// Convenience accessor — returns the adapter whose `sessionType` matches the
+// session.meta.type value, or undefined if no adapter has claimed that type.
+// session.js calls this in the hot path; keep it cheap.
+function getAdapterForSessionType(type) {
+  if (!type) return undefined;
+  for (const adapter of Object.values(AGENT_ADAPTERS)) {
+    if (adapter.sessionType === type) return adapter;
+  }
+  return undefined;
+}
+
+// Convenience accessor — first adapter whose prompt regex matches `data` or
+// whose `matches(command)` returns true. Returns undefined if no adapter
+// claims the session, leaving the caller to fall back to legacy detection
+// (gemini / python-server / shell). session.js calls this from `_detectType`.
+function detectAdapter(data, command) {
+  for (const adapter of Object.values(AGENT_ADAPTERS)) {
+    const promptHit = adapter.patterns
+      && adapter.patterns.prompt
+      && typeof data === 'string'
+      && adapter.patterns.prompt.test(data);
+    const cmdHit = typeof adapter.matches === 'function' && adapter.matches(command);
+    if (promptHit || cmdHit) return adapter;
+  }
+  return undefined;
+}
+
+module.exports = {
+  AGENT_ADAPTERS,
+  getAdapterForSessionType,
+  detectAdapter,
+};

package/packages/server/src/index.js

@@ -8,7 +8,9 @@ const { WebSocketServer } = require('ws');
 const path = require('path');
 const os = require('os');
 const fs = require('fs');
+const dns = require('dns');
 const { v4: uuidv4 } = require('uuid');
+const { createCachedLookup, createFailureLogger } = require('./rumen-pool-resilience');
 
 // Conditional imports (graceful fallback if not installed yet)
 let pty, Database, pg;
@@ -19,10 +21,18 @@ try { pg = require('pg'); } catch { pg = null; }
 // Module-level singleton Postgres pool for rumen_insights (petvetbid DB).
 // Lazy-initialized on first rumen endpoint hit so startup stays fast and
 // servers without DATABASE_URL never pay the connection cost.
+//
+// DNS-resilience (Sprint 45 side-task): the pool is constructed with a
+// cached `lookup` function that retries DNS failures with jittered
+// exponential backoff and serves stale entries during transient outages.
+// Pool errors / recoveries flow through a recency-graded logger so a
+// flapping host doesn't flood the log.
 let _rumenPool = null;
 let _rumenPoolFailed = false;
 let _rumenPoolFailedAt = 0;
 const RUMEN_POOL_RETRY_MS = 30_000;
+const _rumenLookup = createCachedLookup(dns);
+const _rumenLogger = createFailureLogger(console);
 const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 function getRumenPool() {
   if (_rumenPool) return _rumenPool;
@@ -38,14 +48,14 @@ function getRumenPool() {
       connectionString: process.env.DATABASE_URL,
       max: 4,
       idleTimeoutMillis: 30000,
-      connectionTimeoutMillis: 5000
-    });
-    _rumenPool.on('error', (err) => {
-      console.warn('[rumen] pg pool error:', err.message);
+      connectionTimeoutMillis: 5000,
+      lookup: _rumenLookup,
     });
+    _rumenPool.on('error', (err) => _rumenLogger.logFailure(`pg pool error: ${err.message}`));
+    _rumenPool.on('connect', () => _rumenLogger.logRecovery());
     return _rumenPool;
   } catch (err) {
-    console.warn('[rumen] failed to create pg pool:', err.message);
+    _rumenLogger.logFailure(`failed to create pg pool: ${err.message}`);
     _rumenPoolFailed = true;
     _rumenPoolFailedAt = Date.now();
     return null;
@@ -69,6 +79,7 @@ const { createGraphRoutes } = require('./graph-routes');
 const { createProjectsRoutes } = require('./projects-routes');
 const orchestrationPreview = require('./orchestration-preview');
 const { createPtyReaper } = require('./pty-reaper');
+const { AGENT_ADAPTERS } = require('./agent-adapters');
 
 // Sprint 37 T3 — lazy resolution of T2's CLI modules. The orchestration-preview
 // helper is decoupled from T2's templates.js / init-project.js; we resolve
@@ -1244,6 +1255,28 @@ function createServer(config) {
     res.json(t);
   });
 
+  // GET /api/agent-adapters - serializable projection of the multi-agent
+  // registry for the launcher. Sprint 45 T4: replaces the hardcoded
+  // claude/cc/gemini/python branches in app.js with a registry-driven
+  // detector. Each entry exposes only the fields the client needs:
+  //   • name        — adapter id ("claude", "codex", "gemini", "grok")
+  //   • sessionType — meta.type the launcher should set
+  //   • binary      — canonical command name; client matches `^binary\b` (i)
+  //   • costBand    — 'free' | 'pay-per-token' | 'subscription' (Sprint 46
+  //                   surfaces this in PLANNING.md cost annotations)
+  // Functions / RegExps are NOT serialized — match logic lives client-side
+  // and uses the binary as the prefix anchor. Adapter-specific shorthand
+  // (e.g. `cc` → `claude`) is normalized in app.js before this lookup.
+  app.get('/api/agent-adapters', (req, res) => {
+    const list = Object.values(AGENT_ADAPTERS).map((a) => ({
+      name: a.name,
+      sessionType: a.sessionType,
+      binary: a.spawn && a.spawn.binary,
+      costBand: a.costBand,
+    }));
+    res.json(list);
+  });
+
   // Public-shape helper so GET and PATCH return the same envelope.
   function publicConfigPayload() {
     return {
@@ -1650,10 +1683,16 @@ function createServer(config) {
     if (!pool) return res.json({ enabled: false });
 
     try {
+      // Sprint 45 side-task 2 — order by COALESCE(started_at, completed_at) so
+      // jobs whose upstream writer (the @jhizzard/rumen createJob INSERT in the
+      // Edge Function) leaves started_at NULL still surface as "latest" via
+      // their populated completed_at. Pre-fix the query returned a 2026-04-16
+      // job permanently because that was the last row to have started_at
+      // populated — every subsequent insert lands started_at = NULL.
       const jobSql =
         `SELECT id, status, completed_at, sessions_processed, insights_generated
            FROM rumen_jobs
-           ORDER BY started_at DESC
+           ORDER BY COALESCE(started_at, completed_at) DESC NULLS LAST
            LIMIT 1`;
       const insightSql =
         `SELECT

package/packages/server/src/rumen-pool-resilience.js

@@ -0,0 +1,111 @@
+// Sprint 45 side-task — DNS-resilience policy for the rumen pg.Pool.
+//
+// Two factories, both DI-friendly so tests can stub dns + console:
+//
+//   createCachedLookup(dnsModule, opts)
+//     Returns a (hostname, options, callback) function suitable for
+//     pg.Pool's `lookup` config. Caches successful lookups for
+//     `cacheTtlMs` (default 30s). On lookup failure, retries with
+//     jittered exponential backoff up to `backoffCapsMs.length`
+//     attempts (default [100, 500, 2000, 5000]). If every retry fails
+//     and a stale cached address exists, serves stale rather than
+//     failing — DNS flickers shouldn't tear the pool down.
+//
+//   createFailureLogger(consoleModule, opts)
+//     Returns { logFailure, logRecovery } closures owning a private
+//     failure-window state. First failure logs `warn`; consecutive
+//     failures within `windowMs` (default 60s) downgrade to `debug`;
+//     a recovery after any prior failure logs `info` once and clears
+//     the window. Idempotent recovery (no failures pending) is silent.
+//
+// Both factories are pure — no module-scope state, no side effects on
+// require — so tests can construct fresh instances per case.
+
+'use strict';
+
+const DEFAULT_BACKOFF_CAPS_MS = [100, 500, 2000, 5000];
+const DEFAULT_DNS_CACHE_TTL_MS = 30_000;
+const DEFAULT_FAILURE_WINDOW_MS = 60_000;
+
+function _jitter(capMs, rng) {
+  return Math.floor(capMs * (0.5 + rng() * 0.5));
+}
+
+function createCachedLookup(dnsModule, opts = {}) {
+  const cacheTtlMs = opts.cacheTtlMs ?? DEFAULT_DNS_CACHE_TTL_MS;
+  const backoffCapsMs = opts.backoffCapsMs ?? DEFAULT_BACKOFF_CAPS_MS;
+  const setTimeoutFn = opts.setTimeout ?? setTimeout;
+  const now = opts.now ?? Date.now;
+  const rng = opts.random ?? Math.random;
+  const cache = new Map();
+
+  return function cachedLookup(hostname, options, callback) {
+    if (typeof options === 'function') { callback = options; options = {}; }
+    const t = now();
+    const hit = cache.get(hostname);
+    if (hit && hit.expiresAt > t) {
+      return callback(null, hit.address, hit.family);
+    }
+    let attempt = 0;
+    const tryOnce = () => {
+      dnsModule.lookup(hostname, options, (err, address, family) => {
+        if (!err) {
+          cache.set(hostname, { address, family, expiresAt: now() + cacheTtlMs });
+          return callback(null, address, family);
+        }
+        if (attempt >= backoffCapsMs.length) {
+          if (hit) return callback(null, hit.address, hit.family);
+          return callback(err);
+        }
+        const delay = _jitter(backoffCapsMs[attempt++], rng);
+        setTimeoutFn(tryOnce, delay);
+      });
+    };
+    tryOnce();
+  };
+}
+
+function createFailureLogger(consoleModule, opts = {}) {
+  const windowMs = opts.windowMs ?? DEFAULT_FAILURE_WINDOW_MS;
+  const prefix = opts.prefix ?? '[rumen]';
+  const now = opts.now ?? Date.now;
+  let firstAt = 0;
+  let lastAt = 0;
+  let count = 0;
+
+  function logFailure(message) {
+    const t = now();
+    if (firstAt > 0 && (t - lastAt) < windowMs) {
+      count += 1;
+      lastAt = t;
+      const debug = consoleModule.debug || consoleModule.log;
+      debug(`${prefix} (debounced ${count}) ${message}`);
+      return;
+    }
+    firstAt = t;
+    lastAt = t;
+    count = 1;
+    consoleModule.warn(`${prefix} ${message}`);
+  }
+
+  function logRecovery(message) {
+    if (firstAt === 0) return;
+    const info = consoleModule.info || consoleModule.log;
+    info(`${prefix} recovered after ${count} failure(s)${message ? ` — ${message}` : ''}`);
+    firstAt = 0;
+    lastAt = 0;
+    count = 0;
+  }
+
+  function _state() { return { firstAt, lastAt, count }; }
+
+  return { logFailure, logRecovery, _state };
+}
+
+module.exports = {
+  createCachedLookup,
+  createFailureLogger,
+  DEFAULT_BACKOFF_CAPS_MS,
+  DEFAULT_DNS_CACHE_TTL_MS,
+  DEFAULT_FAILURE_WINDOW_MS,
+};