elanous 0.2.8 → 0.2.10

package/scripts/publish-internal-dist.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env bun
 import { createHash } from 'node:crypto';
 import { spawnSync } from 'node:child_process';
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, renameSync, rmSync, statSync, symlinkSync, writeFileSync } from 'node:fs';
+import { existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, renameSync, rmSync, statSync, symlinkSync, writeFileSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { spawnSyncText } from '../src/util/spawn-sync-output.js';
 
@@ -74,11 +74,21 @@ export function publishInternalDist(checkout: string, out: string, keep = 3): {
     } else {
       renameSync(staging, target);
     }
+    const alias = join(download, `v${pkg.version}`);
+    try {
+      if (!lstatSync(alias).isSymbolicLink()) throw new Error(`version alias is not a symlink: ${alias}`);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
+    }
     mkdirSync(join(out, 'latest'), { recursive: true });
     link = join(out, 'latest', `.download-${process.pid}-${Date.now()}`);
     symlinkSync(`../download/${name}`, link, 'dir');
     renameSync(link, join(out, 'latest', 'download'));
     link = undefined;
+    link = join(download, `.alias-${process.pid}-${Date.now()}`);
+    symlinkSync(name, link, 'dir');
+    renameSync(link, alias);
+    link = undefined;
     const versions = readdirSync(download, { withFileTypes: true })
       .filter((entry) => entry.isDirectory() && /^v[0-9A-Za-z][0-9A-Za-z._-]*-[0-9a-f]{12}$/.test(entry.name))
       .map((entry) => ({ name: entry.name, mtime: statSync(join(download, entry.name)).mtimeMs }))

package/scripts/release-loop/cutoff.ts

@@ -4,13 +4,14 @@ import { mkdirSync, realpathSync, writeFileSync } from 'node:fs';
 import { dirname, isAbsolute, join, relative, resolve } from 'node:path';
 import { debug } from '../../src/debug/log.js';
 import { effectiveInstanceRoot } from '../../src/instance/resolve.js';
-import { buildReleaseManifest, type ReleaseLanding } from '../../src/release-loop/manifest.js';
+import { buildReleaseManifest, parseNextMdNotes, type NextMdNote, type ReleaseLanding } from '../../src/release-loop/manifest.js';
 import { readReleaseNotes, releaseNotesDir } from '../../src/release-loop/release-note.js';
 import { queryRunningRuns } from '../../src/self-implement/running-runs.js';
 import { loadFederatedRunLedger } from '../../src/self-implement/run-ledger.js';
 
 const SEED = 'c1cc37478';
 const CLI_DOC = 'release/public/docs/cli.md';
+const NEXT_MD = 'release/next.md';
 
 function git(args: string[], optional = false): string | null {
   const result = spawnSync('git', args, { cwd: process.cwd(), encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 });
@@ -61,6 +62,32 @@ function landingAt(sha: string, title: string): ReleaseLanding {
   };
 }
 
+/**
+ * next.md lines added between the baseline and the cutoff, each tied to the last landing in range whose diff added that
+ * exact line. Lines already in the file at the baseline shipped with an earlier release and are left out (REL7b).
+ */
+function nextMdNotes(baseline: string, cutoff: string, landings: ReleaseLanding[]): { notes: NextMdNote[]; carried: number } {
+  const text = git(['show', `${cutoff}:${NEXT_MD}`], true);
+  if (!text) return { notes: [], carried: 0 };
+  const inRange = new Set(addedLines(requiredGit(['diff', '-U0', baseline, cutoff, '--', NEXT_MD])));
+  const addedBy = new Map<string, string>();
+  for (const landing of landings) {
+    if (!landing.changedFiles.includes(NEXT_MD)) continue;
+    const diff = requiredGit(['show', '-m', '--first-parent', '--format=', '-U0', landing.sha, '--', NEXT_MD]);
+    for (const line of addedLines(diff)) addedBy.set(line, landing.sha);
+  }
+  const all = parseNextMdNotes(text);
+  const notes = all.filter((note) => note.raw !== undefined && inRange.has(note.raw)).map((note) => {
+    const sha = addedBy.get(note.raw!);
+    return { kind: note.kind, line: note.line, ...(sha ? { sha } : {}) };
+  });
+  return { notes, carried: all.length - notes.length };
+}
+
+function addedLines(diff: string): string[] {
+  return diff.split('\n').filter((line) => line.startsWith('+') && !line.startsWith('+++')).map((line) => line.slice(1).trim());
+}
+
 function runningGoalPaths(): string[] {
   const repo = process.cwd();
   const paths: string[] = [];
@@ -118,11 +145,13 @@ export function main(args: string[] = process.argv.slice(2)): void {
   const instanceRoot = effectiveInstanceRoot();
   const notes = readReleaseNotes(releaseNotesDir(instanceRoot));
   debug.log('release.notes', 'read', { fragments: notes.size, problems: notes.problems });
+  const nextMd = nextMdNotes(baselineSha, cutoff, landings);
   const manifest = buildReleaseManifest({
-    version, baseline: { ref: baseline.ref, sha: baselineSha }, cutoff: { sha: cutoff }, landings, notes,
+    version, baseline: { ref: baseline.ref, sha: baselineSha }, cutoff: { sha: cutoff }, landings, notes, nextMd: nextMd.notes,
     runningGoalPaths: runningGoalPaths(), publicCommandsBefore: commandsAt(baselineSha), publicCommandsAfter: commandsAt(cutoff),
   });
   const output = { ...manifest, baselineSource: baseline.source };
+  debug.log('release-loop.notes', 'fragments', { version, ...manifest.fragments, carriedFromEarlier: nextMd.carried });
   const directory = join(instanceRoot, 'release', version);
   mkdirSync(directory, { recursive: true });
   writeFileSync(join(directory, 'manifest.json'), JSON.stringify(output, null, 2) + '\n');

package/scripts/release-loop/export-check-node.ts

@@ -0,0 +1,85 @@
+#!/usr/bin/env bun
+import { existsSync, mkdtempSync, readFileSync, realpathSync, rmSync, symlinkSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { finishNode, nodeOutput, readGraphContext, runCommand, type CommandResult, type CommandRunner } from './node-verdict.js';
+
+export interface ExportCheckResult extends Record<string, unknown> {
+  outcome: 'ok' | 'fail';
+  verdict: 'pass' | 'fail';
+  summary: string;
+  step: 'export' | 'build';
+  tail: string;
+}
+
+function failed(step: ExportCheckResult['step'], message: string, result?: CommandResult): ExportCheckResult {
+  const tail = (result ? result.stderr || result.stdout : message).trim().slice(-300);
+  return { outcome: 'fail', verdict: 'fail', summary: `${step} failed: ${message}${result ? ` (rc=${result.status})` : ''}`, step, tail };
+}
+
+/** Check the same public export and PWA build as release prepare, without cloning or writing to a public remote. */
+export function runExportCheck(run: CommandRunner = runCommand, repoRoot = process.cwd()): ExportCheckResult {
+  const context = readGraphContext();
+  const commit = nodeOutput(context, 'version-release', 'commit');
+  if (context.outputs.gate?.outcome !== 'ok') return failed('export', 'gate did not pass');
+  const root = resolve(repoRoot);
+  const out = mkdtempSync(join(tmpdir(), 'elanous-export-check-'));
+  const sourceDir = join(out, 'source');
+  let added = false;
+  let step: ExportCheckResult['step'] = 'export';
+  let result: ExportCheckResult = failed(step, 'check incomplete');
+  try {
+    const modulesRoot = dirname(realpathSync(join(root, 'node_modules')));
+    const add = run('git', ['worktree', 'add', '-q', '--detach', sourceDir, commit], root);
+    if (add.status !== 0) result = failed('export', 'git worktree add', add);
+    else {
+      added = true;
+      const head = run('git', ['rev-parse', 'HEAD'], sourceDir);
+      if (head.status !== 0 || head.stdout.trim() !== commit) result = failed('export', 'cut commit mismatch', head);
+      else {
+        const version = (JSON.parse(readFileSync(join(sourceDir, 'package.json'), 'utf8')) as { version?: string }).version;
+        if (version !== context.input.version) result = failed('export', `package.json version ${version} != ${context.input.version}`);
+        else {
+          symlinkSync(join(modulesRoot, 'node_modules'), join(sourceDir, 'node_modules'), 'dir');
+          const exported = run('bun', ['scripts/public-export.ts', '--out', join(out, 'export')], sourceDir);
+          if (exported.status !== 0) result = failed('export', 'public export', exported);
+          else {
+            step = 'build';
+            const publicDir = join(out, 'export');
+            symlinkSync(join(modulesRoot, 'node_modules'), join(publicDir, 'node_modules'), 'dir');
+            const pwaModules = join(modulesRoot, 'apps', 'pwa', 'node_modules');
+            if (existsSync(pwaModules) && existsSync(join(publicDir, 'apps', 'pwa'))) symlinkSync(pwaModules, join(publicDir, 'apps', 'pwa', 'node_modules'), 'dir');
+            const built = run('bun', ['bin/elanous.mjs', 'nexus', 'build'], publicDir);
+            result = built.status === 0 && existsSync(join(publicDir, 'apps', 'pwa', 'out', 'index.html'))
+              ? { outcome: 'ok', verdict: 'pass', summary: `public export and PWA build ${commit.slice(0, 12)}`, step: 'build', tail: '' }
+              : failed('build', 'PWA build or out/index.html missing', built);
+          }
+        }
+      }
+    }
+  } catch (error) {
+    result = failed(step, error instanceof Error ? error.message : String(error));
+  } finally {
+    try {
+      if (added) {
+        const removed = run('git', ['worktree', 'remove', '--force', sourceDir], root);
+        if (removed.status !== 0) result = failed(step, 'git worktree remove', removed);
+      }
+    } catch (error) {
+      result = failed(step, `git worktree remove: ${error instanceof Error ? error.message : String(error)}`);
+    } finally {
+      rmSync(out, { recursive: true, force: true });
+    }
+  }
+  return result;
+}
+
+if (import.meta.main) {
+  let version = '';
+  try {
+    version = readGraphContext().input.version;
+    process.exitCode = finishNode('export-check', version, runExportCheck());
+  } catch (error) {
+    process.exitCode = finishNode('export-check', version, failed('export', error instanceof Error ? error.message : String(error)));
+  }
+}

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

@@ -125,6 +125,14 @@ export const POD_MEMORY_SOURCE = 'docs/measurements/td1-whole-gate-mechanical-20
 export const POD_SHARD_FILE_CAP = 27;
 
 export const POD_SWEEP_INTEGRATION_ONLY: readonly string[] = ['scripts/install.test.ts'];
+/** Whole-repository audits run alone in the nightly test-diet graph, not in release-gate shards. */
+export const GATE_NIGHTLY_AUDITS: readonly string[] = [
+  'test/f12-sweep.test.ts', // Sweeps the whole repository; 7.8 GB even after TD1a.
+  'scripts/unwired-exports.test.ts', // Compiles and scans all exports; 9.9 GB.
+  'test/guardian/dispatch-surface-contract.test.ts', // Compiles repository-wide dispatch contracts; 8.3 GB.
+  'test/pwa-build-typecheck.test.ts', // Builds and typechecks the whole PWA; 4.2 GB.
+  'test/user-config-mcp.test.ts', // 2.1 GB peak; keep the gate below the 2 GB audit budget.
+];
 const tail40 = (output: string) => output.trimEnd().split(/\r?\n/).slice(-40).join('\n');
 const lastStartedTestFile = (output: string, paths: string[]): string | undefined => {
   let last: string | undefined;
@@ -211,9 +219,11 @@ export function createGateRunner(repo: string, remote?: string, commandOverride?
     // CDP 시험은 `test:deterministic` 이 스스로 뺀다 — 조각에 그것만 남으면 bun «시험 없음» exit 1 을 «불완전»으로 읽었다(09-30 G1d 실측 둘).
     // bun 의 탐색은 숨은 디렉터리(`.x/`)를 안 연다 — 사람의 `bun test` 가 한 번도 안 돌리는 빈 픽스처가 조각에 혼자 남아 «Ran 0 tests» 를 «불완전»으로 읽었다(09-30 G1e 5번 조각).
     const assignable = files.filter((file) => !cdpPatterns.includes(file) && !POD_SWEEP_INTEGRATION_ONLY.includes(file)
-      && !file.split('/').some((part) => part.startsWith('.')));
+      && !GATE_NIGHTLY_AUDITS.includes(file) && !file.split('/').some((part) => part.startsWith('.')));
     const integrationOnly = files.filter((file) => POD_SWEEP_INTEGRATION_ONLY.includes(file));
     if (integrationOnly.length) debug.log('release-loop.gate', 'pod-sweep-integration-only', { files: integrationOnly });
+    const nightlyAudits = files.filter((file) => GATE_NIGHTLY_AUDITS.includes(file));
+    if (nightlyAudits.length) debug.log('release-loop.gate', 'pod-sweep-nightly-audit', { files: nightlyAudits });
     if (!assignable.length) throw new Error('sweep incomplete: no tests ran');
     const durations = pod.durationSource ? readFileDurations(pod.durationSource) : new Map<string, number>();
     const memory = readFileMemory(join(tree, POD_MEMORY_SOURCE));
@@ -427,9 +437,10 @@ export function createGateRunner(repo: string, remote?: string, commandOverride?
       const outputs: string[] = [];
       let total = { pass: 0, fail: 0, errors: 0, ran: 0, files: 0 };
       for (const group of groups) {
-        if (!group.paths.length || !files.some((f) => group.paths.some((p) => f === p || f.startsWith(`${p}/`)))) continue;
+        if (!group.paths.length || !files.some((f) => !GATE_NIGHTLY_AUDITS.includes(f) && group.paths.some((p) => f === p || f.startsWith(`${p}/`)))) continue;
         const start = Date.now();
-        const groupIgnores = cdpPatterns.filter((pattern) => group.paths.some((p) => pattern === p || pattern.startsWith(`${p}/`)))
+        const groupIgnores = [...new Set([...cdpPatterns, ...GATE_NIGHTLY_AUDITS])]
+          .filter((pattern) => files.includes(pattern) && group.paths.some((p) => pattern === p || pattern.startsWith(`${p}/`)))
           .flatMap((pattern) => ['--path-ignore-patterns', pattern]);
         const run = await command('bun', ['run', 'test:deterministic', ...groupIgnores, ...group.paths.map(asPath)], tree);
         if (logDir) {
@@ -608,7 +619,10 @@ export async function judgeGate(opts: GateOptions, runner: GateRunner = createGa
     };
     let baseline: SweepFailures | undefined = trusted ? { failures: trusted.failures, errors: trusted.errors ?? [] } : undefined;
     if (!baseline) {
-      const baseRun = await runner.sweep(await getBaseTree(), join(root, 'release', opts.version, 'gate-logs', 'baseline'));
+      // K9b — with no reusable ledger the baseline is swept on the same Pod pool as the cut, not on this host (0.2.6: an
+      // hour of local baseline after a 23-minute Pod cut).
+      const baseRun = await runner.sweep(await getBaseTree(), join(root, 'release', opts.version, 'gate-logs', 'baseline'),
+        opts.pod ? { ...opts.pod, durationSource: join(ledger, 'release', opts.baselineVersion, 'gate-logs', 'cut') } : undefined);
       baseline = failuresOf(baseRun, 'baseline sweep');
     }
     for (const id of [...baseline.failures, ...baseline.errors, ...cut.failures, ...cut.errors]) fileOf(id);

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

@@ -57,6 +57,11 @@ export function errorResult(error: unknown): { outcome: 'error'; verdict: 'fail'
   return { outcome: 'error', verdict: 'fail', summary: error instanceof Error ? error.message : String(error) };
 }
 
+/** A cut whose notes would show users nothing fails the cutoff instead of shipping a «Plus N internal changes.» page. */
+export function cutoffNotesEmpty(data: Record<string, unknown> | undefined): boolean {
+  return Array.isArray(data?.escalate) && (data.escalate as Array<{ kind?: string }>).some((item) => item?.kind === 'notes-empty');
+}
+
 // Existing cutoff/PWA/TUI programs have different output conventions; normalize them at the graph boundary.
 if (import.meta.main) {
   const node = process.argv[2];
@@ -78,7 +83,9 @@ if (import.meta.main) {
     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';
-    result = { ...data, outcome, verdict: outcome === 'ok' ? verdict === 'flaky' ? 'flaky' : 'pass' : 'fail',
+    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);

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

@@ -1,8 +1,29 @@
 #!/usr/bin/env bun
+import { existsSync, readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
+import { join, isAbsolute } from 'node:path';
+import { debug } from '../../src/debug/log.js';
 import { errorResult, finishNode, lastResult, nodeOutput, readGraphContext, runCommand, type CommandResult, type CommandRunner } from './node-verdict.js';
 
-interface HostResult { host: string; ok: boolean; before: string; after: string; error?: string; skipped?: string; hooks?: string }
+interface HostResult { host: string; ok: boolean; before: string; after: string; error?: string; skipped?: string; hooks?: string; restart?: 'no-service' }
+interface OpsUpgradeDeps { exists?: (path: string) => boolean; installSource?: () => string | null }
+
+function localInstallSource(): string | null {
+  try {
+    const data: unknown = JSON.parse(readFileSync(join(homedir(), '.local/share/elanous/install.json'), 'utf8'));
+    return data && typeof data === 'object' && 'source' in data && typeof data.source === 'string' ? data.source : null;
+  } catch { return null; }
+}
+
+function installedMatches(installed: unknown, version: string, checkout: boolean): boolean {
+  return installed === version || checkout && typeof installed === 'string'
+    && installed.startsWith(`${version}-`) && /^[0-9a-f]{12}$/.test(installed.slice(version.length + 1));
+}
+
+function missingService(data: Record<string, unknown> | undefined): boolean {
+  return typeof data?.reason === 'string'
+    && /^재시작 실패:\s*(?:Could not find service\s+"?com\.elanous\.nexus\b|(?:Failed to restart elanous-nexus\.service:\s*)?Unit elanous-nexus(?:\.service)? not found\b)/i.test(data.reason);
+}
 
 function firstLine(text: string): string { return text.trim().split(/\r?\n/)[0]?.trim() ?? ''; }
 
@@ -15,7 +36,7 @@ function reason(result: CommandResult): string {
 
 function quote(value: string): string { return `'${value.replaceAll("'", "'\\''")}'`; }
 
-export function runOpsUpgrade(run: CommandRunner = runCommand) {
+export function runOpsUpgrade(run: CommandRunner = runCommand, deps: OpsUpgradeDeps = {}) {
   const context = readGraphContext();
   const hosts = context.input.opsHosts;
   if (hosts === undefined || (Array.isArray(hosts) && hosts.length === 0)) {
@@ -27,9 +48,12 @@ export function runOpsUpgrade(run: CommandRunner = runCommand) {
   if (nodeOutput(context, 'publish', 'tag') !== `v${version}`) throw new Error('published tag/version mismatch');
   const internalDist = context.input.internalDist;
   if (internalDist !== undefined && (typeof internalDist !== 'string' || !internalDist.trim())) throw new Error('input.internalDist must be a path string');
-  const feedPath = typeof internalDist === 'string' && internalDist.startsWith('~/') ? `${homedir()}/${internalDist.slice(2)}` : internalDist;
+  const defaultFeed = join(homedir(), '.local/share/elanous-ops/internal-dist');
+  const feedPath = typeof internalDist === 'string'
+    ? internalDist.startsWith('~/') ? `${homedir()}/${internalDist.slice(2)}` : internalDist
+    : (deps.exists ?? existsSync)(defaultFeed) ? defaultFeed : undefined;
   let feedError = '';
-  if (typeof feedPath === 'string') {
+  if (feedPath !== undefined) {
     try {
       const feed = run('bun', ['scripts/publish-internal-dist.ts', '--checkout', process.cwd(), '--out', feedPath]);
       const data = lastResult(feed);
@@ -38,8 +62,15 @@ export function runOpsUpgrade(run: CommandRunner = runCommand) {
   }
   const results: HostResult[] = [];
   for (const host of hosts as string[]) {
+    const source = host === 'local' ? (deps.installSource ?? localInstallSource)() : null;
+    const checkout = host === 'local' && source !== null && isAbsolute(source);
+    const path = checkout ? 'checkout' as const : 'release' as const;
+    const record = (result: HostResult) => {
+      results.push(result);
+      debug.log('release-loop.ops-upgrade', 'host', { host, path, restart: result.restart ?? (context.input.opsRestart === true ? result.ok ? 'ok' : 'failed' : 'skipped'), ok: result.ok });
+    };
     if (host !== 'local' && feedError) {
-      results.push({ host, ok: false, before: '', after: '', skipped: '내부 피드 발행 실패', error: feedError });
+      record({ host, ok: false, before: '', after: '', skipped: '내부 피드 발행 실패', error: feedError });
       continue;
     }
     const command = (args: string[]): CommandResult => host === 'local'
@@ -51,22 +82,46 @@ export function runOpsUpgrade(run: CommandRunner = runCommand) {
     try {
       const previous = command(['--version']);
       if (previous.status === 0) before = firstLine(previous.stdout);
-      const updated = command(['update', '--version', version, '--json', ...(context.input.opsRestart === true ? ['--restart'] : [])]);
+      if (checkout) {
+        const git = (args: string[]) => run('git', args, source!);
+        const dirty = git(['status', '--porcelain', '--untracked-files=all']);
+        if (dirty.status !== 0 || dirty.stdout.trim()) {
+          record({ host, ok: false, before, after, error: dirty.status === 0 ? '체크아웃 변경 있음' : `체크아웃 상태 확인 실패: ${reason(dirty)}` });
+          continue;
+        }
+        const fetched = git(['fetch', '--tags']);
+        if (fetched.status !== 0) {
+          record({ host, ok: false, before, after, error: `태그 가져오기 실패: ${reason(fetched)}` });
+          continue;
+        }
+        const tag = git(['rev-parse', '--verify', `refs/tags/v${version}^{commit}`]);
+        if (tag.status !== 0 || !tag.stdout.trim()) {
+          record({ host, ok: false, before, after, error: `태그 없음: v${version}` });
+          continue;
+        }
+        const moved = git(['checkout', '--detach', `v${version}`]);
+        if (moved.status !== 0) {
+          record({ host, ok: false, before, after, error: `체크아웃 전환 실패: ${reason(moved)}` });
+          continue;
+        }
+      }
+      const updated = command(['update', ...(checkout || host !== 'local' && feedPath !== undefined ? [] : ['--version', version]), '--json', ...(context.input.opsRestart === true ? ['--restart'] : [])]);
       const updateResult = lastResult(updated);
-      if (updated.status !== 0 || updateResult?.exitCode !== 0 || updateResult.installedVersion !== version) {
-        const error = updated.status === 0 && updateResult?.exitCode === 0
-          ? `설치판 불일치 (기대 ${version}, 실제 ${String(updateResult.installedVersion)})` : reason(updated);
-        results.push({ host, ok: false, before, after, error });
+      const noService = host !== 'local' && context.input.opsRestart === true && updateResult?.exitCode === 1 && missingService(updateResult);
+      if ((!noService && (updated.status !== 0 || updateResult?.exitCode !== 0)) || !installedMatches(updateResult?.installedVersion, version, checkout)) {
+        const error = (updated.status === 0 && updateResult?.exitCode === 0 || noService)
+          ? `설치판 불일치 (기대 ${version}, 실제 ${String(updateResult?.installedVersion)})` : reason(updated);
+        record({ host, ok: false, before, after, error });
         continue;
       }
       const current = command(['--version']);
       if (current.status !== 0) {
-        results.push({ host, ok: false, before, after, error: reason(current) });
+        record({ host, ok: false, before, after, error: reason(current) });
         continue;
       }
       after = firstLine(current.stdout);
-      if (after.split(/\s+/)[0] !== version) {
-        results.push({ host, ok: false, before, after, error: `올렸는데 판이 그대로 (기대 ${version}, 실제 ${after || '없음'})` });
+      if (!installedMatches(after.split(/\s+/)[0], version, checkout)) {
+        record({ host, ok: false, before, after, error: `올렸는데 판이 그대로 (기대 ${version}, 실제 ${after || '없음'})` });
         continue;
       }
       // The webhook receiver (`elanous hooks serve`, a user systemd unit on the bot VM) keeps the old code until it
@@ -76,16 +131,17 @@ export function runOpsUpgrade(run: CommandRunner = runCommand) {
         const restarted = run('ssh', [host, 'systemctl --user try-restart elanous-hooks.service 2>/dev/null && systemctl --user is-active elanous-hooks.service 2>/dev/null || echo absent']);
         hooks = firstLine(restarted.stdout) || 'absent';
       }
-      results.push({ host, ok: true, before, after, ...(hooks ? { hooks } : {}) });
+      record({ host, ok: true, before, after, ...(hooks ? { hooks } : {}), ...(noService ? { restart: 'no-service' as const } : {}) });
     } catch (error) {
-      results.push({ host, ok: false, before, after, error: firstLine(String(error)) });
+      record({ host, ok: false, before, after, error: firstLine(String(error)) });
     }
   }
   const failures = results.filter((result) => !result.ok);
   return { outcome: failures.length || feedError ? 'fail' as const : 'ok' as const,
     verdict: failures.length || feedError ? 'fail' as const : 'pass' as const,
     summary: failures.length ? `운영 판올림 실패: ${failures.map(({ host, error }) => `${host}: ${error}`).join('; ')}${feedError && !failures.some((item) => item.skipped) ? `; ${feedError}` : ''}`
-      : feedError || `운영 판올림 ${version} · ${results.length}대 확인`, hosts: results };
+      : feedError || `운영 판올림 ${version} · ${results.length}대 확인`,
+    feed: feedError ? 'failed' as const : feedPath === undefined ? 'skipped-no-path' as const : 'published' as const, hosts: results };
 }
 
 if (import.meta.main) {

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

@@ -2,10 +2,13 @@ import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { releaseLedgerRoot } from '../../src/instance/resolve.js';
 import { checklistGate, type ChecklistGate } from '../../src/release-loop/checklist.js';
+import { getSchedule, formatKst } from '../../src/release-loop/release-schedule.js';
+import { debug } from '../../src/debug/log.js';
 
 export type ReleaseReadiness =
   | { ready: false; reason: 'already-published'; details: string }
   | { ready: false; reason: 'already-running'; details: string }
+  | { ready: false; reason: 'before-cut'; details: string }
   | { ready: false; reason: 'checklist-blocked'; details: ChecklistGate }
   | { ready: true; reason: 'ready'; details: ChecklistGate };
 
@@ -13,6 +16,7 @@ export interface ReleaseReadinessDeps {
   ledgerRoot?: string;
   checklist?: typeof checklistGate;
   isPidAlive?: (pid: number) => boolean;
+  now?: () => Date;
 }
 
 function readIfPresent(path: string): string | undefined {
@@ -52,6 +56,11 @@ export function releaseReadiness(version: string, deps: ReleaseReadinessDeps = {
       return { ready: false, reason: 'already-running', details: String(pid) };
     }
   }
+  const schedule = getSchedule(version, deps.ledgerRoot);
+  if (schedule && (deps.now ?? (() => new Date()))().getTime() < Date.parse(schedule.cutAt)) {
+    debug.log('release.schedule', 'before-cut', { version, cutAt: schedule.cutAt, landBy: schedule.landBy });
+    return { ready: false, reason: 'before-cut', details: `before-cut (${formatKst(schedule.cutAt)})` };
+  }
   const gate = (deps.checklist ?? checklistGate)(version);
   if (!gate.ok) return { ready: false, reason: 'checklist-blocked', details: gate };
   return { ready: true, reason: 'ready', details: gate };

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

@@ -1,6 +1,6 @@
 #!/usr/bin/env bun
 import { spawnSync } from 'node:child_process';
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join, resolve } from 'node:path';
 import { emitNodeResult } from './node-verdict.js';
@@ -55,7 +55,16 @@ function versionAt(repo: string): string {
   return pkg.version;
 }
 
-function landing(repo: string, kind: Kind, releaseVersion: string): Output {
+/** next.md list lines (trimmed) present at the cut commit, or null when the cut or its next.md cannot be read. */
+function shippedNextMdLines(repo: string, cut: string | undefined): { lines: Set<string> } | { reason: string } {
+  if (!cut) return { reason: 'cut-unknown' };
+  // git-spawn-allow: reads the cut commit's next.md to learn which lines that release already carried.
+  const shown = spawnSync('git', ['show', `${cut}:release/next.md`], { cwd: repo, encoding: 'utf8', maxBuffer: 16 * 1024 * 1024 });
+  if (shown.status !== 0 || shown.error) return { reason: 'cut-next-md-unreadable' };
+  return { lines: new Set(shown.stdout.split('\n').map((line) => line.trim()).filter((line) => line.startsWith('- '))) };
+}
+
+function landing(repo: string, kind: Kind, releaseVersion: string, cut?: string): Output {
   const target = kind === 'release' ? releaseVersion : nextDevVersion(releaseVersion);
   const source = kind === 'release' ? `${releaseVersion}-dev.N` : releaseVersion;
   fetchMain(repo);
@@ -85,6 +94,41 @@ function landing(repo: string, kind: Kind, releaseVersion: string): Output {
       writeFileSync(lockPath, lock.replace(root[0], root[0].replace(lockedVersion[0], `"version": "${target}"`)));
     }
     run('bun', ['install', '--frozen-lockfile'], worktree);
+    if (kind === 'dev-bump') {
+      const nextPath = join(worktree, 'release', 'next.md');
+      if (existsSync(nextPath)) {
+        const original = readFileSync(nextPath, 'utf8');
+        // OP 10-02: dev-bump runs on the then-current main, not the cut. Lines landed after the cut are not in this
+        // release and #22745 carries only lines added by the next cut range — so remove only lines the cut carried.
+        const shipped = shippedNextMdLines(repo, cut);
+        if ('reason' in shipped) {
+          console.error(`⚠ next.md 비우기 건너뜀(${shipped.reason}) — 컷 커밋의 next.md 를 못 읽어 «나간 줄»을 증명할 수 없다`);
+          debug.log('release-loop.notes', 'next-md-reset-skipped', { reason: shipped.reason }, { level: 'warn' });
+        }
+        const shippedLines = 'lines' in shipped ? shipped.lines : new Set<string>();
+        let keptAfterCut = 0;
+        let removed = 0;
+        let keptLater = 0;
+        let inSection = false;
+        let droppingItem = false;
+        // Only shipped list items (and their indented continuation lines) go; headings, prose, `###` subheadings and
+        // `Target: later` items stay — the reviewer's «preserve everything but the released lines».
+        const reset = original.split(/(?<=\n)/).filter((line) => {
+          if (/^## /.test(line)) { inSection = true; droppingItem = false; return true; }
+          if (!inSection) return true;
+          if (/^- /.test(line)) {
+            if (/\bTarget:\s*later(?:\.|\s|$)/i.test(line)) { keptLater++; droppingItem = false; return true; }
+            if (!shippedLines.has(line.trim())) { keptAfterCut++; droppingItem = false; return true; }
+            removed++; droppingItem = true; return false;
+          }
+          if (droppingItem && /^[ \t]+\S/.test(line)) return false;
+          droppingItem = false;
+          return true;
+        }).join('');
+        if (reset !== original) writeFileSync(nextPath, reset);
+        debug.log('release-loop.notes', 'next-md-reset', { removed, keptLater, keptAfterCut });
+      }
+    }
     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,
@@ -111,24 +155,28 @@ function landing(repo: string, kind: Kind, releaseVersion: string): Output {
 function main(args: string[] = process.argv.slice(2), repo = process.cwd()): Output {
   let kind: Kind | null = null;
   let version: string | null = null;
+  let cut: string | undefined;
   try {
-    if (args[0] !== 'release' && args[0] !== 'dev-bump') throw new Error('usage: version-node.ts <release|dev-bump> [--version <v>] --json');
+    if (args[0] !== 'release' && args[0] !== 'dev-bump') throw new Error('usage: version-node.ts <release|dev-bump> [--version <v>] [--cut <sha>] --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; }
+      if (args[i] === '--cut' && args[i + 1]) { cut = 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 (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 }; outputs?: Record<string, { commit?: unknown } | undefined> };
+      if (!version && typeof context.input?.version === 'string') version = context.input.version;
+      // The cut = the commit version-release landed (what cutoff and the gate measured).
+      const cutCommit = context.outputs?.['version-release']?.commit;
+      if (!cut && typeof cutCommit === 'string' && cutCommit) cut = cutCommit;
     }
     if (!version) throw new Error('version required (--version or ELANOUS_GRAPH_CONTEXT.input.version)');
     nextDevVersion(version);
-    return landing(resolve(repo), kind, version);
+    return landing(resolve(repo), kind, version, cut);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     const worktree = /\[worktree: ([^\]]+)\]$/.exec(message)?.[1];

package/scripts/repo-watch-cycle.ts

@@ -25,7 +25,7 @@ function log(s: string): void {
 
 const results = runRepoWatchCycle({
   // 흡수 제안 리포트 발송(report 채널 · 야간무음 게이트 · fail-soft).
-  notify: (report) => { try { log(`발송 ${sendOutbound(report, 'report') ? 'OK' : '실패'}`); } catch (e) { log(`발송 오류: ${e instanceof Error ? e.message : String(e)}`); } },
+  notify: (report) => { try { log(`발송 ${sendOutbound(report, 'ops-report') ? 'OK' : '실패'}`); } catch (e) { log(`발송 오류: ${e instanceof Error ? e.message : String(e)}`); } },
   // 자율행동 회상 기록(loop=autopilot).
   record: (input) => { recordAutonomousActionSafe({ loop: 'autopilot', ...input }); },
 });

package/scripts/retro-cycle.ts

@@ -120,11 +120,11 @@ const report = await runRetroCycle({
     const p = join(REPORT_DIR, filename); writeFileSync(p, md);
     // ★ B5: --collect-only 면 발송 억제(회고 리포트 영속·resolution/발굴 입력·발송만 skip).
     if (process.argv.includes('--collect-only')) log(`collect-only — 회고 리포트 영속·발송 skip`);
-    else try { log(`회고 리포트 발송 ${sendOutbound(md, 'report') ? 'OK' : '실패'}`); } catch (e) { log(`발송 오류: ${e instanceof Error ? e.message : String(e)}`); }
+    else try { log(`회고 리포트 발송 ${sendOutbound(md, 'ops-report') ? 'OK' : '실패'}`); } catch (e) { log(`발송 오류: ${e instanceof Error ? e.message : String(e)}`); }
     return p;
   },
   // HITL 승인 요청 — 텔레그램 alert(collect-only 면 로그만).
-  notify: (t) => { log(`[HITL] ${t.replace(/\n/g, ' ')}`); if (!process.argv.includes('--collect-only')) try { sendOutbound(t, 'alert'); } catch { /* fail-soft */ } },
+  notify: (t) => { log(`[HITL] ${t.replace(/\n/g, ' ')}`); if (!process.argv.includes('--collect-only')) try { sendOutbound(t, 'ops-alert'); } catch { /* fail-soft */ } },
 }, period);
 
 log(`retro ${period}: report=${report.reportPath} · 제안=${report.hasProposal ? report.proposalId : '없음'}`);

package/scripts/schedule-health-report.ts

@@ -96,7 +96,7 @@ function main(): void {
       console.log(msg);
       return;
     }
-    const ok = sendOutbound(msg, 'alert');
+    const ok = sendOutbound(msg, 'ops-alert');
     console.log(`[schedule-health] ${mode}: ${ok ? '발송' : '발송 실패'} — 밀림 ${health.stale.length}·실패 ${health.errored.length}`);
   } finally {
     db.close();