elanous 0.2.42 → 0.2.44

package/scripts/release-loop/gate-progress-sim.ts

@@ -0,0 +1,73 @@
+/**
+ * Deterministic E4 fixture: emit a fixed fake-Pod gate-progress sequence through
+ * the real standalone debug-log sink. It never starts a gate, Pod, SSH, or kubectl.
+ * Run only with ELANOUS_STATE_DIR pointing at an isolated directory (config
+ * follows the resolved state root), then inspect it with `eln logs --category release-loop.gate`.
+ */
+import { randomUUID } from 'node:crypto';
+import { mkdirSync, realpathSync } from 'node:fs';
+import { basename, dirname, isAbsolute, join, relative, resolve } from 'node:path';
+import { debug } from '../../src/debug/log.js';
+import { effectiveInstanceRoot, prodInstanceRoot } from '../../src/instance/resolve.js';
+import { getElanousConfigDir } from '../../src/elanous-config-dir.js';
+import { registerStandaloneLogSink } from '../../src/domains/standalone-log-sink.js';
+
+const scenario = [
+  { completed: 0, total: 3, elapsedMs: 0 },
+  { completed: 1, total: 3, elapsedMs: 1_000 },
+  { completed: 3, total: 3, elapsedMs: 3_000 },
+] as const;
+
+function isInside(path: string, root: string): boolean {
+  const comparablePath = process.platform === 'darwin' ? path.toLocaleLowerCase('en-US') : path;
+  const comparableRoot = process.platform === 'darwin' ? root.toLocaleLowerCase('en-US') : root;
+  const rel = relative(comparableRoot, comparablePath);
+  return rel === '' || (!rel.startsWith('..') && !isAbsolute(rel));
+}
+
+function canonicalRoot(path: string): string {
+  let cursor = resolve(path);
+  const suffix: string[] = [];
+  for (;;) {
+    try { return join(realpathSync(cursor), ...suffix.reverse()); }
+    catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
+      const parent = dirname(cursor);
+      if (parent === cursor) throw error;
+      suffix.push(basename(cursor));
+      cursor = parent;
+    }
+  }
+}
+
+async function emitGateProgressSimulation(runId?: string): Promise<void> {
+  const stateRoot = effectiveInstanceRoot();
+  const configRoot = getElanousConfigDir();
+  const actualProdRoot = canonicalRoot(prodInstanceRoot());
+  const actualStateRoot = canonicalRoot(stateRoot);
+  const actualConfigRoot = canonicalRoot(configRoot);
+  const overlapsProductionRoot = [actualStateRoot, actualConfigRoot].some((root) =>
+    isInside(root, actualProdRoot) || isInside(actualProdRoot, root));
+  if (overlapsProductionRoot) {
+    throw new Error('refusing to emit mock gate events into the production instance; set ELANOUS_STATE_DIR to an isolated path');
+  }
+  // Logs are written below effectiveInstanceRoot() by logsDbPath(); check both resolver roots before creating either.
+  mkdirSync(stateRoot, { recursive: true });
+  mkdirSync(configRoot, { recursive: true });
+  if (!await registerStandaloneLogSink('release-loop')) {
+    throw new Error('could not register the isolated standalone logs.db sink');
+  }
+  const effectiveRunId = runId?.trim() || randomUUID();
+  for (const step of scenario) {
+    debug.log('release-loop.gate', 'progress', {
+      runId: effectiveRunId,
+      scenario: 'e4-fixed-pod-shards',
+      executor: 'pod',
+      host: 'mock-pod-host-1',
+      ...step,
+    });
+  }
+  process.stdout.write(`${JSON.stringify({ runId: effectiveRunId, scenario: 'e4-fixed-pod-shards', events: scenario.length, stateRoot: actualStateRoot })}\n`);
+}
+
+if (import.meta.main) await emitGateProgressSimulation(process.argv[2] || undefined);

package/scripts/release-loop/gate-traffic-mode.ts

@@ -1,11 +1,18 @@
 import { randomUUID } from 'node:crypto';
-import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, rmdirSync, statSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, rmdirSync, statSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { join } from 'node:path';
+import { basename, dirname, join } from 'node:path';
 import { debug } from '../../src/debug/log.js';
 
-type TrafficBoard = Record<string, unknown> & { global: string };
+type TrafficBoard = Record<string, unknown> & { global: string; seats?: Record<string, Record<string, unknown>> };
 type PatchResult = { changed: true; previous: string; warning?: string } | { changed: false; current: string };
