@nforma.ai/nforma 0.2.1 → 0.28.0

package/bin/nForma.cjs

@@ -4,6 +4,7 @@
 const fs         = require('fs');
 const path       = require('path');
 const os         = require('os');
+const crypto     = require('crypto');
 const { spawnSync } = require('child_process');
 
 // ─── Circuit breaker CLI (non-interactive, exits before TUI loads) ───────────
@@ -89,7 +90,7 @@ const { readClaudeJson, writeClaudeJson, getGlobalMcpServers } = core;
 const {
   buildDashboardLines, probeAllSlots,
   maskKey, deriveKeytarAccount,
-  readQgsdJson, writeQgsdJson,
+  readNfJson, writeNfJson,
   buildExportData, validateImportSchema, buildBackupPath,
   buildTimeoutChoices, applyTimeoutUpdate,
   buildPolicyChoices,
@@ -105,6 +106,7 @@ const reqCore = require('./requirements-core.cjs');
 const CLAUDE_JSON_PATH   = path.join(os.homedir(), '.claude.json');
 const PROVIDERS_JSON     = path.join(__dirname, 'providers.json');
 const PROVIDERS_JSON_TMP = PROVIDERS_JSON + '.tmp';
+const SESSIONS_FILE      = path.join(os.homedir(), '.claude', 'nf', 'sessions.json');
 
 // ─── Constants ────────────────────────────────────────────────────────────────
 const PROVIDER_KEY_NAMES = [
@@ -202,11 +204,37 @@ function logEvent(level, msg) {
 
 if (_xtermError) logEvent('warn', `blessed-xterm unavailable: ${_xtermError}`);
 
-// ─── Session state ───────────────────────────────────────────────────────────
-const sessions = [];        // { id, name, cwd, term (XTerm widget), alive }
+// ─── Session state & persistence ─────────────────────────────────────────────
+const sessions = [];        // { id, name, cwd, claudeSessionId, term (XTerm widget), alive }
 let activeSessionIdx = -1;  // -1 = no terminal shown
 let sessionIdCounter = 0;
 
+function loadPersistedSessions() {
+  try {
+    if (!fs.existsSync(SESSIONS_FILE)) return [];
+    return JSON.parse(fs.readFileSync(SESSIONS_FILE, 'utf8'));
+  } catch (_) { return []; }
+}
+
+function savePersistedSessions() {
+  const data = sessions.map(s => ({
+    id: s.id, name: s.name, cwd: s.cwd, claudeSessionId: s.claudeSessionId,
+  }));
+  try {
+    fs.mkdirSync(path.dirname(SESSIONS_FILE), { recursive: true });
+    fs.writeFileSync(SESSIONS_FILE, JSON.stringify(data, null, 2), 'utf8');
+  } catch (_) {}
+}
+
+function removePersistedSession(claudeSessionId) {
+  try {
+    const persisted = loadPersistedSessions();
+    const filtered = persisted.filter(s => s.claudeSessionId !== claudeSessionId);
+    fs.mkdirSync(path.dirname(SESSIONS_FILE), { recursive: true });
+    fs.writeFileSync(SESSIONS_FILE, JSON.stringify(filtered, null, 2), 'utf8');
+  } catch (_) {}
+}
+
 // ─── Module switching (activity bar) ──────────────────────────────────────────
 let activeModuleIdx = 0;
 
@@ -249,6 +277,9 @@ function switchModule(idx) {
     return;
   }
 
+  // Sessions module: don't auto-dispatch (avoids unwanted "New Session" modal)
+  if (idx === 3) return;
+
   // Auto-show first item's content (skip separators, use view-only for interactive actions)
   const first = mod.items[0];
   if (first && first.action !== 'sep') {
@@ -262,8 +293,24 @@ function switchModule(idx) {
 function refreshSessionMenu() {
   const mod = MODULES[3]; // Sessions
   const items = [{ label: '  New Session', action: 'session-new' }];
+
+  // Show persisted sessions that aren't currently loaded
+  const loadedIds = new Set(sessions.map(s => s.claudeSessionId));
+  const persisted = loadPersistedSessions().filter(p => !loadedIds.has(p.claudeSessionId));
+  if (persisted.length > 0) {
+    items.push({ label: ' \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500', action: 'sep' });
+    items.push({ label: ' {#888888-fg}Previous Sessions{/}', action: 'sep' });
+    persisted.forEach(p => {
+      items.push({
+        label: `  {yellow-fg}\u21bb{/} [${p.id}] ${p.name}`,
+        action: `session-resume-${p.claudeSessionId}`,
+      });
+    });
+  }
+
   if (sessions.length > 0) {
     items.push({ label: ' \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500', action: 'sep' });
+    items.push({ label: ' {#888888-fg}Active Sessions{/}', action: 'sep' });
     sessions.forEach((s, i) => {
       const status = s.alive ? '{green-fg}\u25cf{/}' : '{red-fg}\u25cb{/}';
       const active = (i === activeSessionIdx) ? '{#4a9090-fg}\u25b8{/} ' : '  ';
@@ -275,6 +322,7 @@ function refreshSessionMenu() {
     items.push({ label: ' \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500', action: 'sep' });
     items.push({ label: '  Kill Session', action: 'session-kill' });
   }
+
   mod.items = items;
   // If Sessions module is active, refresh the visible menu
   if (activeModuleIdx === 3) {
@@ -284,18 +332,28 @@ function refreshSessionMenu() {
   }
 }
 
-function createSession(name, cwd) {
+function createSession(name, cwd, resumeSessionId) {
   if (!XTerm) {
     toast('Sessions require blessed-xterm (native rebuild needed). Run: npm rebuild', true);
     return null;
   }
+  // Guard: fall back to process.cwd() if provided cwd no longer exists (e.g., resumed session)
+  let effectiveCwd = cwd || process.cwd();
+  if (!fs.existsSync(effectiveCwd)) {
+    logEvent('warn', `Session cwd "${effectiveCwd}" no longer exists, falling back to ${process.cwd()}`);
+    effectiveCwd = process.cwd();
+  }
   const id = ++sessionIdCounter;
+  const claudeSessionId = resumeSessionId || crypto.randomUUID();
+  const args = resumeSessionId
+    ? ['--resume', resumeSessionId]
+    : ['--session-id', claudeSessionId];
   const term = new XTerm({
     screen,
     parent: screen,
     shell: 'claude',
-    args: [],
-    cwd: cwd || process.cwd(),
+    args,
+    cwd: effectiveCwd,
     cursorType: 'block',
     scrollback: 1000,
     top: 3, left: 35, right: 0, bottom: 2,
@@ -311,8 +369,9 @@ function createSession(name, cwd) {
   });
   term.hide();
 
-  const session = { id, name, cwd: cwd || process.cwd(), term, alive: true };
+  const session = { id, name, cwd: effectiveCwd, claudeSessionId, term, alive: true };
   sessions.push(session);
+  savePersistedSessions();
 
   term.on('exit', () => {
     session.alive = false;
@@ -358,6 +417,7 @@ function killSession(idx) {
   const session = sessions[idx];
   try { session.term.terminate(); } catch (_) {}
   screen.remove(session.term);
+  removePersistedSession(session.claudeSessionId);
   sessions.splice(idx, 1);
   // Adjust activeSessionIdx
   if (activeSessionIdx === idx) {
@@ -376,13 +436,31 @@ async function newSessionFlow() {
 }
 
 async function killSessionFlow() {
-  if (sessions.length === 0) { toast('No sessions to kill'); return; }
-  const items = sessions.map((s, i) => ({
-    label: `[${s.id}] ${s.name} (${s.alive ? 'alive' : 'dead'})`,
-    value: i,
-  }));
+  const items = [];
+  sessions.forEach((s, i) => {
+    items.push({
+      label: `[${s.id}] ${s.name} (${s.alive ? 'alive' : 'dead'})`,
+      value: { type: 'active', idx: i },
+    });
+  });
+  // Also offer to remove persisted (inactive) sessions
+  const loadedIds = new Set(sessions.map(s => s.claudeSessionId));
+  const persisted = loadPersistedSessions().filter(p => !loadedIds.has(p.claudeSessionId));
+  persisted.forEach(p => {
+    items.push({
+      label: `[${p.id}] ${p.name} (saved)`,
+      value: { type: 'persisted', claudeSessionId: p.claudeSessionId },
+    });
+  });
+  if (items.length === 0) { toast('No sessions to kill'); return; }
   const choice = await promptList({ title: 'Kill Session', items });
-  killSession(choice.value);
+  if (choice.value.type === 'active') {
+    killSession(choice.value.idx);
+  } else {
+    removePersistedSession(choice.value.claudeSessionId);
+    refreshSessionMenu();
+    toast('Saved session removed');
+  }
 }
 
 // ─── Providers.json helpers ───────────────────────────────────────────────────
@@ -397,11 +475,11 @@ function writeProvidersJson(data) {
 
 // ─── Update policy helper ────────────────────────────────────────────────────
 function writeUpdatePolicy(slotName, policy) {
-  const qgsd = readQgsdJson();
-  if (!qgsd.agent_config) qgsd.agent_config = {};
-  if (!qgsd.agent_config[slotName]) qgsd.agent_config[slotName] = {};
-  qgsd.agent_config[slotName].update_policy = policy;
-  writeQgsdJson(qgsd);
+  const nfCfg = readNfJson();
+  if (!nf.agent_config) nf.agent_config = {};
+  if (!nf.agent_config[slotName]) nf.agent_config[slotName] = {};
+  nf.agent_config[slotName].update_policy = policy;
+  writeNfJson(nfCfg);
 }
 
 // ─── Secrets loader (cached — keychain prompted once per process) ─────────────
@@ -409,7 +487,7 @@ let _secretsCache = undefined;
 function loadSecrets() {
   if (_secretsCache !== undefined) return _secretsCache;
   const candidates = [
-    path.join(os.homedir(), '.claude', 'qgsd-bin', 'secrets.cjs'),
+    path.join(os.homedir(), '.claude', 'nf-bin', 'secrets.cjs'),
     path.join(__dirname, 'secrets.cjs'),
   ];
   for (const p of candidates) {
@@ -521,7 +599,7 @@ function agentRows() {
         const pp = require('./planning-paths.cjs');
         failPath = pp.resolveWithFallback(process.cwd(), 'quorum-failures');
       } catch (_) {
-        failPath = path.join(os.homedir(), '.claude', 'qgsd', 'quorum-failures.json');
+        failPath = path.join(os.homedir(), '.claude', 'nf', 'quorum-failures.json');
       }
       if (fs.existsSync(failPath)) {
         const failures = JSON.parse(fs.readFileSync(failPath, 'utf8'));
@@ -554,15 +632,15 @@ function buildHeaderInfo() {
   let quorumN = '—';
   let failMode = '—';
   try {
-    const qgsd   = readQgsdJson();
-    const defN   = qgsd.quorum?.maxSize;
-    const byProf = qgsd.quorum?.maxSizeByProfile || {};
+    const nfCfg   = readNfJson();
+    const defN   = nf.quorum?.maxSize;
+    const byProf = nf.quorum?.maxSizeByProfile || {};
     const effN   = byProf[profile] ?? defN;
     if (effN != null) quorumN = String(effN) + (byProf[profile] != null ? '*' : '');
-    if (qgsd.fail_mode) failMode = qgsd.fail_mode;
+    if (nf.fail_mode) failMode = nf.fail_mode;
   } catch (_) {}
 
-  // Key agent tiers — from qgsd-core/references/model-profiles.md
+  // Key agent tiers — from core/references/model-profiles.md
   const TIERS = {
     planner:    { quality: 'opus',   balanced: 'opus',   budget: 'sonnet' },
     executor:   { quality: 'opus',   balanced: 'sonnet', budget: 'sonnet' },
@@ -674,19 +752,19 @@ function refreshStatusBar(extra) {
 // ─── Settings content (rendered in contentBox when Settings action selected) ──
 function buildSettingsPaneContent() {
   const cfg     = readProjectConfig();
-  const qgsd    = readQgsdJson();
+  const nfCfg    = readNfJson();
   const profile = cfg.model_profile || 'balanced';
   const ov      = cfg.model_overrides || {};
-  const defN    = qgsd.quorum?.maxSize ?? 3;
-  const byProf  = qgsd.quorum?.maxSizeByProfile || {};
+  const defN    = nf.quorum?.maxSize ?? 3;
+  const byProf  = nf.quorum?.maxSizeByProfile || {};
   const effN    = byProf[profile] ?? defN;
   const nStr    = String(effN) + (byProf[profile] != null ? '*' : '');
-  const failStr = qgsd.fail_mode || '—';
+  const failStr = nf.fail_mode || '—';
 
   const D = '{#777777-fg}', V = '{#aaaaaa-fg}', A = '{#4a9090-fg}', Z = '{/}';
   const mTag = k => ov[k] ? `${A}${ov[k]}${Z}{#888888-fg}*${Z}` : `${V}${AGENT_TIERS[k]?.[profile] || '—'}${Z}`;
 
-  const agents = ['qgsd-planner', 'qgsd-executor', 'qgsd-phase-researcher', 'qgsd-verifier', 'qgsd-codebase-mapper'];
+  const agents = ['nf-planner', 'nf-executor', 'nf-phase-researcher', 'nf-verifier', 'nf-codebase-mapper'];
   const labels = ['Planner', 'Executor', 'Researcher', 'Verifier', 'Mapper'];
 
   const lines = [
@@ -865,7 +943,7 @@ function promptCheckbox(opts) {
 // Writes a temp shell script and opens it in a new Terminal.app window via osascript.
 // Returns true if the terminal was opened successfully.
 function spawnExternalTerminal(loginCmd) {
-  const tmpScript = path.join(os.tmpdir(), 'qgsd-auth-' + Date.now() + '.sh');
+  const tmpScript = path.join(os.tmpdir(), 'nf-auth-' + Date.now() + '.sh');
   try {
     fs.writeFileSync(tmpScript, [
       '#!/bin/sh',
@@ -1073,7 +1151,7 @@ async function addAgentFlow() {
 
   const secrets = loadSecrets();
   if (apiKey && secrets) {
-    await secrets.set('qgsd', deriveKeytarAccount(slotName), apiKey);
+    await secrets.set('nforma', deriveKeytarAccount(slotName), apiKey);
   } else if (apiKey) {
     env.ANTHROPIC_API_KEY = apiKey;
   }
@@ -1104,20 +1182,20 @@ async function cloneSlotFlow() {
   data.mcpServers = { ...servers, [newName]: cloned };
   writeClaudeJson(data);
 
-  // Copy qgsd.json agent_config metadata from source to cloned slot
+  // Copy nf.json agent_config metadata from source to cloned slot
   try {
-    const qgsd = readQgsdJson();
-    const sourceConfig = (qgsd.agent_config || {})[source.value];
+    const nfCfg = readNfJson();
+    const sourceConfig = (nf.agent_config || {})[source.value];
     if (sourceConfig) {
-      if (!qgsd.agent_config) qgsd.agent_config = {};
-      qgsd.agent_config[newName] = JSON.parse(JSON.stringify(sourceConfig));
+      if (!nf.agent_config) nf.agent_config = {};
+      nf.agent_config[newName] = JSON.parse(JSON.stringify(sourceConfig));
       // Clear key_status from clone (needs fresh probe)
-      if (qgsd.agent_config[newName].key_status) {
-        delete qgsd.agent_config[newName].key_status;
+      if (nf.agent_config[newName].key_status) {
+        delete nf.agent_config[newName].key_status;
       }
-      writeQgsdJson(qgsd);
+      writeNfJson(nfCfg);
     }
-  } catch (_) { /* qgsd.json might not exist yet -- non-fatal */ }
+  } catch (_) { /* nf.json might not exist yet -- non-fatal */ }
 
   toast(`✓ Cloned "${source.value}" → "${newName}"`);
   renderList();
@@ -1193,9 +1271,9 @@ async function editAgentFlow() {
             prompt: 'ANTHROPIC_API_KEY (blank = remove):', isPassword: true });
           const secrets = loadSecrets();
           const account = deriveKeytarAccount(slotName);
-          if (val && secrets)      { await secrets.set('qgsd', account, val); delete env.ANTHROPIC_API_KEY; }
+          if (val && secrets)      { await secrets.set('nforma', account, val); delete env.ANTHROPIC_API_KEY; }
           else if (val)             { env.ANTHROPIC_API_KEY = val; }
-          else if (secrets)         { await secrets.delete('qgsd', account); delete env.ANTHROPIC_API_KEY; }
+          else if (secrets)         { await secrets.delete('nforma', account); delete env.ANTHROPIC_API_KEY; }
           else                      { delete env.ANTHROPIC_API_KEY; }
 
         } else if (field.value === 'baseUrl') {
@@ -1478,7 +1556,7 @@ async function loginAgentFlow() {
 // ─── Provider Keys ────────────────────────────────────────────────────────────
 async function renderProviderKeys() {
   const secrets = loadSecrets();
-  if (!secrets) { setContent('Provider Keys', '{red-fg}secrets.cjs not found — QGSD not installed.{/}'); return; }
+  if (!secrets) { setContent('Provider Keys', '{red-fg}secrets.cjs not found — nForma not installed.{/}'); return; }
   const lines = ['{bold}Provider Keys (keytar){/bold}', '─'.repeat(40)];
   for (const { key, label } of PROVIDER_KEY_NAMES) {
     // hasKey() reads local JSON index — no keychain prompt
@@ -1492,7 +1570,7 @@ async function renderProviderKeys() {
 async function providerKeysFlow() {
   setContent('Provider Keys', '{gray-fg}Select an action…{/}');
   const secrets = loadSecrets();
-  if (!secrets) { toast('secrets.cjs not found — QGSD not installed', true); return; }
+  if (!secrets) { toast('secrets.cjs not found — nForma not installed', true); return; }
 
   while (true) {                                                // action loop: ESC → main menu
     let action;
@@ -1518,7 +1596,7 @@ async function providerKeysFlow() {
 
       try {
         if (action.value === 'remove') {
-          await secrets.delete('qgsd', picked.value);
+          await secrets.delete('nforma', picked.value);
           toast(`Removed ${picked.label}`);
           await renderProviderKeys();
           continue;                                             // re-show key picker (remove more)
@@ -1526,7 +1604,7 @@ async function providerKeysFlow() {
 
         const val = await promptInput({ title: `Set ${picked.label}`, prompt: `Value for ${picked.value}:`, isPassword: true });
         if (!val) { toast('Empty value — key not stored', true); continue; }
-        await secrets.set('qgsd', picked.value, val);
+        await secrets.set('nforma', picked.value, val);
         toast(`${picked.label} saved to keychain`);
         await renderProviderKeys();
       } catch (_) { continue; }                                // ESC during value input → re-show key picker
@@ -1537,7 +1615,7 @@ async function providerKeysFlow() {
 // ─── Post-Rotation Validation (CRED-01: fire-and-forget, non-blocking) ───────
 /**
  * Fire-and-forget post-rotation validation.
- * Probes each rotated slot and persists key_status to qgsd.json.
+ * Probes each rotated slot and persists key_status to nf.json.
  * Does NOT block the caller -- called with .catch(() => {}).
  * Uses sequential for...of to avoid keychain concurrency (same pattern as rotation loop).
  * Reuses probeAndPersistKey from manage-agents-core.cjs (DRY -- do not duplicate probe/classify/write logic).
@@ -1556,7 +1634,7 @@ async function validateRotatedKeys(rotatedSlots) {
     if (secretsLib) {
       try {
         const account = deriveKeytarAccount(slotName);
-        const k = await secretsLib.get('qgsd', account);
+        const k = await secretsLib.get('nforma', account);
         if (k) apiKey = k;
       } catch (_) {}
     }
@@ -1604,7 +1682,7 @@ async function batchRotateFlow() {
 
     const account = deriveKeytarAccount(picked.value);
     if (secrets) {
-      await secrets.set('qgsd', account, newKey);
+      await secrets.set('nforma', account, newKey);
     } else {
       if (!servers[picked.value].env) servers[picked.value].env = {};
       servers[picked.value].env.ANTHROPIC_API_KEY = newKey;
@@ -1671,7 +1749,7 @@ function buildScoreboardLines(data, opts) {
     const lines = [];
     lines.push('{bold}  Quorum Scoreboard{/bold}');
     lines.push('  {gray-fg}No agents configured in providers.json.{/}');
-    lines.push('  {gray-fg}Run /qgsd:mcp-setup to add agents.{/}');
+    lines.push('  {gray-fg}Run /nf:mcp-setup to add agents.{/}');
     lines.push('');
     return lines;
   }
@@ -1973,18 +2051,18 @@ async function updateAgentsFlow() {
 
 // ─── Settings helpers ─────────────────────────────────────────────────────────
 const AGENT_TIERS = {
-  'qgsd-planner':          { quality: 'opus',   balanced: 'opus',   budget: 'sonnet' },
-  'qgsd-executor':         { quality: 'opus',   balanced: 'sonnet', budget: 'sonnet' },
-  'qgsd-phase-researcher': { quality: 'opus',   balanced: 'sonnet', budget: 'haiku'  },
-  'qgsd-verifier':         { quality: 'sonnet', balanced: 'sonnet', budget: 'haiku'  },
-  'qgsd-codebase-mapper':  { quality: 'sonnet', balanced: 'haiku',  budget: 'haiku'  },
+  'nf-planner':          { quality: 'opus',   balanced: 'opus',   budget: 'sonnet' },
+  'nf-executor':         { quality: 'opus',   balanced: 'sonnet', budget: 'sonnet' },
+  'nf-phase-researcher': { quality: 'opus',   balanced: 'sonnet', budget: 'haiku'  },
+  'nf-verifier':         { quality: 'sonnet', balanced: 'sonnet', budget: 'haiku'  },
+  'nf-codebase-mapper':  { quality: 'sonnet', balanced: 'haiku',  budget: 'haiku'  },
 };
 const AGENT_LABELS = {
-  'qgsd-planner':          'Planner',
-  'qgsd-executor':         'Executor',
-  'qgsd-phase-researcher': 'Researcher',
-  'qgsd-verifier':         'Verifier',
-  'qgsd-codebase-mapper':  'Mapper',
+  'nf-planner':          'Planner',
+  'nf-executor':         'Executor',
+  'nf-phase-researcher': 'Researcher',
+  'nf-verifier':         'Verifier',
+  'nf-codebase-mapper':  'Mapper',
 };
 
 function readProjectConfig() {
@@ -2001,10 +2079,10 @@ function writeProjectConfig(cfg) {
 async function settingsFlow() {
   while (true) {
     const cfg     = readProjectConfig();
-    const qgsd    = readQgsdJson();
+    const nfCfg    = readNfJson();
     const profile = cfg.model_profile || 'balanced';
-    const defN    = qgsd.quorum?.maxSize ?? 3;
-    const byProf  = qgsd.quorum?.maxSizeByProfile || {};
+    const defN    = nf.quorum?.maxSize ?? 3;
+    const byProf  = nf.quorum?.maxSizeByProfile || {};
     const effN    = byProf[profile] ?? defN;
     const nStr    = String(effN) + (byProf[profile] != null ? '*' : '');
     const ovCount = Object.keys(cfg.model_overrides || {}).length;
@@ -2014,7 +2092,7 @@ async function settingsFlow() {
       picked = await promptList({ title: 'Settings', items: [
         { label: `  Profile          ${profile}`,              value: 'profile'   },
         { label: `  Quorum n         ${nStr}  →`,              value: 'n'         },
-        { label: `  Fail mode        ${qgsd.fail_mode || '—'}`,value: 'fail'      },
+        { label: `  Fail mode        ${nf.fail_mode || '—'}`,value: 'fail'      },
         { label: `  Model overrides  ${ovCount ? `${ovCount} active` : 'none'}  →`, value: 'overrides' },
       ]});
     } catch (_) { return; }
@@ -2046,9 +2124,9 @@ async function settingsFlow() {
           { label: 'strict   Block if any required slot fails',       value: 'strict'  },
         ]});
       } catch (_) { continue; }
-      const qg = readQgsdJson();
+      const qg = readNfJson();
       qg.fail_mode = choice.value;
-      writeQgsdJson(qg);
+      writeNfJson(qg);
       refreshSettingsPane();
       toast(`✓ Fail mode → ${choice.value}`);
 
@@ -2109,9 +2187,9 @@ async function modelOverridesFlow() {
 
 async function quorumNFlow() {
   while (true) {
-    const qgsd   = readQgsdJson();
-    const defN   = qgsd.quorum?.maxSize ?? 3;
-    const byProf = qgsd.quorum?.maxSizeByProfile || {};
+    const nfCfg   = readNfJson();
+    const defN   = nf.quorum?.maxSize ?? 3;
+    const byProf = nf.quorum?.maxSizeByProfile || {};
     const fmt    = p => byProf[p] != null ? String(byProf[p]) : `${defN} (default)`;
 
     let picked;
@@ -2138,19 +2216,19 @@ async function quorumNFlow() {
     const n = parseInt(val.trim(), 10);
     if (isNaN(n) || n < 0) { toast('Invalid — enter a positive number or 0 to remove', true); continue; }
 
-    if (!qgsd.quorum) qgsd.quorum = {};
+    if (!nf.quorum) nf.quorum = {};
     if (picked.value === 'default') {
-      qgsd.quorum.maxSize = n;
+      nf.quorum.maxSize = n;
     } else {
-      if (!qgsd.quorum.maxSizeByProfile) qgsd.quorum.maxSizeByProfile = {};
+      if (!nf.quorum.maxSizeByProfile) nf.quorum.maxSizeByProfile = {};
       if (n === 0) {
-        delete qgsd.quorum.maxSizeByProfile[picked.value];
-        if (!Object.keys(qgsd.quorum.maxSizeByProfile).length) delete qgsd.quorum.maxSizeByProfile;
+        delete nf.quorum.maxSizeByProfile[picked.value];
+        if (!Object.keys(nf.quorum.maxSizeByProfile).length) delete nf.quorum.maxSizeByProfile;
       } else {
-        qgsd.quorum.maxSizeByProfile[picked.value] = n;
+        nf.quorum.maxSizeByProfile[picked.value] = n;
       }
     }
-    writeQgsdJson(qgsd);
+    writeNfJson(nfCfg);
     renderHeader();
     refreshSettingsPane();
     toast(`✓ Quorum n (${picked.value}) → ${n === 0 ? 'reset to default' : n}`);
@@ -2209,8 +2287,8 @@ async function updatePolicyFlow() {
   const slots   = Object.keys(servers);
   if (!slots.length) { toast('No slots configured', true); return; }
 
-  const qgsd        = readQgsdJson();
-  const agentConfig = qgsd.agent_config || {};
+  const nfCfg        = readNfJson();
+  const agentConfig = nf.agent_config || {};
 
   const target = await promptList({ title: 'Update Policy — Pick slot',
     items: slots.map(s => ({
@@ -2276,7 +2354,7 @@ async function importFlow() {
             prompt: `API key for ${slotName} / ${envKey} (blank = skip):`, isPassword: true });
         } catch (_) { delete cfg.env[envKey]; continue; }       // ESC → skip key, move to next
         if (val) {
-          if (secrets) { await secrets.set('qgsd', deriveKeytarAccount(slotName), val); delete cfg.env[envKey]; }
+          if (secrets) { await secrets.set('nforma', deriveKeytarAccount(slotName), val); delete cfg.env[envKey]; }
           else          { cfg.env[envKey] = val; }
         } else {
           delete cfg.env[envKey];
@@ -2335,6 +2413,13 @@ async function dispatch(action) {
     else if (action === 'req-gaps')         reqCoverageGapsFlow();
     else if (action === 'session-new')  await newSessionFlow();
     else if (action === 'session-kill') await killSessionFlow();
+    else if (action.startsWith('session-resume-')) {
+      const csid = action.replace('session-resume-', '');
+      const persisted = loadPersistedSessions().find(p => p.claudeSessionId === csid);
+      if (persisted) {
+        createSession(persisted.name, persisted.cwd, persisted.claudeSessionId);
+      }
+    }
     else if (action.startsWith('session-connect-')) {
       connectSession(parseInt(action.replace('session-connect-', ''), 10));
     }
@@ -2568,7 +2653,7 @@ function reqCoverageGapsFlow() {
     lines.push('');
 
     // Run for all known specs
-    const specs = ['QGSDQuorum', 'QGSDStopHook', 'QGSDCircuitBreaker'];
+    const specs = ['NFQuorum', 'NFStopHook', 'NFCircuitBreaker'];
     let totalGaps = 0;
 
     for (const specName of specs) {
@@ -2698,6 +2783,12 @@ function applyUpdateBadge(outdatedCount) {
 // ─── Start ────────────────────────────────────────────────────────────────────
 if (require.main === module) {
   renderHeader();
+  // Restore persisted session counter so IDs don't collide
+  const _persisted = loadPersistedSessions();
+  if (_persisted.length > 0) {
+    sessionIdCounter = Math.max(..._persisted.map(p => p.id));
+  }
+  refreshSessionMenu();
   switchModule(0);
   const warns = _logEntries.filter(e => e.level === 'warn' || e.level === 'error');
   if (warns.length) {
@@ -2723,4 +2814,8 @@ module.exports._pure = {
   MODULES,
   logEvent,
   _logEntries,
+  loadPersistedSessions,
+  savePersistedSessions,
+  removePersistedSession,
+  SESSIONS_FILE,
 };