@jhizzard/termdeck 0.4.0 → 0.4.2

package/README.md

@@ -18,6 +18,8 @@ Ninety seconds, one command. Node 18+ is all you need — prebuilt binaries mean
 
 This is **Tier 1**. Works immediately, fully local, no accounts, no credentials, no database. You get the full dashboard — 7 grid layouts, 8 themes, per-panel metadata overlays, terminal switcher, reply button, status logs, session history in local SQLite. **Flashback is silent at this tier** because there's no memory store to query.
 
+First-time user? The **config** button in the toolbar shows what's set up and what's next — click it for a live view of each tier's status with guided next steps.
+
 Enabling Flashback takes **one additional 15-minute setup step** — see Tier 2 below. The rest of this README explains what you get, how it works, and how to go deeper.
 
 ---
@@ -137,7 +139,7 @@ Restart Claude Code. Six MCP tools appear: `memory_remember`, `memory_recall`, `
 
 ### Tier 3 — Add Rumen for async learning
 
-Rumen is a separate npm package — `@jhizzard/rumen@0.4.0` — that ships as a Supabase Edge Function designed to run on a 15-minute `pg_cron` schedule. It's the async reflection layer over Mnestra: it reads recent session memories, cross-references them with your entire historical corpus via hybrid search, synthesizes insights via Claude Haiku, and writes the results back into `rumen_insights` (a new table alongside Mnestra's `memory_items`). TermDeck's Flashback and Claude Code's `memory_recall` both automatically benefit because insights flow back into the same database.
+Rumen is a separate npm package — `@jhizzard/rumen@0.4.2` — that ships as a Supabase Edge Function designed to run on a 15-minute `pg_cron` schedule. It's the async reflection layer over Mnestra: it reads recent session memories, cross-references them with your entire historical corpus via hybrid search, synthesizes insights via Claude Haiku, and writes the results back into `rumen_insights` (a new table alongside Mnestra's `memory_items`). TermDeck's Flashback and Claude Code's `memory_recall` both automatically benefit because insights flow back into the same database.
 
 **Rumen is live.** First full-kickstart run against a production Mnestra store on 2026-04-15 19:47 UTC: **111 sessions processed, 111 insights generated** in one pass. Insights surfaced patterns like "the error detection regex in Flashback misses `No such file or directory` — same class of blind spot as X" and "Practice sessions exist as a separate model but frontend components were built and never wired into the schedule view." The cognitive loop is closed.
 
@@ -161,7 +163,7 @@ Honest limits, stated upfront so the skeptic has nothing to chase:
 - **Not a replacement for reading docs.** It's the shortest path to a memory you already wrote. If the memory isn't there, the feature does nothing.
 - **Not fully local by default.** Tier 2+ reaches out to Supabase for storage and OpenAI for embeddings. Tier 1 is fully local. A fully-local Tier 2 (local Postgres + local embeddings) is on the roadmap.
 - **Not free forever.** Tier 2+ pays OpenAI fractions of a cent per memory for embeddings. Self-hosted embeddings via Ollama are on the roadmap.
-- **Not proven at scale.** v0.4.0, validated against 3,527 memories in one developer's production store. First full Rumen kickstart on 2026-04-15 processed 111 sessions into 111 insights in one pass. No multi-user data yet. Bug reports and issues welcome.
+- **Not proven at scale.** v0.4.2, validated against 3,527 memories in one developer's production store. First full Rumen kickstart on 2026-04-15 processed 111 sessions into 111 insights in one pass. No multi-user data yet. Bug reports and issues welcome.
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jhizzard/termdeck",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "Browser-based terminal multiplexer with metadata overlays, panel flashback memory recall, and AI-aware session management",
   "bin": {
     "termdeck": "./packages/cli/src/index.js"

package/packages/cli/src/forge.js

@@ -0,0 +1,262 @@
+#!/usr/bin/env node
+
+// `termdeck forge` — Tier 5 SkillForge: autonomous skill generation from
+// Mnestra memories. This file is the CLI surface only; the Opus prompt
+// template (T2) and skill installer (T3) land in packages/server/src/.
+//
+// Sprint 20 scope (T1):
+//   1. Parse flags (--dry-run, --yes, --max-cost, --min-confidence)
+//   2. Connect to Mnestra /healthz and read the memory count
+//   3. Project cost based on memory count × avg tokens × Opus pricing
+//   4. Prompt for confirmation (skip with --yes or --dry-run)
+//
+// Steps 5–7 (Opus call, skill parsing, install) print a "Coming in v0.5"
+// stub so the command exits cleanly for anyone who tries it early.
+
+const http = require('http');
+const path = require('path');
+
+// Opus pricing (per million tokens) — keep in sync with
+// https://www.anthropic.com/pricing when it changes.
+const OPUS_PRICE_INPUT_PER_M = 15;
+const OPUS_PRICE_OUTPUT_PER_M = 75;
+// Each memory expands to ~200 input tokens once formatted into the forge
+// prompt. Output is roughly 20% of input (skills are compact markdown).
+const AVG_TOKENS_PER_MEMORY = 200;
+const OUTPUT_TO_INPUT_RATIO = 0.2;
+
+const HELP = [
+  '',
+  'TermDeck SkillForge (experimental)',
+  '',
+  'Usage: termdeck forge [flags]',
+  '',
+  'Flags:',
+  '  --help            Print this message and exit',
+  '  --dry-run         Show the cost projection and exit without prompting',
+  '  --yes             Skip the confirmation prompt (implies you accept the cost)',
+  '  --max-cost <usd>  Abort if projected cost exceeds this dollar amount',
+  '  --min-confidence  Minimum confidence score (0.0–1.0) for generated skills',
+  '',
+  'What this does (Sprint 20 preview):',
+  '  1. Reads memory count from Mnestra',
+  '  2. Projects the Opus cost for generating skills from those memories',
+  '  3. Asks for confirmation',
+  '  4. (v0.5) Calls Opus, parses skills, installs to ~/.claude/skills/',
+  ''
+].join('\n');
+
+function parseFlags(argv) {
+  const out = {
+    help: false,
+    dryRun: false,
+    yes: false,
+    maxCost: null,
+    minConfidence: null
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--help' || a === '-h') {
+      out.help = true;
+    } else if (a === '--dry-run') {
+      out.dryRun = true;
+    } else if (a === '--yes' || a === '-y') {
+      out.yes = true;
+    } else if (a === '--max-cost' && argv[i + 1]) {
+      const n = Number(argv[i + 1]);
+      if (!Number.isFinite(n) || n < 0) {
+        throw new Error(`--max-cost must be a non-negative number, got: ${argv[i + 1]}`);
+      }
+      out.maxCost = n;
+      i++;
+    } else if (a === '--min-confidence' && argv[i + 1]) {
+      const n = Number(argv[i + 1]);
+      if (!Number.isFinite(n) || n < 0 || n > 1) {
+        throw new Error(`--min-confidence must be between 0 and 1, got: ${argv[i + 1]}`);
+      }
+      out.minConfidence = n;
+      i++;
+    }
+  }
+  return out;
+}
+
+function httpGet(url, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const req = http.get(url, { timeout: timeoutMs }, (res) => {
+      if (res.statusCode !== 200) {
+        res.resume();
+        reject(new Error(`HTTP ${res.statusCode}`));
+        return;
+      }
+      let body = '';
+      res.setEncoding('utf8');
+      res.on('data', (chunk) => { body += chunk; });
+      res.on('end', () => resolve(body));
+    });
+    req.on('error', reject);
+    req.on('timeout', () => { req.destroy(); reject(new Error('timeout')); });
+  });
+}
+
+// Mnestra's /healthz returns one of several shapes depending on version; we
+// probe all the documented keys and return the first numeric match. The same
+// extraction logic lives in preflight.js — keep them in sync if the response
+// format changes.
+function extractMemoryCount(data) {
+  if (!data || typeof data !== 'object') return null;
+  const candidates = [
+    data.store && data.store.rows,
+    data.total,
+    data.memories,
+    data.count
+  ];
+  for (const c of candidates) {
+    if (c == null) continue;
+    const n = Number(c);
+    if (Number.isFinite(n)) return n;
+  }
+  return null;
+}
+
+async function fetchMemoryCount(config) {
+  const rag = (config && config.rag) || {};
+  const baseUrl = rag.mnestraWebhookUrl
+    ? rag.mnestraWebhookUrl.replace(/\/mnestra\/?$/, '')
+    : 'http://localhost:37778';
+  const url = `${baseUrl}/healthz`;
+  const body = await httpGet(url, 3000);
+  let data;
+  try { data = JSON.parse(body); } catch (err) {
+    throw new Error(`Mnestra /healthz returned non-JSON: ${err.message}`);
+  }
+  const count = extractMemoryCount(data);
+  if (count == null) {
+    throw new Error(`Mnestra reachable at ${url} but no memory count in response`);
+  }
+  return { count, url };
+}
+
+function projectCost(memoryCount) {
+  const inputTokens = memoryCount * AVG_TOKENS_PER_MEMORY;
+  const outputTokens = Math.round(inputTokens * OUTPUT_TO_INPUT_RATIO);
+  const inputCost = (inputTokens / 1_000_000) * OPUS_PRICE_INPUT_PER_M;
+  const outputCost = (outputTokens / 1_000_000) * OPUS_PRICE_OUTPUT_PER_M;
+  return {
+    inputTokens,
+    outputTokens,
+    totalTokens: inputTokens + outputTokens,
+    inputCost,
+    outputCost,
+    totalCost: inputCost + outputCost
+  };
+}
+
+function formatUSD(n) {
+  return `$${n.toFixed(2)}`;
+}
+
+function formatTokens(n) {
+  return Number(n).toLocaleString();
+}
+
+function printProjection(count, mnestraUrl, cost, flags) {
+  const dim = '\x1b[2m';
+  const bold = '\x1b[1m';
+  const reset = '\x1b[0m';
+  process.stdout.write('\n');
+  process.stdout.write(`  ${bold}TermDeck SkillForge (experimental)${reset}\n`);
+  process.stdout.write(`  ${dim}Mnestra: ${mnestraUrl}${reset}\n\n`);
+  process.stdout.write(`  Memories to analyze:  ${bold}${formatTokens(count)}${reset}\n`);
+  process.stdout.write(`  Estimated input:      ${formatTokens(cost.inputTokens)} tokens  (${formatUSD(cost.inputCost)})\n`);
+  process.stdout.write(`  Estimated output:     ${formatTokens(cost.outputTokens)} tokens  (${formatUSD(cost.outputCost)})\n`);
+  process.stdout.write(`  ${bold}Estimated total:      ${formatUSD(cost.totalCost)}${reset}\n`);
+  if (flags.minConfidence != null) {
+    process.stdout.write(`  ${dim}Min confidence:       ${flags.minConfidence}${reset}\n`);
+  }
+  if (flags.maxCost != null) {
+    process.stdout.write(`  ${dim}Max cost cap:         ${formatUSD(flags.maxCost)}${reset}\n`);
+  }
+  process.stdout.write('\n');
+}
+
+async function askYesNo(question) {
+  // Lazy-require to avoid pulling readline until we actually prompt. Mirrors
+  // the pattern used by init-mnestra.js.
+  const setupDir = path.join(__dirname, '..', '..', 'server', 'src', 'setup');
+  const { prompts } = require(setupDir);
+  try {
+    return await prompts.confirm(question, { defaultYes: false });
+  } finally {
+    prompts.closeRl();
+  }
+}
+
+async function forge(argv) {
+  let flags;
+  try {
+    flags = parseFlags(argv || []);
+  } catch (err) {
+    process.stderr.write(`[forge] ${err.message}\n`);
+    return 1;
+  }
+
+  if (flags.help) {
+    process.stdout.write(HELP);
+    return 0;
+  }
+
+  // Load config lazily — loading it triggers the "[config] Loaded from …"
+  // banner, which we only want when the command is actually running.
+  const { loadConfig } = require(path.join(__dirname, '..', '..', 'server', 'src', 'config.js'));
+  const config = loadConfig();
+
+  let memoryInfo;
+  try {
+    memoryInfo = await fetchMemoryCount(config);
+  } catch (err) {
+    process.stderr.write(`[forge] Could not reach Mnestra: ${err.message}\n`);
+    process.stderr.write(`[forge] Start Mnestra with \`mnestra serve\` and retry.\n`);
+    return 1;
+  }
+
+  if (memoryInfo.count === 0) {
+    process.stderr.write(`[forge] Mnestra has 0 memories — run \`mnestra ingest\` before forging skills.\n`);
+    return 1;
+  }
+
+  const cost = projectCost(memoryInfo.count);
+  printProjection(memoryInfo.count, memoryInfo.url, cost, flags);
+
+  if (flags.maxCost != null && cost.totalCost > flags.maxCost) {
+    process.stderr.write(`[forge] Projected cost ${formatUSD(cost.totalCost)} exceeds --max-cost ${formatUSD(flags.maxCost)}. Aborting.\n`);
+    return 2;
+  }
+
+  if (flags.dryRun) {
+    process.stdout.write('[forge] --dry-run: stopping before Opus call.\n');
+    return 0;
+  }
+
+  if (!flags.yes) {
+    const ok = await askYesNo(`  Proceed and spend ~${formatUSD(cost.totalCost)} on Opus?`);
+    if (!ok) {
+      process.stdout.write('[forge] Aborted by user.\n');
+      return 0;
+    }
+  }
+
+  // Steps 4–7 are deliberately stubbed for Sprint 20 — the Opus call, skill
+  // parsing, and installer land in Sprint 21 (T2 + T3 ship the building
+  // blocks).
+  process.stdout.write('\n');
+  process.stdout.write('[forge] Skill generation coming in v0.5.\n');
+  process.stdout.write('[forge]   - Opus call:        wired in Sprint 21 (T2 forge-prompt.js)\n');
+  process.stdout.write('[forge]   - Skill installer:  wired in Sprint 21 (T3 skill-installer.js)\n');
+  return 0;
+}
+
+module.exports = forge;
+module.exports.parseFlags = parseFlags;
+module.exports.projectCost = projectCost;
+module.exports.extractMemoryCount = extractMemoryCount;