+type PwaSnapshot = { reason: unknown; hadReason: boolean; updatedAt: unknown; hadUpdatedAt: boolean; activeUpdatedAt: string;
+  heavyLocalBan: unknown; hadHeavyLocalBan: boolean;
+  perCycle: Record<string, { value: unknown; hadValue: boolean }> };
+type PwaPatchResult = { changed: true; previous: PwaSnapshot; warning?: string };
+const RELEASE_SEATS = ['OP', 'TC', 'MK', 'UX'] as const;
+const PWA_PER_CYCLE = 3;
+const MAX_PWA_TRAFFIC_BACKUPS_PER_KIND = 10;
 
 const defaultTrafficPath = () => join(homedir(), 'elanous-hq', 'seat-state', 'OP', 'traffic.json');
 const trafficPath = (env: NodeJS.ProcessEnv) => env.ELANOUS_TRAFFIC_SIGNAL || defaultTrafficPath();
@@ -21,6 +28,17 @@ function releaseGateContext(env: NodeJS.ProcessEnv): boolean {
   }
 }
 
+function releasePwaContext(env: NodeJS.ProcessEnv): boolean {
+  const source = env.ELANOUS_GRAPH_CONTEXT;
+  if (!source) return false;
+  try {
+    const raw = JSON.parse(source.trimStart().startsWith('{') ? source : readFileSync(source, 'utf8')) as Record<string, unknown>;
+    return raw.graphId === 'release-loop' && raw.nodeId === 'pwa';
+  } catch {
+    return false;
+  }
+}
+
 function withTrafficLock<T>(path: string, action: () => T): T {
   const lock = `${path}.lock.d`;
   const deadline = Date.now() + 10_000;
@@ -86,6 +104,136 @@ function patchGlobal(path: string, next: string, reason: string, onlyIf?: string
   });
 }
 
