elanous 0.2.0 → 0.2.4

package/scripts/release-loop/pwa-scenarios-node.ts

@@ -0,0 +1,140 @@
+#!/usr/bin/env bun
+/**
+ * Release-loop ④ — run the PWA scenario suite on one commit, in isolation, and print one verdict.
+ *
+ *   bun scripts/release-loop/pwa-scenarios-node.ts --commit <sha> [--with-costly] [--reruns 2] [--json]
+ *
+ * Steps: temp worktree at <sha> → `nexus build` → isolated nexus (`--test`, leased test port)
+ * → warm-up pass (discarded — the first page load after boot is slow and made T4a/N5a fail on the
+ * 0.2.3 cut) → every scenario → rerun failed cells → stop nexus, remove worktree.
+ * Never touches the production daemon or ~/.elanous.
+ *
+ * Exit: 0 = pass or flaky · 1 = fail · 2 = could not run (worktree, build, boot).
+ * `--with-costly` adds scenarios that call a real model (C1).
+ */
+import { spawn, spawnSync } from 'node:child_process';
+import { existsSync, mkdtempSync, openSync, readFileSync, symlinkSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { decideVerdict, exitCodeFor, idsToRerun, type CellRun, type NodeVerdict } from './pwa-node-verdict';
+import { envLiteral } from '../../src/platform/env-literal.js';
+
+interface Options { commit: string; withCostly: boolean; reruns: number; json: boolean }
+
+function parseArgs(argv: readonly string[]): Options {
+  const opts: Options = { commit: '', withCostly: false, reruns: 2, json: false };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === '--commit') opts.commit = argv[++i] ?? '';
+    else if (arg === '--with-costly') opts.withCostly = true;
+    else if (arg === '--json') opts.json = true;
+    else if (arg === '--reruns') opts.reruns = Number(argv[++i] ?? '2');
+    else throw new Error(`unknown argument: ${arg}`);
+  }
+  if (!/^[0-9a-f]{7,40}$/i.test(opts.commit)) throw new Error('--commit <sha> is required');
+  if (!Number.isInteger(opts.reruns) || opts.reruns < 0 || opts.reruns > 5) throw new Error('--reruns must be 0..5');
+  return opts;
+}
+
+const NO_PROXY_ENV = Object.fromEntries(Object.entries(process.env).filter(([k]) => !/^(https?|all)_proxy$/i.test(k)));
+const log = (msg: string) => process.stderr.write(`[pwa-node] ${msg}\n`);
+
+function run(cmd: string, args: string[], cwd: string, timeoutMs = 600_000) {
+  const r = spawnSync(cmd, args, { cwd, env: envLiteral(NO_PROXY_ENV), encoding: 'utf8', timeout: timeoutMs, maxBuffer: 64 * 1024 * 1024 });
+  return { rc: r.status ?? -1, stdout: r.stdout ?? '', stderr: r.stderr ?? '' };
+}
+
+async function waitFor(check: () => boolean | Promise<boolean>, timeoutMs: number, what: string): Promise<void> {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (await check()) return;
+    await new Promise((r) => setTimeout(r, 1000));
+  }
+  throw new Error(`timed out waiting for ${what}`);
+}
+
+function scenarioRun(worktree: string, baseUrl: string, ids: readonly string[]): CellRun[] {
+  const r = run('bun', ['scripts/pwa-scenarios.ts', '--base-url', baseUrl, '--only', ids.join(','), '--json'], worktree, 900_000);
+  const line = r.stdout.split('\n').reverse().find((l) => l.trim().startsWith('{'));
+  if (!line) throw new Error(`scenario runner produced no JSON (rc=${r.rc}): ${r.stderr.slice(-300)}`);
+  const parsed = JSON.parse(line) as { results: Array<{ id: string; pass: boolean; blocked?: string }> };
+  return parsed.results.map((c) => ({ id: c.id, pass: c.pass, blocked: Boolean(c.blocked) }));
+}
+
+async function main(): Promise<number> {
+  let opts: Options;
+  try { opts = parseArgs(process.argv.slice(2)); } catch (e) { log(String(e)); return 2; }
+  const repo = resolve('.');
+  const work = mkdtempSync(join(tmpdir(), 'pwa-node-'));
+  const worktree = join(work, 'tree');
+  let nexusPid: number | undefined;
+  let verdict: NodeVerdict | undefined;
+  let failure: string | undefined;
+  try {
+    const add = run('git', ['worktree', 'add', '--detach', worktree, opts.commit], repo);
+    if (add.rc !== 0) throw new Error(`worktree add failed: ${add.stderr.trim()}`);
+    symlinkSync(join(repo, 'node_modules'), join(worktree, 'node_modules'));
+    if (existsSync(join(repo, 'apps/pwa/node_modules'))) symlinkSync(join(repo, 'apps/pwa/node_modules'), join(worktree, 'apps/pwa/node_modules'));
+
+    log(`build ${opts.commit.slice(0, 10)}`);
+    const build = run('bun', ['bin/elanous.mjs', 'nexus', 'build'], worktree, 900_000);
+    if (build.rc !== 0) throw new Error(`nexus build failed (rc=${build.rc})`);
+
+    const nexusLog = join(work, 'nexus.log');
+    const emptyCwd = mkdtempSync(join(work, 'cwd-'));
+    const child = spawn('bun', ['bin/elanous.mjs', 'nexus', 'run', '--test', '--tool-cwd', emptyCwd], {
+      cwd: worktree, env: envLiteral(NO_PROXY_ENV), detached: true, stdio: ['ignore', openSync(nexusLog, 'a'), openSync(nexusLog, 'a')],
+    });
+    child.unref();
+    let port = '';
+    await waitFor(() => {
+      const m = /nexus +:(\d+)/.exec(existsSync(nexusLog) ? readFileSync(nexusLog, 'utf8') : '');
+      if (m) port = m[1]!;
+      const pid = /pid +(\d+)/.exec(existsSync(nexusLog) ? readFileSync(nexusLog, 'utf8') : '');
+      if (pid) nexusPid = Number(pid[1]);
+      return port !== '';
+    }, 60_000, 'nexus port');
+    const baseUrl = `http://127.0.0.1:${port}`;
+    await waitFor(async () => {
+      try { await fetch(`${baseUrl}/app/`); return true; } catch { return false; }
+    }, 60_000, 'nexus http');
+    log(`nexus up ${baseUrl} pid=${nexusPid ?? '?'}`);
+
+    const list = run('bun', ['-e', `import('./scripts/lib/pwa-scenarios/scenarios.ts').then(m=>console.log(JSON.stringify(m.createScenarios().map(s=>({id:s.id,costly:!!s.costly})))))`], worktree);
+    const all = JSON.parse(list.stdout.trim()) as Array<{ id: string; costly: boolean }>;
+    const ids = all.filter((s) => opts.withCostly || !s.costly).map((s) => s.id);
+
+    log('warm-up (discarded)');
+    scenarioRun(worktree, baseUrl, ids.filter((id) => !all.find((s) => s.id === id)?.costly));
+
+    log(`run ${ids.join(',')}`);
+    const first = scenarioRun(worktree, baseUrl, ids);
+    const reruns: CellRun[][] = [];
+    let pending = idsToRerun(first);
+    for (let i = 0; i < opts.reruns && pending.length > 0; i++) {
+      log(`rerun ${i + 1}: ${pending.join(',')}`);
+      const pass = scenarioRun(worktree, baseUrl, pending);
+      reruns.push(pass);
+      pending = pass.filter((r) => !r.pass || r.blocked).map((r) => r.id);
+    }
+    verdict = decideVerdict(first, reruns);
+  } catch (e) {
+    failure = e instanceof Error ? e.message : String(e);
+    log(`could not run: ${failure}`);
+  } finally {
+    if (existsSync(worktree)) run('bun', ['bin/elanous.mjs', 'nexus', 'run', '--test', '--stop'], worktree, 60_000);
+    if (nexusPid) { try { process.kill(nexusPid, 'SIGTERM'); } catch { /* already gone */ } }
+    run('git', ['worktree', 'remove', '--force', worktree], repo);
+  }
+
+  const out = { verdict: verdict?.verdict ?? 'error', commit: opts.commit, withCostly: opts.withCostly, cells: verdict?.cells ?? [], ...(failure ? { error: failure } : {}) };
+  if (opts.json) console.log(JSON.stringify(out));
+  else {
+    console.log(`pwa-node: ${out.verdict} · ${opts.commit.slice(0, 10)}`);
+    for (const c of out.cells) console.log(`  ${c.id} ${c.final}${c.reruns.length ? ` (first ${c.first} · reruns ${c.reruns.join('/')})` : ''}`);
+    if (failure) console.log(`  error: ${failure}`);
+  }
+  return verdict ? exitCodeFor(verdict.verdict) : 2;
+}
+
+process.exit(await main());