package/packages/cli/src/index.js

@@ -12,6 +12,8 @@
 // `--mnestra` / `init-mnestra.js` together.
 
 const path = require('path');
+const fs = require('fs');
+const os = require('os');
 const { execSync } = require('child_process');
 
 // Parse CLI args
@@ -48,6 +50,18 @@ if (args[0] === 'init') {
   process.exit(1);
 }
 
+// `termdeck forge` — Sprint 20 SkillForge preview. Autonomously generates
+// Claude Code skills from Mnestra memories. Lazy-loaded so the launcher
+// startup path stays unaffected.
+if (args[0] === 'forge') {
+  const forge = require(path.join(__dirname, 'forge.js'));
+  forge(args.slice(1)).then((code) => process.exit(code || 0)).catch((err) => {
+    console.error('[cli] forge failed:', err && err.stack || err);
+    process.exit(1);
+  });
+  return;
+}
+
 const flags = {};
 for (let i = 0; i < args.length; i++) {
   if (args[i] === '--port' && args[i + 1]) {
@@ -68,6 +82,7 @@ for (let i = 0; i < args.length; i++) {
     termdeck --session-logs     Write per-session markdown logs to ~/.termdeck/sessions/
     termdeck init --mnestra      Configure Tier 2 memory (Supabase + Mnestra)
     termdeck init --rumen       Deploy Tier 3 async learning (Rumen)
+    termdeck forge              Generate Claude skills from memories (experimental)
 
   Keyboard shortcuts (in browser):
     Ctrl+Shift+N                Focus prompt bar
@@ -94,6 +109,11 @@ if (flags.sessionLogs) {
   process.env.TERMDECK_SESSION_LOGS = '1';
 }
 
+// First-run detection (Sprint 19 T3): surface a one-line hint pointing at
+// the setup wizard when no config.yaml exists yet. Check happens before
+// loadConfig() so the message reflects on-disk state, not defaults.
+const firstRun = !fs.existsSync(path.join(os.homedir(), '.termdeck', 'config.yaml'));
+
 const config = loadConfig();
 if (flags.port) config.port = flags.port;
 if (flags.sessionLogs) {
@@ -137,6 +157,10 @@ server.listen(port, host, async () => {
   ╚══════════════════════════════════════╝
   `);
 
+  if (firstRun) {
+    console.log("  First run detected. Open http://localhost:3000 and click 'config' to set up.\n");
+  }
+
   // Run preflight health checks (non-blocking — warn but don't prevent startup)
   runPreflight(config).then((result) => {
     printHealthBanner(result);

package/packages/client/public/app.js

@@ -80,6 +80,10 @@
           setTimeout(() => { if (!tourState.active) startTour(); }, 1200);
         }
       } catch {}
+
+      // Sprint 19 T2: auto-open setup wizard if /api/setup reports firstRun.
+      // Silent-fail if the endpoint isn't available yet (T1 not merged).
+      maybeAutoOpenSetupWizard();
     }
 
     // ===== Create Terminal Panel =====
@@ -2419,6 +2423,203 @@
       return html;
     }
 
+    // ===== Setup Wizard (Sprint 19 T2) =====
+    // Progressive-disclosure modal that shows TermDeck's 4 configuration tiers
+    // and their live status. Detection only — does not write config files.
+    const SETUP_TIERS = [
+      {
+        id: '1',
+        name: 'Tier 1 — TermDeck core',
+        desc: 'Local terminal multiplexer running in your browser.',
+        commands: []
+      },
+      {
+        id: '2',
+        name: 'Tier 2 — Mnestra RAG',
+        desc: 'Persistent cross-session memory backed by Postgres + pgvector.',
+        commands: ['termdeck init --mnestra']
+      },
+      {
+        id: '3',
+        name: 'Tier 3 — Rumen learning loop',
+        desc: 'Async insight extraction and morning briefings (Supabase Edge Function).',
+        commands: ['termdeck init --rumen']
+      },
+      {
+        id: '4',
+        name: 'Tier 4 — Projects',
+        desc: 'Named project roots so you can launch with "cc <name>" shorthand.',
+        commands: ['Click the + button in the prompt bar, or edit ~/.termdeck/config.yaml']
+      }
+    ];
+
+    let setupModalOpen = false;
+
+    function ensureSetupModal() {
+      if (document.getElementById('setupModal')) return;
+      const modal = document.createElement('div');
+      modal.className = 'setup-modal';
+      modal.id = 'setupModal';
+      modal.setAttribute('role', 'dialog');
+      modal.setAttribute('aria-modal', 'true');
+      modal.setAttribute('aria-labelledby', 'setupTitle');
+      modal.innerHTML = `
+        <div class="setup-backdrop" id="setupBackdrop"></div>
+        <div class="setup-card">
+          <header class="setup-header">
+            <div>
+              <h3 id="setupTitle">Setup wizard</h3>
+              <p class="setup-subtitle" id="setupSubtitle">Checking status…</p>
+            </div>
+            <button type="button" class="setup-close" id="setupClose" aria-label="Close">×</button>
+          </header>
+          <div class="setup-body">
+            <div class="setup-tiers" id="setupTiers">
+              <div class="setup-loading">Checking tier status…</div>
+            </div>
+          </div>
+          <footer class="setup-footer">
+            <div class="setup-hint">
+              Edit <code>~/.termdeck/config.yaml</code> and <code>~/.termdeck/secrets.env</code>, then re-check.
+            </div>
+            <div class="setup-actions">
+              <button type="button" class="setup-recheck" id="setupRecheck">re-check</button>
+              <button type="button" class="setup-done" id="setupDone">done</button>
+            </div>
+          </footer>
+        </div>
+      `;
+      document.body.appendChild(modal);
+
+      document.getElementById('setupBackdrop').addEventListener('click', closeSetupModal);
+      document.getElementById('setupClose').addEventListener('click', closeSetupModal);
+      document.getElementById('setupDone').addEventListener('click', closeSetupModal);
+      document.getElementById('setupRecheck').addEventListener('click', refreshSetupStatus);
+      modal.addEventListener('keydown', (e) => {
+        if (e.key === 'Escape') { e.preventDefault(); closeSetupModal(); }
+      });
+    }
+
+    async function openSetupModal() {
+      ensureSetupModal();
+      document.getElementById('setupModal').classList.add('open');
+      setupModalOpen = true;
+      await refreshSetupStatus();
+    }
+
+    function closeSetupModal() {
+      const m = document.getElementById('setupModal');
+      if (m) m.classList.remove('open');
+      setupModalOpen = false;
+    }
+
+    async function refreshSetupStatus() {
+      const tiersEl = document.getElementById('setupTiers');
+      const subtitle = document.getElementById('setupSubtitle');
+      const recheckBtn = document.getElementById('setupRecheck');
+      if (!tiersEl) return;
+      tiersEl.innerHTML = '<div class="setup-loading">Checking tier status…</div>';
+      if (subtitle) subtitle.textContent = 'Checking status…';
+      if (recheckBtn) { recheckBtn.disabled = true; recheckBtn.textContent = 're-checking…'; }
+      try {
+        const data = await api('GET', '/api/setup');
+        renderSetupTiers(data);
+        const cur = Number(data.tier) || 1;
+        if (subtitle) {
+          subtitle.textContent = cur >= 4
+            ? 'All tiers configured — you are good to go.'
+            : `Current tier: ${cur} of 4. Install the next tier below to unlock more features.`;
+        }
+      } catch (err) {
+        tiersEl.innerHTML = `<div class="setup-error">
+          Failed to load setup status: ${escapeHtml(err && err.message ? err.message : String(err))}.<br>
+          Make sure the server is reachable and supports <code>GET /api/setup</code>.
+        </div>`;
+        if (subtitle) subtitle.textContent = 'Error checking status.';
+      } finally {
+        if (recheckBtn) { recheckBtn.disabled = false; recheckBtn.textContent = 're-check'; }
+      }
+    }
+
+    function renderSetupTiers(data) {
+      const tiersEl = document.getElementById('setupTiers');
+      if (!tiersEl) return;
+      const tiers = (data && data.tiers) || {};
+      const currentTier = Number(data && data.tier) || 1;
+
+      const html = SETUP_TIERS.map((tier, idx) => {
+        const info = tiers[tier.id] || { status: 'not_configured', detail: 'Unknown' };
+        const status = info.status || 'not_configured';
+        const detail = info.detail || '';
+        const badgeLabel = status === 'active'
+          ? 'active'
+          : status === 'partial' ? 'partial' : 'not configured';
+        const isCurrent = Number(tier.id) === currentTier + 1 && status !== 'active';
+        const cmds = (status === 'active' || tier.commands.length === 0)
+          ? ''
+          : `<div class="setup-cmds">${tier.commands.map((c) => {
+              const copyable = /^termdeck\s/.test(c);
+              return `<div class="setup-cmd">
+                <code>${escapeHtml(c)}</code>
+                ${copyable ? `<button type="button" class="setup-copy" data-copy="${escapeHtml(c)}">copy</button>` : ''}
+              </div>`;
+            }).join('')}</div>`;
+
+        return `
+          <div class="setup-tier setup-tier-${status}${isCurrent ? ' setup-tier-next' : ''}">
+            <div class="setup-tier-rail" aria-hidden="true">
+              <span class="setup-tier-dot"></span>
+              ${idx < SETUP_TIERS.length - 1 ? '<span class="setup-tier-line"></span>' : ''}
+            </div>
+            <div class="setup-tier-body">
+              <div class="setup-tier-head">
+                <span class="setup-tier-name">${escapeHtml(tier.name)}</span>
+                <span class="setup-tier-status setup-tier-status-${status}">${escapeHtml(badgeLabel)}</span>
+              </div>
+              <div class="setup-tier-desc">${escapeHtml(tier.desc)}</div>
+              ${detail ? `<div class="setup-tier-detail">${escapeHtml(detail)}</div>` : ''}
+              ${cmds}
+            </div>
+          </div>
+        `;
+      }).join('');
+
+      tiersEl.innerHTML = html;
+
+      tiersEl.querySelectorAll('.setup-copy').forEach((btn) => {
+        btn.addEventListener('click', () => {
+          const txt = btn.getAttribute('data-copy') || '';
+          navigator.clipboard.writeText(txt).then(() => {
+            const original = btn.textContent;
+            btn.textContent = 'copied!';
+            btn.classList.add('copied');
+            setTimeout(() => {
+              btn.textContent = original;
+              btn.classList.remove('copied');
+            }, 1500);
+          }).catch(() => {});
+        });
+      });
+    }
+
+    async function maybeAutoOpenSetupWizard() {
+      // Auto-open only when the server reports firstRun=true and we're not
+      // already in the middle of the onboarding tour. Silent-fail if the
+      // endpoint doesn't exist (server predates Sprint 19 T1).
+      try {
+        const res = await fetch(`${API}/api/setup`);
+        if (!res.ok) return;
+        const data = await res.json();
+        if (data && data.firstRun && !tourState.active) {
+          setTimeout(() => {
+            if (!tourState.active && !setupModalOpen) openSetupModal();
+          }, 800);
+        }
+      } catch {
+        // API not available — skip silently
+      }
+    }
+
     function fmtUptime(sec) {
       const s = Math.floor(sec);
       const h = Math.floor(s / 3600);
@@ -2460,12 +2661,9 @@
       fetch: () => api('GET', '/api/status'),
       render: renderStatusDropdown
     });
-    setupInfoDropdown({
-      btnId: 'btn-config',
-      dropdownId: 'configDropdown',
-      fetch: () => api('GET', '/api/config'),
-      render: renderConfigDropdown
-    });
+    // Sprint 19 T2: config button now opens the setup wizard instead of the
+    // legacy config dropdown (renderConfigDropdown is kept as dead code).
+    document.getElementById('btn-config').addEventListener('click', openSetupModal);
 
     // Onboarding tour wiring
     document.getElementById('btn-how').addEventListener('click', startTour);