+function writeTrafficBoard(path: string, after: TrafficBoard, suffix: string): void {
+  const at = new Date();
+  const stamp = [at.getMonth() + 1, at.getDate(), at.getHours(), at.getMinutes(), at.getSeconds()].map(value => String(value).padStart(2, '0')).join('');
+  writeFileSync(`${path}.bak-${stamp}-${randomUUID().slice(0, 8)}-${suffix}`, readFileSync(path));
+  const temp = `${path}.tmp.${process.pid}.${randomUUID()}`;
+  try {
+    writeFileSync(temp, `${JSON.stringify(after, null, 2)}\n`, { mode: statSync(path).mode & 0o777 });
+    renameSync(temp, path);
+  } finally { rmSync(temp, { force: true }); }
+  // Re-read after the atomic rename so a malformed write is visible to the caller.
+  JSON.parse(readFileSync(path, 'utf8')) as TrafficBoard;
+  if (suffix.startsWith('release-pwa-')) {
+    try { pruneTrafficBackups(path, suffix); }
+    catch (error) { debug.log('release-loop.pwa', 'traffic backup pruning failed', { path, suffix, error: String(error) }, { level: 'warn' }); }
+  }
+}
+
+function pruneTrafficBackups(path: string, suffix: string): void {
+  const directory = dirname(path);
+  const prefix = `${basename(path)}.bak-`;
+  const backups = readdirSync(directory)
+    .filter(name => name.startsWith(prefix) && name.endsWith(`-${suffix}`))
+    .map(name => ({ path: join(directory, name), modifiedAt: statSync(join(directory, name)).mtimeMs }))
+    .sort((a, b) => a.modifiedAt - b.modifiedAt);
+  for (const backup of backups.slice(0, Math.max(0, backups.length - MAX_PWA_TRAFFIC_BACKUPS_PER_KIND))) {
+    rmSync(backup.path, { force: true });
+  }
+}
+
+function patchPwaTraffic(path: string): PwaPatchResult {
+  return withTrafficLock(path, () => {
+    if (!existsSync(path)) throw new Error(`traffic board missing: ${path}`);
+    const board = JSON.parse(readFileSync(path, 'utf8')) as TrafficBoard;
+    if (!board || typeof board !== 'object' || Array.isArray(board) || typeof board.global !== 'string'
+      || !board.seats || typeof board.seats !== 'object' || Array.isArray(board.seats)
+      || !RELEASE_SEATS.every(seat => board.seats![seat] && typeof board.seats![seat] === 'object' && !Array.isArray(board.seats![seat]))) {
+      throw new Error(`invalid traffic board for PWA policy: ${path}`);
+    }
+    const activeUpdatedAt = new Date().toISOString();
+    const previous: PwaSnapshot = {
+      hadReason: Object.hasOwn(board, 'reason'), reason: board.reason,
+      hadUpdatedAt: Object.hasOwn(board, 'updatedAt'), updatedAt: board.updatedAt, activeUpdatedAt,
+      hadHeavyLocalBan: Object.hasOwn(board, 'heavyLocalBan'), heavyLocalBan: board.heavyLocalBan,
+      perCycle: Object.fromEntries(RELEASE_SEATS.map(seat => [seat, {
+        hadValue: Object.hasOwn(board.seats![seat]!, 'perCycle'), value: board.seats![seat]!.perCycle,
+      }])),
+    };
+    const updated: TrafficBoard = {
+      ...board,
+      ...(board.heavyLocalBan === true ? {} : { reason: 'release PWA node running (heavy-local banned)' }),
+      heavyLocalBan: true,
+      seats: Object.fromEntries(Object.entries(board.seats).map(([seat, value]) => [seat,
+        RELEASE_SEATS.includes(seat as typeof RELEASE_SEATS[number]) ? { ...value, perCycle: PWA_PER_CYCLE } : value])),
+      updatedAt: activeUpdatedAt,
+    };
+    writeTrafficBoard(path, updated, 'release-pwa-policy');
+    return { changed: true, previous };
+  });
+}
+
+function restorePwaTraffic(path: string, previous: PwaSnapshot): { restored: boolean; reason?: string } {
+  return withTrafficLock(path, () => {
+    const board = JSON.parse(readFileSync(path, 'utf8')) as TrafficBoard;
+    if (!board || typeof board !== 'object' || Array.isArray(board) || !board.seats || typeof board.seats !== 'object') {
+      throw new Error(`invalid traffic board while restoring PWA policy: ${path}`);
+    }
+    // If another writer removed/replaced our marker, that writer owns the current policy.
+    if (board.heavyLocalBan !== true) return { restored: false, reason: 'heavyLocalBan-changed' };
+    const seats = { ...board.seats };
+    for (const seat of RELEASE_SEATS) {
+      const current = seats[seat];
+      const snapshot = previous.perCycle[seat];
+      if (!current || current.perCycle !== PWA_PER_CYCLE) continue;
+      const restored = { ...current };
+      if (snapshot?.hadValue) restored.perCycle = snapshot.value;
+      else delete restored.perCycle;
+      seats[seat] = restored;
+    }
+    const updated: TrafficBoard = { ...board, seats };
+    if (previous.hadHeavyLocalBan) updated.heavyLocalBan = previous.heavyLocalBan;
+    else delete updated.heavyLocalBan;
+    if (updated.reason === 'release PWA node running (heavy-local banned)') {
+      if (previous.hadReason) updated.reason = previous.reason;
+      else delete updated.reason;
+    }
+    if (board.updatedAt === previous.activeUpdatedAt) {
+      if (previous.hadUpdatedAt) updated.updatedAt = previous.updatedAt;
+      else delete updated.updatedAt;
+    }
+    writeTrafficBoard(path, updated, 'release-pwa-restore');
+    return { restored: true };
+  });
+}
+
+/** Apply the release PWA node's temporary half-traffic and heavy-local marker, restoring on every exit. */
+export async function runWithReleasePwaTraffic<T>(env: NodeJS.ProcessEnv, run: () => Promise<T>): Promise<T> {
+  if (!releasePwaContext(env)) return run();
+  const path = trafficPath(env);
+  let started: PwaPatchResult;
+  try { started = patchPwaTraffic(path); }
+  catch (error) {
+    debug.log('release-loop.pwa', 'traffic policy set failed', { path, error: String(error) }, { level: 'warn' });
+    throw new Error(`release PWA traffic policy could not be applied: ${String(error)}`, { cause: error });
+  }
+  if (started.warning) debug.log('release-loop.pwa', 'traffic policy verification failed', { path, error: started.warning }, { level: 'warn' });
+  let restoreResult: Promise<void> | undefined;
+  const restoreOnce = () => restoreResult ??= Promise.resolve().then(() => {
+    try {
+      const restored = restorePwaTraffic(path, started.previous);
+      if (!restored.restored) debug.log('release-loop.pwa', 'traffic policy restore skipped', { path, reason: restored.reason }, { level: 'warn' });
+    } catch (error) { debug.log('release-loop.pwa', 'traffic policy restore failed', { path, error: String(error) }, { level: 'warn' }); }
+  });
+  const interrupt = (signal: NodeJS.Signals) => {
+    void restoreOnce().finally(() => {
+      process.removeListener(signal, signal === 'SIGINT' ? onSigint : onSigterm);
+      process.kill(process.pid, signal);
+    });
+  };
+  const onSigint = () => interrupt('SIGINT');
+  const onSigterm = () => interrupt('SIGTERM');
+  process.once('SIGINT', onSigint);
+  process.once('SIGTERM', onSigterm);
+  try { return await run(); }
+  finally {
+    process.removeListener('SIGINT', onSigint);
+    process.removeListener('SIGTERM', onSigterm);
+    await restoreOnce();
+  }
+}
+
 /** Hold dispatcher traffic at gate only for the release-loop's gate node, then restore conditionally. */
 export async function runWithReleaseGateTraffic<T>(env: NodeJS.ProcessEnv, run: () => Promise<T>): Promise<T> {
   if (!releaseGateContext(env)) return run();

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

@@ -3,6 +3,7 @@ import { spawnSync } from 'node:child_process';
 import { isReleaseVersion } from './release-version.js';
 import { readFileSync } from 'node:fs';
 import { debug } from '../../src/debug/log.js';
+import { runWithReleasePwaTraffic } from './gate-traffic-mode.js';
 
 export type NodeOutcome = 'ok' | 'fail' | 'error';
 export type NodeVerdict = 'pass' | 'flaky' | 'fail';
@@ -86,30 +87,42 @@ export function pwaNodeArgs(commit: string, input: Record<string, unknown>): str
 }
 
 // Existing cutoff/PWA/TUI programs have different output conventions; normalize them at the graph boundary.