package/scripts/release-loop/release-docs.ts

@@ -0,0 +1,102 @@
+import type { ReleaseManifest } from '../../src/release-loop/manifest.js';
+
+/** Render the cutoff's IN set, never the deferred or escalation lists. */
+export function renderReleaseNotes(manifest: ReleaseManifest, version: string): string {
+  const sections = [
+    { heading: 'Behavior changes', kinds: ['feat', 'fix'] },
+    { heading: 'Security', kinds: ['security'] },
+    { heading: 'Internal', kinds: ['internal'] },
+    { heading: 'Other changes', kinds: ['unknown'] },
+  ] as const;
+  const lines = [`# ${version}`, ''];
+  for (const section of sections) {
+    const entries = manifest.in.filter((entry) => section.kinds.some((kind) => kind === (entry.kind ?? 'unknown')));
+    if (!entries.length) continue;
+    lines.push(`## ${section.heading}`, '');
+    for (const entry of entries) {
+      const label = (entry.line ?? entry.title).replace(/\r?\n/g, ' ').trim();
+      lines.push(entry.prNumber === undefined
+        ? `- ${label}`
+        : `- ${label} ([#${entry.prNumber}](https://github.com/ElanvitalAI/elanous/pull/${entry.prNumber}))`);
+    }
+    lines.push('');
+  }
+  return `${lines.join('\n').trimEnd()}\n`;
+}
+
+/** Mark only the public-doc status indicator, leaving unfinished/design annotations untouched. */
+export function flipNextReleaseMarkers(text: string, version: string): string {
+  return text.replace(/🟡 on main(?: — next release|, in the next release)?/g, `✅ in v${version.replace(/^v/, '')}`);
+}
+
+/**
+ * Fold notes that landed before the release loop (a PR appending its own line, a headline paragraph)
+ * into the rendered notes instead of refusing or overwriting them. Paragraphs before any section stay
+ * under the title (the headline slot); list lines the cutoff did not render keep their own `##` section
+ * (lines outside any section go to «Also in this release»). A line that differs from a rendered one only
+ * by the trailing PR link is the same line. Folding its own output again gives the same bytes.
+ */
+export function foldPreLandedNotes(existing: string, rendered: string): { text: string; folded: number } {
+  const key = (line: string) => line.trim().replace(/\s*\(\[#\d+\]\([^)]*\)\)\s*$/, '').trim();
+  // Rendered list keys per section — a pre-landed line is «already rendered» only within the same heading
+  // (or anywhere, when it sits outside any section).
+  const renderedBySection = new Map<string, Set<string>>();
+  const renderedAll = new Set<string>();
+  { let h = ''; for (const l of rendered.split(/\r?\n/)) { const t = l.trim(); if (/^##\s/.test(t)) { h = t; continue; } if (/^[-*]\s/.test(t)) { renderedAll.add(key(t)); const set = renderedBySection.get(h) ?? new Set<string>(); set.add(key(t)); renderedBySection.set(h, set); } } }
+  const alreadyRendered = (line: string, section: string | null) => section === null ? renderedAll.has(key(line)) : (renderedBySection.get(section)?.has(key(line)) ?? false);
+  const paragraphs: string[] = [];
+  const sections = new Map<string, string[]>();
+  const DEFAULT = '## Also in this release';
+  let heading: string | null = null;
+  for (const raw of existing.split(/\r?\n/)) {
+    const line = raw.trimEnd();
+    const trimmed = line.trim();
+    if (/^#\s/.test(trimmed)) continue;
+    if (!trimmed) {
+      // Keep paragraph breaks (collapse runs of blank lines to one) in the headline block and in sections.
+      if (heading === null) { if (paragraphs.length && paragraphs.at(-1) !== '') paragraphs.push(''); }
+      else { const list = sections.get(heading)!; if (list.length && list.at(-1) !== '') list.push(''); }
+      continue;
+    }
+    if (/^##\s/.test(trimmed)) { heading = trimmed; if (!sections.has(heading)) sections.set(heading, []); continue; }
+    if (/^[-*]\s/.test(trimmed)) {
+      if (alreadyRendered(trimmed, heading)) continue;
+      const target = heading ?? DEFAULT;
+      const list = sections.get(target) ?? [];
+      if (!list.some((item) => key(item) === key(trimmed))) list.push(trimmed);
+      sections.set(target, list);
+    } else if (heading === null) {
+      paragraphs.push(line);
+    } else {
+      // Prose under a section keeps its section.
+      const list = sections.get(heading) ?? [];
+      list.push(line);
+      sections.set(heading, list);
+    }
+  }
+  // Rendered notes = title ⊕ ordered `##` sections. A pre-landed section with the same heading merges into it.
+  const [title, ...rest] = rendered.trimEnd().split('\n');
+  const renderedSections: Array<{ heading: string; lines: string[] }> = [];
+  for (const line of rest) {
+    if (/^##\s/.test(line.trim())) renderedSections.push({ heading: line.trim(), lines: [] });
+    else if (renderedSections.length && line.trim()) renderedSections.at(-1)!.lines.push(line);
+  }
+  let folded = paragraphs.filter(Boolean).length;
+  for (const lines of sections.values()) while (lines.at(-1) === '') lines.pop();
+  for (const section of renderedSections) {
+    const extra = sections.get(section.heading);
+    if (!extra) continue;
+    while (extra[0] === '') extra.shift();
+    // A paragraph must not glue onto the rendered list above it — keep one blank line between.
+    if (extra.length && !/^[-*]\s/.test(extra[0]!.trim()) && section.lines.length) section.lines.push('');
+    section.lines.push(...extra);
+    folded += extra.length;
+    sections.delete(section.heading);
+  }
+  const parts = [title!, ''];
+  while (paragraphs.at(-1) === '') paragraphs.pop();
+  if (paragraphs.length) parts.push(paragraphs.join('\n'), '');
+  for (const section of renderedSections) parts.push(section.heading, '', ...section.lines, '');
+  for (const [name, lines] of sections) { parts.push(name, '', ...lines, ''); folded += Math.max(lines.filter(Boolean).length, 1); }
+  return { text: `${parts.join('\n').trimEnd()}\n`, folded };
+}

package/scripts/release-loop/tui-node-checks.ts

@@ -0,0 +1,29 @@
+// Release-loop ⑦ — judge an isolated TUI session from its screen text. Pure: no PTY.
+// The screens are what `scripts/tui-sim.ts text <id>` prints.
+
+export interface TuiScreens {
+  readyMs: number | null; // null = never became ready
+  first: string;          // screen right after boot
+  help: string;           // after sending `/help`
+  afterEsc: string;       // after pressing Esc
+}
+
+export interface TuiCheck { id: string; pass: boolean; detail: string }
+
+const ERROR_TEXT = /\b(TypeError|ReferenceError|SyntaxError|Unhandled|panic|Segmentation fault)\b|Error: /;
+
+export function tuiChecks(s: TuiScreens, readyLimitMs = 60_000): TuiCheck[] {
+  const all = [s.first, s.help, s.afterEsc].join('\n');
+  return [
+    { id: 'boot', pass: s.readyMs !== null && s.readyMs <= readyLimitMs, detail: s.readyMs === null ? 'never ready' : `ready in ${s.readyMs}ms` },
+    { id: 'prompt', pass: s.first.includes('❯'), detail: 'input line (❯) on the first screen' },
+    { id: 'status-bar', pass: /│.*ctx \d+/.test(s.first), detail: 'status bar with model and ctx' },
+    { id: 'help-opens', pass: s.help.includes('help') && s.help.includes('Commands') && s.help.includes('/help'), detail: '/help shows the help overlay' },
+    { id: 'help-closes', pass: !s.afterEsc.includes('Commands') && s.afterEsc.includes('❯'), detail: 'Esc closes the overlay' },
+    { id: 'no-error-text', pass: !ERROR_TEXT.test(all), detail: 'no error text on any screen' },
+  ];
+}
+
+export function tuiVerdict(checks: readonly TuiCheck[]): 'pass' | 'fail' {
+  return checks.every((c) => c.pass) ? 'pass' : 'fail';
+}

package/scripts/release-loop/tui-sim-node.ts

@@ -0,0 +1,113 @@
+#!/usr/bin/env bun
+/**
+ * Release-loop ⑦ — boot the TUI of one commit in isolation and check it responds.
+ *
+ *   bun scripts/release-loop/tui-sim-node.ts --commit <sha> [--json]
+ *
+ * Steps: temp worktree at <sha> → `scripts/tui-sim.ts start --test` (that commit's code, the
+ * repo's `.elanous-test` config so no first-run wizard) → first screen → `/help` → Esc → dump PNG
+ * → stop, clean, remove worktree. Never touches the production daemon or ~/.elanous.
+ * macOS only (the TUI PTY checks run on the mbp). One retry of the whole session → «flaky».
+ *
+ * Exit: 0 = pass or flaky · 1 = fail · 2 = could not run (not macOS, worktree).
+ */
+import { spawn, spawnSync } from 'node:child_process';
+import { copyFileSync, existsSync, mkdtempSync, openSync, symlinkSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { basename, join, resolve } from 'node:path';
+import { tuiChecks, tuiVerdict, type TuiCheck } from './tui-node-checks';
+
+const log = (msg: string) => process.stderr.write(`[tui-node] ${msg}\n`);
+const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
+
+function run(args: string[], cwd: string, timeoutMs = 60_000) {
+  const r = spawnSync('bun', args, { cwd, encoding: 'utf8', timeout: timeoutMs, maxBuffer: 16 * 1024 * 1024 });
+  return { rc: r.status ?? -1, stdout: r.stdout ?? '', stderr: r.stderr ?? '' };
+}
+
+async function session(worktree: string, stateDir: string, id: string, work: string): Promise<{ checks: TuiCheck[]; png?: string }> {
+  const sim = (...a: string[]) => run(['scripts/tui-sim.ts', ...a], worktree, 60_000);
+  const startLog = join(work, `${id}.log`);
+  const child = spawn('bun', ['scripts/tui-sim.ts', 'start', '--id', id, '--test', '--state-dir', stateDir, '--boot', '10'], {
+    cwd: worktree, detached: true, stdio: ['ignore', openSync(startLog, 'a'), openSync(startLog, 'a')],
+  });
+  child.unref();
+  const t0 = Date.now();
+  let readyMs: number | null = null;
+  try {
+    while (Date.now() - t0 < 90_000) {
+      if (/"ready": true/.test(sim('status', id).stdout)) { readyMs = Date.now() - t0; break; }
+      await sleep(2000);
+    }
+    const text = () => sim('text', id).stdout;
+    const first = readyMs === null ? '' : text();
+    let help = '';
+    let afterEsc = '';
+    if (readyMs !== null) {
+      sim('send', id, '/help');
+      await sleep(3000);
+      help = text();
+      sim('key', id, 'esc');
+      await sleep(1500);
+      afterEsc = text();
+    }
+    const dump = readyMs === null ? '' : sim('dump', id, 'release-check').stderr;
+    const inTree = /files: .*?(\S+\.png)/.exec(dump)?.[1];
+    // The worktree is removed at the end — keep the screen next to it, in the temp work dir.
+    let png: string | undefined;
+    if (inTree && existsSync(inTree)) { png = join(work, basename(inTree)); copyFileSync(inTree, png); }
+    return { checks: tuiChecks({ readyMs, first, help, afterEsc }), png };
+  } finally {
+    sim('stop', id);
+    await sleep(3000);
+    sim('clean', id);
+  }
+}
+
+async function main(): Promise<number> {
+  const argv = process.argv.slice(2);
+  const commit = argv[argv.indexOf('--commit') + 1] ?? '';
+  const json = argv.includes('--json');
+  if (argv.indexOf('--commit') < 0 || !/^[0-9a-f]{7,40}$/i.test(commit)) { log('--commit <sha> is required'); return 2; }
+  if (process.platform !== 'darwin') { log('macOS only — this node runs on the mbp'); return 2; }
+
+  const repo = resolve('.');
+  const stateDir = join(repo, '.elanous-test');
+  const work = mkdtempSync(join(tmpdir(), 'tui-node-'));
+  const worktree = join(work, 'tree');
+  let attempts: Array<{ checks: TuiCheck[]; png?: string }> = [];
+  let failure: string | undefined;
+  try {
+    const add = spawnSync('git', ['worktree', 'add', '--detach', worktree, commit], { cwd: repo, encoding: 'utf8' });
+    if (add.status !== 0) throw new Error(`worktree add failed: ${(add.stderr ?? '').trim()}`);
+    symlinkSync(join(repo, 'node_modules'), join(worktree, 'node_modules'));
+    if (!existsSync(join(stateDir, 'config.json'))) log(`⚠ ${stateDir}/config.json missing — the TUI may open the first-run wizard`);
+    const id = `rl-${commit.slice(0, 8)}-${Date.now().toString(36)}`;
+    log(`session 1 (${id})`);
+    attempts.push(await session(worktree, stateDir, id, work));
+    if (tuiVerdict(attempts[0]!.checks) === 'fail') {
+      log('session 2 (retry)');
+      attempts.push(await session(worktree, stateDir, `${id}-r`, work));
+    }
+  } catch (e) {
+    failure = e instanceof Error ? e.message : String(e);
+    log(`could not run: ${failure}`);
+    attempts = [];
+  } finally {
+    spawnSync('git', ['worktree', 'remove', '--force', worktree], { cwd: repo });
+  }
+
+  const last = attempts.at(-1);
+  const verdict = !last ? 'error' : tuiVerdict(last.checks) === 'fail' ? 'fail' : attempts.length > 1 ? 'flaky' : 'pass';
+  const out = { verdict, commit, attempts: attempts.length, checks: last?.checks ?? [], png: last?.png, ...(failure ? { error: failure } : {}) };
+  if (json) console.log(JSON.stringify(out));
+  else {
+    console.log(`tui-node: ${verdict} · ${commit.slice(0, 10)} · attempts ${attempts.length}`);
+    for (const c of out.checks) console.log(`  ${c.pass ? '✓' : '✗'} ${c.id} — ${c.detail}`);
+    if (out.png) console.log(`  screen: ${out.png}`);
+    if (failure) console.log(`  error: ${failure}`);
+  }
+  return verdict === 'error' ? 2 : verdict === 'fail' ? 1 : 0;
+}
+
+process.exit(await main());

package/scripts/release-loop/upgrade-node.ts

@@ -0,0 +1,25 @@
+#!/usr/bin/env bun
+import { existsSync } from 'node:fs';
+import { errorResult, finishNode, nodeOutput, readGraphContext, runCommand, type CommandRunner, type NodeOutcome } from './node-verdict.js';
+
+export function runUpgrade(run: CommandRunner = runCommand) {
+  const context = readGraphContext();
+  if (context.outputs.prepare?.outcome !== 'ok') throw new Error('prepare did not pass');
+  if (nodeOutput(context, 'prepare', 'commit') !== nodeOutput(context, 'version-release', 'commit')) throw new Error('prepare commit differs from release commit');
+  const candidate = nodeOutput(context, 'prepare', 'candidate');
+  if (!existsSync(candidate)) throw new Error(`candidate missing: ${candidate}`);
+  const output = run('bash', ['scripts/release-upgrade-check.sh', '--from', context.input.previousVersion, '--candidate', candidate]);
+  if (output.stderr) process.stderr.write(output.stderr);
+  const verdicts = output.stdout.split('\n').filter((line) => /\[upgrade\] verdict\b/.test(line));
+  const passed = verdicts.length === 2 && verdicts.some((line) => /^ubuntu:24\.04\s+\[upgrade\] verdict ok\s*$/.test(line))
+    && verdicts.some((line) => /^debian:12\s+\[upgrade\] verdict ok\s*$/.test(line));
+  const outcome: NodeOutcome = output.status === 0 && passed ? 'ok' : verdicts.length === 0 || output.status === null || output.status === 2 ? 'error' : 'fail';
+  return { outcome, verdict: outcome === 'ok' ? 'pass' as const : 'fail' as const,
+    summary: outcome === 'ok' ? `upgrade ${context.input.previousVersion} → ${context.input.version} · ${verdicts.length} images` : `upgrade failed (rc=${output.status}): ${output.stdout.trim().split('\n').at(-1) || output.stderr.trim() || 'no upgrade verdict'}` };
+}
+
+if (import.meta.main) {
+  let version = '';
+  try { version = readGraphContext().input.version; process.exitCode = finishNode('upgrade', version, runUpgrade()); }
+  catch (error) { process.exitCode = finishNode('upgrade', version, errorResult(error)); }
+}

package/scripts/release-loop/verify-node.ts

@@ -0,0 +1,21 @@
+#!/usr/bin/env bun
+import { errorResult, finishNode, lastResult, nodeOutput, readGraphContext, runCommand, type CommandRunner } from './node-verdict.js';
+
+export function runVerify(run: CommandRunner = runCommand) {
+  const context = readGraphContext();
+  if (context.outputs['docs-land']?.outcome !== 'ok') throw new Error('docs must land and deploy before verify');
+  if (nodeOutput(context, 'publish', 'tag') !== `v${context.input.version}`) throw new Error('published tag/version mismatch');
+  const output = run('bun', ['bin/elanous.mjs', 'release', 'verify', '--version', context.input.version, '--json']);
+  if (output.stderr) process.stderr.write(output.stderr);
+  const result = lastResult(output);
+  const passed = output.status === 0 && result?.ok === true && result.notesPage === 'ok';
+  if (output.status === null || output.status === 2 || !result) throw new Error(`release verify incomplete: ${output.stderr.trim()}`);
+  return { outcome: passed ? 'ok' as const : 'fail' as const, verdict: passed ? 'pass' as const : 'fail' as const,
+    summary: passed ? `verify v${context.input.version} · notes page ok` : `verify failed: ${result?.error ?? result?.notesPage ?? output.stderr.trim()}` };
+}
+
+if (import.meta.main) {
+  let version = '';
+  try { version = readGraphContext().input.version; process.exitCode = finishNode('verify', version, runVerify()); }
+  catch (error) { process.exitCode = finishNode('verify', version, errorResult(error)); }
+}

package/scripts/release-loop/version-node.ts

@@ -0,0 +1,147 @@
+#!/usr/bin/env bun
+import { spawnSync } from 'node:child_process';
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { emitNodeResult } from './node-verdict.js';
+import { debug } from '../../src/debug/log.js';
+
+type Kind = 'release' | 'dev-bump';
+type Output = { outcome: 'ok' | 'error'; kind: Kind | null; version: string | null; commit: string | null; pr: number | null; worktree?: string; error?: string };
+
+export function nextDevVersion(version: string): string {
+  const match = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.exec(version);
+  if (!match) throw new Error(`invalid release version: ${version}`);
+  return `${match[1]}.${match[2]}.${BigInt(match[3]!) + 1n}-dev.0`;
+}
+
+function run(command: string, args: string[], cwd: string): string {
+  const result = spawnSync(command, args, { cwd, encoding: 'utf8', maxBuffer: 16 * 1024 * 1024 });
+  if (result.status !== 0 || result.error) {
+    throw new Error(`${command} ${args[0]} failed (rc=${result.status ?? 'unknown'}): ${(result.stderr || result.error || result.stdout || 'no output').toString().trim()}`);
+  }
+  return result.stdout;
+}
+
+// git-spawn-allow: this isolated release checkout must read origin/main and create/remove its own worktree.
+function git(repo: string, ...args: string[]): string {
+  return run('git', args, repo).trim();
+}
+
+// Retry only failures that can clear without changing the release checkout.
+const TRANSIENT_FETCH_ERROR = /cannot lock ref|unable to create .*\.lock|another git process|could not resolve host|failed to connect|connection (?:timed out|reset)|network is unreachable|remote end hung up|early EOF|permission denied \(publickey\)|authentication failed|could not read Username/i;
+
+function fetchMain(repo: string): void {
+  for (let attempt = 1; attempt <= 3; attempt++) {
+    const result = spawnSync('git', ['fetch', 'origin', 'main'], { cwd: repo, encoding: 'utf8', maxBuffer: 16 * 1024 * 1024 });
+    if (result.status === 0 && !result.error) return;
+    const stderr = (result.stderr || result.error?.message || result.stdout || 'no output').trim();
+    if (attempt < 3 && TRANSIENT_FETCH_ERROR.test(stderr)) {
+      Bun.sleepSync(100 * 2 ** (attempt - 1));
+      continue;
+    }
+    // Report the URL's transport, never its value (or the socket path).
+    const remote = spawnSync('git', ['remote', 'get-url', 'origin'], { cwd: repo, encoding: 'utf8' });
+    const url = remote.status === 0 ? remote.stdout.trim() : '';
+    const remoteKind = /^(?:ssh:\/\/|[^\s@]+@[^\s:]+:)/i.test(url) ? 'ssh'
+      : /^https:\/\//i.test(url) ? 'https' : 'unknown';
+    throw new Error(`git fetch origin main failed after ${attempt} attempt(s) (rc=${result.status ?? 'unknown'}): ${stderr} [remote URL kind: ${remoteKind}; SSH_AUTH_SOCK present: ${Boolean(process.env.SSH_AUTH_SOCK)}]`);
+  }
+}
+
+function versionAt(repo: string): string {
+  const pkg = JSON.parse(git(repo, 'show', 'origin/main:package.json')) as { version?: unknown };
+  if (typeof pkg.version !== 'string') throw new Error('origin/main package.json has no version');
+  return pkg.version;
+}
+
+function landing(repo: string, kind: Kind, releaseVersion: string): Output {
+  const target = kind === 'release' ? releaseVersion : nextDevVersion(releaseVersion);
+  const source = kind === 'release' ? `${releaseVersion}-dev.N` : releaseVersion;
+  fetchMain(repo);
+  const current = versionAt(repo);
+  const before = git(repo, 'rev-parse', 'origin/main');
+  if (current === target) return { outcome: 'ok', kind, version: target, commit: before, pr: null };
+  if (kind === 'release' ? !new RegExp(`^${releaseVersion.replaceAll('.', '\\.')}\\-dev\\.(0|[1-9][0-9]*)$`).test(current) : current !== source) {
+    throw new Error(`origin/main version ${current} is not ${source} (target ${target})`);
+  }
+
+  const temp = mkdtempSync(join(tmpdir(), 'release-version-node-'));
+  const worktree = join(temp, 'tree');
+  try {
+    git(repo, 'worktree', 'add', '-b', `release-version-${kind}-${Date.now()}-${process.pid}`, worktree, 'origin/main');
+    const path = join(worktree, 'package.json');
+    const text = readFileSync(path, 'utf8');
+    const old = `"version": "${current}"`;
+    if (!text.includes(old)) throw new Error(`package.json version field not found: ${current}`);
+    writeFileSync(path, text.replace(old, `"version": "${target}"`));
+    const lockPath = join(worktree, 'bun.lock');
+    const lock = readFileSync(lockPath, 'utf8');
+    const root = /"workspaces"\s*:\s*\{\s*""\s*:\s*\{([\s\S]*?)(?=\s*"(?:dependencies|devDependencies|optionalDependencies)"\s*:)/.exec(lock);
+    if (!root) throw new Error('bun.lock root workspace not found');
+    const lockedVersion = /"version"\s*:\s*"([^"]+)"/.exec(root[1]!);
+    if (lockedVersion) {
+      if (lockedVersion[1] !== current) throw new Error(`bun.lock root version ${lockedVersion[1]} is not ${current}`);
+      writeFileSync(lockPath, lock.replace(root[0], root[0].replace(lockedVersion[0], `"version": "${target}"`)));
+    }
+    run('bun', ['install', '--frozen-lockfile'], worktree);
+    const title = kind === 'release' ? `release: ${target}` : `version: ${target}`;
+    const land = spawnSync('bun', ['bin/elanous.mjs', 'pr', 'land', '--commit-message', title, '--title', title, '--body', `Set package.json version to ${target}.`], {
+      cwd: worktree, encoding: 'utf8', maxBuffer: 16 * 1024 * 1024,
+    });
+    const transcript = `${land.stdout ?? ''}\n${land.stderr ?? ''}`;
+    if (land.status !== 0 || land.error || !transcript.includes('✓ merge:')) {
+      throw new Error(`pr land failed (rc=${land.status ?? 'unknown'}; merge marker ${transcript.includes('✓ merge:') ? 'present' : 'missing'}): ${transcript.trim() || land.error || 'no output'}`);
+    }
+    const mergeLine = transcript.split('\n').find((line) => line.includes('✓ merge:')) ?? '';
+    const pr = /(?:#|\/pull\/)(\d+)\b/.exec(mergeLine);
+    fetchMain(repo);
+    const commit = git(repo, 'rev-parse', 'origin/main');
+    if (versionAt(repo) !== target || commit === before) throw new Error(`origin/main did not advance to ${target} after merge`);
+    const output: Output = { outcome: 'ok', kind, version: target, commit, pr: pr ? Number(pr[1]) : null };
+    git(repo, 'worktree', 'remove', '--force', worktree);
+    rmSync(temp, { recursive: true, force: true });
+    return output;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`${message} [worktree: ${worktree}]`);
+  }
+}
+
+function main(args: string[] = process.argv.slice(2), repo = process.cwd()): Output {
+  let kind: Kind | null = null;
+  let version: string | null = null;
+  try {
+    if (args[0] !== 'release' && args[0] !== 'dev-bump') throw new Error('usage: version-node.ts <release|dev-bump> [--version <v>] --json');
+    kind = args[0];
+    for (let i = 1; i < args.length; i++) {
+      if (args[i] === '--json') continue;
+      if (args[i] === '--version' && args[i + 1]) { version = args[++i]!; continue; }
+      throw new Error(`unknown or incomplete argument: ${args[i]}`);
+    }
+    if (!version) {
+      if (process.env.ELANOUS_GRAPH_CONTEXT) {
+        const location = process.env.ELANOUS_GRAPH_CONTEXT;
+        const context = JSON.parse(location.trimStart().startsWith('{') ? location : readFileSync(location, 'utf8')) as { input?: { version?: unknown } };
+        if (typeof context.input?.version === 'string') version = context.input.version;
+      }
+    }
+    if (!version) throw new Error('version required (--version or ELANOUS_GRAPH_CONTEXT.input.version)');
+    nextDevVersion(version);
+    return landing(resolve(repo), kind, version);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const worktree = /\[worktree: ([^\]]+)\]$/.exec(message)?.[1];
+    const outputVersion = kind === 'dev-bump' && version && /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.test(version)
+      ? nextDevVersion(version) : version;
+    return { outcome: 'error', kind, version: outputVersion,
+      commit: null, pr: null, ...(worktree ? { worktree } : {}), error: message };
+  }
+}
+
+if (import.meta.main) {
+  const output = main();
+  debug.log(`release-loop.version-${output.kind ?? 'unknown'}`, 'result', { version: output.version, outcome: output.outcome });
+  emitNodeResult({ ...output, verdict: output.outcome === 'ok' ? 'pass' : 'fail', summary: output.outcome === 'ok' ? `${output.kind} ${output.version} · ${output.commit}` : `${output.kind ?? 'version'}: ${output.error ?? 'failed'}` });
+  if (output.outcome === 'error') process.exitCode = 1;
+}

package/scripts/release-upgrade-check.sh

@@ -0,0 +1,53 @@
+#!/usr/bin/env bash
+# 업데이트(마이그레이션) 검증 — «이전 공개판을 쓰던 사용자»가 새 판으로 올려도 상태가 살아남는가 (대표 2026-09-27 · 릴리스 절차 한 칸).
+#   빈 배포판 컨테이너 → 이전 공개판 설치(공개 설치기 · ELANOUS_VERSION=<from>) → setup · 기억 · 설정 · 로그를 만든다
+#   → 후보 묶음으로 설치기를 다시 돈다(사용자가 업데이트하는 길) → 새 판 · 기억 · 설정 키 · 상태 파일 · 로그 · doctor 를 잰다.
+#
+#   bash scripts/release-upgrade-check.sh --from 0.2.2 [--candidate <elanous.tgz>] [BASE…]
+#     --candidate 없으면 이 체크아웃을 `bun pm pack` 한다(⚠️ 내부본 — 발행 전엔 prepare 산출의 공개 묶음을 준다).
+#     BASE 기본 = ubuntu:24.04 debian:12
+# ⛔ 컨테이너는 systemd·재부팅을 못 잰다(데몬 상주 마이그레이션은 베어 VM 몫). 판정은 줄마다 `[upgrade] <칸> ok|FAIL`.
+set -u
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd -P)"
+FROM=""; CAND=""; BASES=()
+while [ "$#" -gt 0 ]; do
+  case "$1" in
+    --from) FROM="${2:-}"; shift 2 ;;
+    --candidate) CAND="${2:-}"; shift 2 ;;
+    -h|--help) sed -n '2,11p' "$0"; exit 0 ;;
+    -*) echo "⛔ unknown option: $1" >&2; exit 2 ;;
+    *) BASES+=("$1"); shift ;;
+  esac
+done
+[ -n "$FROM" ] || { echo "⛔ --from <previous public version> is required" >&2; exit 2; }
+[ "${#BASES[@]}" -gt 0 ] || BASES=(ubuntu:24.04 debian:12)
+command -v docker >/dev/null 2>&1 || { echo "⛔ docker not on PATH" >&2; exit 127; }
+docker info >/dev/null 2>&1 || { echo "⛔ docker engine is not running" >&2; exit 1; }
+
+OUT="${ELANOUS_UPGRADE_CHECK_OUT:-$(mktemp -d "${TMPDIR:-/tmp}/elanous-upgrade-check.XXXXXX")}"
+CTX="$OUT/ctx"; mkdir -p "$CTX"
+if [ -n "$CAND" ]; then
+  [ -f "$CAND" ] || { echo "⛔ candidate not found: $CAND" >&2; exit 2; }
+  cp "$CAND" "$CTX/elanous.tgz"
+else
+  echo "▶ packing this checkout (internal) → $CTX" >&2
+  (cd "$ROOT" && bun pm pack --destination "$CTX" >/dev/null 2>&1) || { echo "⛔ bun pm pack failed" >&2; exit 1; }
+  mv "$(ls "$CTX"/*.tgz | head -1)" "$CTX/elanous.tgz"
+fi
+cp "$ROOT/scripts/install.sh" "$ROOT/docker/upgrade/Dockerfile" "$ROOT/docker/upgrade/upgrade-probe.sh" "$CTX/"
+
+rc=0
+for base in "${BASES[@]}"; do
+  tag="$(printf '%s' "$base" | tr ':/' '--')"
+  if docker build -t "elanous-upgrade:$tag" --build-arg BASE="$base" "$CTX" > "$OUT/build-$tag.log" 2>&1; then
+    docker run --rm -e FROM="$FROM" "elanous-upgrade:$tag" > "$OUT/run-$tag.log" 2>&1
+    grep '^\[upgrade\] .* FAIL' "$OUT/run-$tag.log" | sed "s/^/$base  /"
+    verdict="$(grep '^\[upgrade\] verdict' "$OUT/run-$tag.log" | tail -1)"
+    echo "$base  ${verdict:-[upgrade] no verdict — $OUT/run-$tag.log}"
+    case "$verdict" in *"verdict ok"*) ;; *) rc=1 ;; esac
+  else
+    echo "$base  build FAILED — $OUT/build-$tag.log"; rc=1
+  fi
+done
+echo "logs: $OUT" >&2
+exit $rc