-if (import.meta.main) {
-  const node = process.argv[2];
+export async function runNodeVerdict(argv: string[], env: NodeJS.ProcessEnv = process.env,
+  runner: CommandRunner = runCommand): Promise<number> {
+  const node = argv[0];
   let version = '';
-  let result: Record<string, unknown> & { outcome: NodeOutcome; verdict: NodeVerdict; summary: string };
-  try {
-    const context = readGraphContext();
-    version = context.input.version;
-    const commit = nodeOutput(context, 'version-release', 'commit');
-    const predecessor = node === 'pwa' ? 'gate' : node === 'tui' ? 'upgrade' : 'version-release';
-    if (context.outputs[predecessor]?.outcome !== 'ok') throw new Error(`${predecessor} did not pass`);
-    const args = node === 'cutoff' ? ['scripts/release-loop/cutoff.ts', '--version', version, '--cutoff', commit, '--baseline', `v${context.input.previousVersion}`, '--json']
-      : node === 'pwa' ? pwaNodeArgs(commit, context.input)
-      : node === 'tui' ? ['scripts/release-loop/tui-sim-node.ts', '--commit', commit, '--json'] : (() => { throw new Error(`unknown node: ${node}`); })();
-    const run = runCommand('bun', args);
-    if (run.stderr) process.stderr.write(run.stderr);
-    const data = lastResult(run);
-    const verdict = data?.verdict;
-    const baseline = data?.baseline as { sha?: string } | undefined;
-    const outcome: NodeOutcome = node === 'cutoff' ? run.status === 0 && data?.version === version && (data?.cutoff as { sha?: string } | undefined)?.sha === commit && typeof baseline?.sha === 'string' ? 'ok' : 'error'
-      : run.status === 0 && (verdict === 'pass' || verdict === 'flaky') ? 'ok' : run.status === 1 ? 'fail' : 'error';
-    if (node === 'cutoff' && outcome === 'ok' && cutoffNotesEmpty(data)) {
-      result = { ...data, outcome: 'fail', verdict: 'fail', summary: 'cutoff notes-empty — 사용자에게 보일 변경 줄이 0이다(release/next.md 와 PR 노트 조각을 확인하라)' };
-    } else result = { ...data, outcome, verdict: outcome === 'ok' ? verdict === 'flaky' ? 'flaky' : 'pass' : 'fail',
-      summary: outcome === 'ok' ? `${node} ${verdict === 'flaky' ? 'flaky' : 'pass'}` : `${node} ${data?.error || run.stderr.trim() || data?.verdict || 'failed'} (rc=${run.status})` };
-  } catch (error) { result = errorResult(error); }
-  process.exitCode = finishNode(node ?? 'unknown', version, result);
+  const execute = async (): Promise<number> => {
+    let result: Record<string, unknown> & { outcome: NodeOutcome; verdict: NodeVerdict; summary: string };
+    try {
+      const context = readGraphContext(env);
+      version = context.input.version;
+      const commit = nodeOutput(context, 'version-release', 'commit');
+      const predecessor = node === 'pwa' ? 'gate' : node === 'tui' ? 'upgrade' : 'version-release';
+      if (context.outputs[predecessor]?.outcome !== 'ok') throw new Error(`${predecessor} did not pass`);
+      const args = node === 'cutoff' ? ['scripts/release-loop/cutoff.ts', '--version', version, '--cutoff', commit, '--baseline', `v${context.input.previousVersion}`, '--json']
+        : node === 'pwa' ? pwaNodeArgs(commit, context.input)
+        : node === 'tui' ? ['scripts/release-loop/tui-sim-node.ts', '--commit', commit, '--json'] : (() => { throw new Error(`unknown node: ${node}`); })();
+      const run = runner('bun', args);
+      if (run.stderr) process.stderr.write(run.stderr);
+      const data = lastResult(run);
+      const verdict = data?.verdict;
+      const baseline = data?.baseline as { sha?: string } | undefined;
+      const outcome: NodeOutcome = node === 'cutoff' ? run.status === 0 && data?.version === version && (data?.cutoff as { sha?: string } | undefined)?.sha === commit && typeof baseline?.sha === 'string' ? 'ok' : 'error'
+        : run.status === 0 && (verdict === 'pass' || verdict === 'flaky') ? 'ok' : run.status === 1 ? 'fail' : 'error';
+      if (node === 'cutoff' && outcome === 'ok' && cutoffNotesEmpty(data)) {
+        result = { ...data, outcome: 'fail', verdict: 'fail', summary: 'cutoff notes-empty — 사용자에게 보일 변경 줄이 0이다(release/next.md 와 PR 노트 조각을 확인하라)' };
+      } else result = { ...data, outcome, verdict: outcome === 'ok' ? verdict === 'flaky' ? 'flaky' : 'pass' : 'fail',
+        summary: outcome === 'ok' ? `${node} ${verdict === 'flaky' ? 'flaky' : 'pass'}` : `${node} ${data?.error || run.stderr.trim() || data?.verdict || 'failed'} (rc=${run.status})` };
+    } catch (error) { result = errorResult(error); }
+    return finishNode(node ?? 'unknown', version, result);
+  };
+
+  if (node !== 'pwa') return execute();
+  try { return await runWithReleasePwaTraffic(env, execute); }
+  catch (error) {
+    try { version = readGraphContext(env).input.version; } catch { /* preserve empty version when context itself is invalid */ }
+    return finishNode(node, version, errorResult(error));
+  }
 }
+
+if (import.meta.main) process.exitCode = await runNodeVerdict(process.argv.slice(2), process.env);

package/scripts/release-loop/notes-repair.ts

@@ -12,6 +12,23 @@ export const REPAIR_MODEL = 'openrouter/z-ai/glm-5.3';
 export type Translator = (line: string, model: string) => Promise<string>;
 export type RepairResult = { text: string; translatedLines: number[]; error?: string };
 
+/** Avoid sending a different provider's configured API key to OpenRouter. */
+export function notesRepairLlmConfig(config: ReturnType<typeof getUserConfig>, model = REPAIR_MODEL) {
+  const isOpenRouterConfig = config.llm.provider === 'openrouter';
+  const llm = { ...config.llm, provider: 'openrouter' as const, model };
+  if (isOpenRouterConfig) {
+    llm.apiKey = config.llm.apiKey;
+    llm.baseUrl = config.llm.baseUrl;
+  } else {
+    delete llm.apiKey;
+    delete llm.baseUrl;
+  }
+  return {
+    ...config,
+    llm,
+  };
+}
+
 function koreanProseLines(text: string): Array<{ index: number; line: string }> {
   let fence: { char: string; length: number } | undefined;
   return text.split(/\r?\n/).flatMap((line, index) => {
@@ -58,7 +75,7 @@ export async function repairKoreanMarkdown(text: string, translate: Translator,
 export const glmTranslator: Translator = async (line, model) => {
   if (model !== REPAIR_MODEL) throw new Error(`unexpected translator model: ${model}`);
   const config = getUserConfig();
-  const llmConfig = { ...config, llm: { ...config.llm, provider: 'openrouter' as const, model } };
+  const llmConfig = notesRepairLlmConfig(config, model);
   const provider = getProviderForConfig(llmConfig, model);
   if (provider.name !== 'openrouter' || !provider.available()) throw new Error('OpenRouter credentials unavailable for openrouter/z-ai/glm-5.3');
   const messages: LLMMessage[] = [