elanous 0.2.35 → 0.2.37

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

@@ -12,7 +12,8 @@ import { baseVersion, isReleaseVersion, isStableVersion, prereleaseKind } from '
 type Kind = 'release' | 'dev-bump';
 type Output = { outcome: 'ok' | 'error'; kind: Kind | null; version: string | null; commit: string | null; pr: number | null; files?: string[]; worktree?: string; error?: string;
   /** RELEASE-BRANCH: the release branch the cut lives on and the main commit it was cut from. */
-  branch?: string; base?: string; existing?: boolean; skipped?: string };
+  branch?: string; base?: string; existing?: boolean; skipped?: string;
+  artifactOwner?: { runId: string; attempt: number } };
 
 export function nextDevVersion(version: string): string {
   const match = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.exec(isReleaseVersion(version) ? baseVersion(version) : version);
@@ -147,6 +148,57 @@ export interface BranchCutDeps {
   freeze?: () => LandingFreeze | null;
   /** `--force-freeze`: cut while a freeze is on (recorded). */
   forceFreeze?: boolean;
+  /** Identity of the graph run cutting this branch. A direct legacy call may omit it. */
+  runId?: string;
+  /** Release run ledger universe; defaults to the active instance root. */
+  root?: string;
+}
+
+function releaseOwner(version: string, deps: BranchCutDeps): { runId: string; attempt: number } | undefined {
+  if (!deps.runId) return undefined;
+  const runId = deps.runId;
+  if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(runId) || runId === '.' || runId === '..') throw new Error(`invalid release run id: ${runId}`);
+  const path = join(deps.root ?? effectiveInstanceRoot(), 'release', version, 'resume-attempts', `${runId}.json`);
+  if (!existsSync(path)) return { runId, attempt: 0 };
+  const saved = JSON.parse(readFileSync(path, 'utf8')) as { version?: unknown; runId?: unknown; attempts?: unknown };
+  if (saved.version !== version || saved.runId !== runId || !Array.isArray(saved.attempts)
+    || saved.attempts.some((value) => typeof value !== 'string' || !Number.isFinite(Date.parse(value))))
+    throw new Error(`invalid resume attempts: ${path}`);
+  return { runId, attempt: saved.attempts.length };
+}
+
+function recordedBranchOwner(repo: string, tip: string): { runId: string; attempt: number } | undefined {
+  // An owner's trailer inherited from main is not evidence that this release branch belongs to that run.
+  const fork = git(repo, 'merge-base', 'origin/main', tip);
+  const messages = git(repo, 'log', '--first-parent', '--format=%B', '-n', '100', `${fork}..${tip}`);
+  const match = /^Elanous-Release-Run: ([A-Za-z0-9][A-Za-z0-9._-]*)\nElanous-Release-Attempt: (0|[1-9][0-9]*)$/m.exec(messages);
+  return match ? { runId: match[1]!, attempt: Number(match[2]) } : undefined;
+}
+
+function priorRunOwnsTip(version: string, tip: string, owner: { runId: string; attempt: number }, root: string): boolean {
+  const path = join(root, 'graph-runs', 'release-loop', `${owner.runId}.json`);
+  if (!existsSync(path)) return false;
+  const state = JSON.parse(readFileSync(path, 'utf8')) as { graphId?: unknown; runId?: unknown; input?: { version?: unknown; branchCut?: unknown };
+    nodes?: Array<{ nodeId?: unknown; ok?: unknown; output?: unknown }> };
+  if (state.graphId !== 'release-loop' || state.runId !== owner.runId || state.input?.version !== version || state.input?.branchCut !== true) return false;
+  return state.nodes?.some((node) => {
+    if (node.nodeId !== 'version-release' || node.ok !== true || typeof node.output !== 'string') return false;
+    try {
+      const result = JSON.parse(node.output.trim().split('\n').at(-1)!) as { commit?: unknown; branch?: unknown };
+      return result.commit === tip && result.branch === `release/${version}`;
+    } catch { return false; }
+  }) ?? false;
+}
+
+function preserveForeignBranch(repo: string, version: string, tip: string): string {
+  const backupBranch = `release-backup/${version}/${tip}`;
+  const ref = `refs/heads/${backupBranch}`;
+  const existing = git(repo, 'ls-remote', '--heads', 'origin', ref).split(/\s+/)[0] ?? '';
+  if (existing && existing !== tip) throw new Error(`${backupBranch} points to another commit — refusing to replace release branch`);
+  if (!existing) git(repo, 'push', '--porcelain', `--force-with-lease=${ref}:`, 'origin', `${tip}:${ref}`);
+  const preserved = git(repo, 'ls-remote', '--heads', 'origin', ref).split(/\s+/)[0] ?? '';
+  if (preserved !== tip) throw new Error(`${backupBranch} backup verification failed — refusing to replace release branch`);
+  return backupBranch;
 }
 
 function currentFreeze(): LandingFreeze | null {
@@ -189,15 +241,23 @@ export function cutReleaseBranchForRun(repo: string, version: string, deps: Bran
     if (!deps.forceFreeze) throw new Error(landingFreezeMessage(frozen));
   }
   fetchMain(repo);
+  const owner = releaseOwner(version, deps);
   const branch = `release/${version}`;
   const advertised = git(repo, 'ls-remote', '--heads', 'origin', `refs/heads/${branch}`).split(/\s+/)[0] ?? '';
   if (advertised) {
-    // A prerelease number is used once: an existing rc branch is another run's cut, never this run's.
-    if (prereleaseKind(version) !== null) throw new Error(`${branch} already exists — ${version} was cut by another run; run again for the next free number`);
     if (!/^[0-9a-f]{40}$/i.test(advertised)) throw new Error(`${branch} remote tip is not a commit SHA`);
     git(repo, 'fetch', 'origin', `+refs/heads/${branch}:refs/remotes/origin/${branch}`);
     const tip = git(repo, 'rev-parse', '--verify', `refs/remotes/origin/${branch}^{commit}`);
     if (tip !== advertised) throw new Error(`${branch} moved while it was read (${advertised} → ${tip})`);
+    const recordedOwner = owner ? recordedBranchOwner(repo, tip) : undefined;
+    const ledgerOwned = owner && !recordedOwner
+      ? priorRunOwnsTip(version, tip, owner, deps.root ?? effectiveInstanceRoot()) : false;
+    if (owner && recordedOwner?.runId !== owner.runId && !ledgerOwned) {
+      const backupBranch = preserveForeignBranch(repo, version, tip);
+      throw new Error(`${branch} belongs to ${recordedOwner?.runId ?? 'an unknown run'}; preserved ${tip} at ${backupBranch}; refusing to replace a foreign release branch`);
+    }
+    // Direct legacy calls retain the old prerelease number rule. A graph run may reuse only its own rc branch.
+    if (!owner && prereleaseKind(version) !== null) throw new Error(`${branch} already exists — ${version} was cut by another run; run again for the next free number`);
     const current = versionAt(repo, tip);
     if (current !== version) throw new Error(`${branch} tip ${tip} package.json version ${current} is not ${version}`);
     // The branch must be a cut of this release line: its fork point on main still carries <base>-dev.N (or <v>).
@@ -207,8 +267,10 @@ export function cutReleaseBranchForRun(repo: string, version: string, deps: Bran
     if (forkVersion !== version && !new RegExp(`^${stableLine.replaceAll('.', '\\.')}-dev\\.(0|[1-9][0-9]*)$`).test(forkVersion)) {
       throw new Error(`${branch} forks from main at ${fork} (version ${forkVersion}) — not a cut of ${stableLine}-dev.N`);
     }
-    debug.log('release-loop.cut', 'chosen', { version, source: 'release-branch', commit: tip, branch, existing: true });
-    return { outcome: 'ok', kind: 'release', version, commit: tip, pr: null, branch, existing: true };
+    // A legacy saved version-release node was the initial cut; later resume counts do not change its owner attempt.
+    const artifactOwner = recordedOwner ?? (ledgerOwned && owner ? { runId: owner.runId, attempt: 0 } : undefined);
+    debug.log('release-loop.cut', 'chosen', { version, source: 'release-branch', commit: tip, branch, existing: true, artifactOwner });
+    return { outcome: 'ok', kind: 'release', version, commit: tip, pr: null, branch, existing: true, ...(artifactOwner ? { artifactOwner } : {}) };
   }
   const base = git(repo, 'rev-parse', 'origin/main');
   const current = versionAt(repo, base);
@@ -229,8 +291,10 @@ export function cutReleaseBranchForRun(repo: string, version: string, deps: Bran
     if (files.length) {
       (deps.install ?? ((tree: string) => { run('bun', ['install', '--frozen-lockfile'], tree); }))(worktree);
       git(worktree, 'add', '-A');
-      git(worktree, 'commit', '-m', `release: ${version}`, '-m', `Cut from main ${base}.`);
     }
+    // Even a no-op version bump needs a commit that records who owns this cut.
+    if (files.length || owner) git(worktree, 'commit', ...(files.length ? [] : ['--allow-empty']), '-m', `release: ${version}`,
+      '-m', `Cut from main ${base}.${owner ? `\n\nElanous-Release-Run: ${owner.runId}\nElanous-Release-Attempt: ${owner.attempt}` : ''}`);
     const commit = git(worktree, 'rev-parse', 'HEAD');
     // Create-only: an empty lease refuses to overwrite a branch someone else made meanwhile.
     const push = git(repo, 'push', '--porcelain', `--force-with-lease=refs/heads/${branch}:`, 'origin', `${commit}:refs/heads/${branch}`);
@@ -239,16 +303,16 @@ export function cutReleaseBranchForRun(repo: string, version: string, deps: Bran
       return flag === '*' && !!ref?.endsWith(`:refs/heads/${branch}`) && summary === '[new branch]';
     });
     if (!created) throw new Error(`${branch} was not created (push: ${push.replace(/\s+/g, ' ').trim() || 'no output'})`);
-    debug.log('release-loop.cut', 'chosen', { version, source: 'release-branch', commit, branch, base, existing: false });
-    return { outcome: 'ok', kind: 'release', version, commit, pr: null, branch, base, files };
+    debug.log('release-loop.cut', 'chosen', { version, source: 'release-branch', commit, branch, base, existing: false, artifactOwner: owner });
+    return { outcome: 'ok', kind: 'release', version, commit, pr: null, branch, base, files, ...(owner ? { artifactOwner: owner } : {}) };
   } finally {
     try { if (added) git(repo, 'worktree', 'remove', '--force', worktree); }
     finally { rmSync(temp, { recursive: true, force: true }); }
   }
 }
 
-function landing(repo: string, kind: Kind, releaseVersion: string, cut?: string, cutCommit?: string, forceFreeze = false, branchCut = false, devTarget?: string): Output {
-  if (kind === 'release' && branchCut && cutCommit === undefined) return cutReleaseBranchForRun(repo, releaseVersion, { forceFreeze });
+function landing(repo: string, kind: Kind, releaseVersion: string, cut?: string, cutCommit?: string, forceFreeze = false, branchCut = false, devTarget?: string, runId?: string): Output {
+  if (kind === 'release' && branchCut && cutCommit === undefined) return cutReleaseBranchForRun(repo, releaseVersion, { forceFreeze, runId });
   if (kind === 'dev-bump' && prereleaseKind(releaseVersion) !== null) {
     // A prerelease (rehearsal) never moves main: the next stable release still owns this -dev line.
     debug.log('release-loop.version-dev-bump', 'skipped', { version: releaseVersion, reason: 'prerelease' });
@@ -375,6 +439,7 @@ export function main(args: string[] = process.argv.slice(2), repo = process.cwd(
   let cutCommit: string | undefined;
   let forceFreeze = false;
   let branchCut = false;
+  let runId: string | undefined;
   try {
     if (args[0] !== 'release' && args[0] !== 'dev-bump') throw new Error('usage: version-node.ts <release|dev-bump> [--version <v>] [--cut <sha>] [--cut-commit <sha>] --json');
     kind = args[0];
@@ -388,7 +453,11 @@ export function main(args: string[] = process.argv.slice(2), repo = process.cwd(
     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; cutCommit?: unknown; forceFreeze?: unknown; branchCut?: unknown }; outputs?: Record<string, { commit?: unknown } | undefined> };
+        runId?: unknown; input?: { version?: unknown; cutCommit?: unknown; forceFreeze?: unknown; branchCut?: unknown }; outputs?: Record<string, { commit?: unknown } | undefined> };
+      if (context.runId !== undefined) {
+        if (typeof context.runId !== 'string') throw new Error('runId must be a string');
+        runId = context.runId;
+      }
       if (!version && typeof context.input?.version === 'string') version = context.input.version;
       forceFreeze = context.input?.forceFreeze === true;
       branchCut = context.input?.branchCut === true;
@@ -403,7 +472,7 @@ export function main(args: string[] = process.argv.slice(2), repo = process.cwd(
     if (!version) throw new Error('version required (--version or ELANOUS_GRAPH_CONTEXT.input.version)');
     nextDevVersion(version);
     if (kind === 'dev-bump' && cutCommit !== undefined) throw new Error('--cut-commit is only valid for release');
-    return landing(resolve(repo), kind, version, cut, cutCommit, forceFreeze, branchCut);
+    return landing(resolve(repo), kind, version, cut, cutCommit, forceFreeze, branchCut, undefined, runId);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     const worktree = /\[worktree: ([^\]]+)\]$/.exec(message)?.[1];

package/scripts/rhythm/daily.ts

@@ -15,7 +15,10 @@ import { loopEvent } from '../../src/loops/observe.js';
 import { kindRouteTarget, mainHomeTarget } from '../../src/domains/telegram-kind-route.js';
 import { recordOutbound } from '../../src/domains/outbound-alert.js';
 import { listSelfDevRuns, runSummaryLine, selfDevRunsDir } from '../../src/self-dev/run-store.js';
-import { runDraftSweep } from '../../src/self-dev/draft-sweep.js';
+import { runDraftSweep, sweptReasonLabel } from '../../src/self-dev/draft-sweep.js';
+import { LogStore } from '../../src/mss/logging/log-store.js';
+import { BriefItemsLedger } from '../../src/briefing/brief-items.js';
+import { debug } from '../../src/debug/log.js';
 import { retroBriefingLines } from '../../src/retro/daily.js';
 import { dispatchCooAdmin } from '../../src/domains/coo-admin-tool.js';
 
@@ -76,6 +79,133 @@ export function collectRunSummaries(now: Date, root = effectiveInstanceRoot(), l
       prNumbers }));
 }
 
+/**
+ * DRAFT-SWEEP-DAILY-SUMMARY — 닫힌 draft 사유를 «하루 한 번 브리핑 원장 1건» 으로 적는다.
+ * 사유의 정본은 DRAFT-SWEEP-QUIET 이 닫을 때 남기는 `closed` 로그(PR 댓글 0 계약은 그쪽이 지킨다)이고,
+ * 이 경로는 로그 원장 «읽기» ⊕ 브리핑 원장 «쓰기» 만 한다 — GitHub 에 아무것도 쓰지 않는다.
+ */
+export const DRAFT_CLOSE_BRIEF_SOURCE = 'rhythm.daily.draft-close';
+/** DRAFT-SWEEP-QUIET 가 닫힌 draft마다 남기는 로그 — 사유의 정본 좌표. */
+const SWEPT_DRAFT_LOG = { category: 'self-dev.draft-sweep', event: 'closed' } as const;
+const SWEPT_LABEL_PREFIX = 'elanous:swept:';
+
+export type ClosedDraftReason = { reason: string; count: number };
+export type ClosedDraftCount = { closed: number; reasons: ClosedDraftReason[]; unreadable: number };
+export type DraftCloseSummary = {
+  /** 요약이 다루는 날짜(어제, KST). */
+  day: string;
+  closed: number;
+  reasons: ClosedDraftReason[];
+  /** 브리핑 원장에 실린 한 줄 — 표본이 없으면 null. */
+  text: string | null;
+  state: 'recorded' | 'already-recorded' | 'unmeasured' | 'unreadable';
+  /** 미측정·실패 사유(한 줄). */
+  detail?: string;
+  itemId?: number;
+};
+
+/** `closed` 로그 한 줄의 `{ reason }` — Pod 전달 래퍼(`originalData`)도 벗긴다. 못 읽으면 null. */
+function closedLogReason(data: string | null): string | null {
+  if (typeof data !== 'string' || !data.trim()) return null;
+  let payload: unknown;
+  try { payload = JSON.parse(data); } catch { return null; }
+  let body = record(payload);
+  const forwarded = body.originalData;
+  if (forwarded !== undefined) {
+    if (typeof forwarded !== 'string') body = record(forwarded);
+    else { try { body = record(JSON.parse(forwarded)); } catch { return null; } }
+  }
+  const reason = string(body.reason).trim();
+  return reason ? shortReason(reason) : null;
+}
+
+/** 사유를 DRAFT-SWEEP-QUIET 의 사유 종류로 접는다(`superseded-by #24123` → `superseded-by`). */
+export function sweptReasonKind(reason: string): string {
+  const label = sweptReasonLabel(reason);
+  return label.startsWith(SWEPT_LABEL_PREFIX) ? label.slice(SWEPT_LABEL_PREFIX.length) : label;
+}
+
+/**
+ * 어제(KST 00:00–24:00) 닫힌 draft 사유를 로그 원장에서 센다.
+ * ⛔ 원장이 없거나 못 읽으면 null — «0건»이 아니라 «미측정»이다.
+ */
+export function collectClosedDrafts(root: string, now: Date): ClosedDraftCount | null {
+  const path = join(root, 'logs', 'logs.db');
+  if (!existsSync(path)) return null;
+  const from = new Date(`${kstDay(new Date(now.getTime() - 86_400_000))}T00:00:00+09:00`);
+  const store = LogStore.openReadOnly(path);
+  try {
+    const rows = store.queryAll({ exactCategories: [SWEPT_DRAFT_LOG.category], events: [SWEPT_DRAFT_LOG.event],
+      sinceMs: from.getTime(), untilMs: from.getTime() + 86_400_000 - 1 });
+    const counts = new Map<string, number>();
+    let unreadable = 0;
+    for (const row of rows) {
+      const reason = closedLogReason(row.data);
+      if (reason === null) { unreadable += 1; continue; }
+      const kind = sweptReasonKind(reason);
+      counts.set(kind, (counts.get(kind) ?? 0) + 1);
+    }
+    return { closed: [...counts.values()].reduce((sum, count) => sum + count, 0),
+      reasons: [...counts].map(([reason, count]) => ({ reason, count }))
+        .sort((a, b) => b.count - a.count || sortNames(a.reason, b.reason)),
+      unreadable };
+  } finally { store.close(); }
+}
+
+/** 브리핑 한 줄 — 사유 종류별 건수, 상위 5종만 적고 나머지는 «외 N종» 으로 접는다. */
+export function composeDraftCloseSummaryText(reasons: readonly ClosedDraftReason[]): string {
+  const total = reasons.reduce((sum, item) => sum + item.count, 0);
+  const shown = reasons.slice(0, 5).map(item => `${item.reason} ${item.count}`).join(' · ');
+  const omitted = Math.max(0, reasons.length - 5);
+  return `어제 닫힌 draft ${total}건${shown ? ` — ${shown}` : ''}${omitted > 0 ? ` · 외 ${omitted}종` : ''}`;
+}
+
+/**
+ * 어제 닫힌 draft 사유를 브리핑 원장(`<state>/briefing/items.sqlite`, `eln brief`)에 **하루 1건** 으로 적는다.
+ * 표본이 없거나 원장을 못 읽으면 아무것도 쓰지 않고 `unmeasured`/`unreadable` 로 남긴다(«0건»으로 적지 않는다).
+ * 관측은 `deps.log`(루프 tick 전용)가 아니라 로그에 직접 남긴다 — 데일리 tick 의 의미를 바꾸지 않는다.
+ */
+export function recordDraftCloseSummary(root: string, now: Date,
+  log: (category: string, event: string, data?: unknown) => void = (category, event, data) => debug.log(category, event, data),
+): DraftCloseSummary {
+  const observe = (summary: DraftCloseSummary): DraftCloseSummary => {
+    try {
+      log('rhythm.daily', 'draft-close-summary', { day: summary.day, closed: summary.closed, state: summary.state,
+        reasons: summary.reasons.map(item => `${item.reason} ${item.count}`).join(' · '),
+        ...(summary.detail ? { detail: summary.detail } : {}), ...(summary.itemId === undefined ? {} : { itemId: summary.itemId }) });
+    } catch { /* 관측 실패가 브리핑을 막지 않는다 */ }
+    return summary;
+  };
+  const day = kstDay(new Date(now.getTime() - 86_400_000));
+  let counted: ClosedDraftCount | null;
+  try { counted = collectClosedDrafts(root, now); }
+  catch (error) { return observe({ day, closed: 0, reasons: [], text: null, state: 'unreadable',
+    detail: shortReason(`로그 원장 못 읽음 · ${reasonOf(error)}`) }); }
+  if (counted === null) return observe({ day, closed: 0, reasons: [], text: null, state: 'unmeasured', detail: '로그 원장 없음' });
+  if (counted.closed === 0) return observe({ day, closed: 0, reasons: [], text: null, state: 'unmeasured',
+    detail: counted.unreadable > 0 ? `사유 못 읽은 closed 로그 ${counted.unreadable}건` : '닫힌 draft 없음' });
+  // 사유를 못 읽은 closed 로그가 섞이면 읽힌 건수만으로 닫힘 총수를 단정할 수 없다 — 원장에 확정 기록하지 않고 부분 미측정으로 남긴다.
+  if (counted.unreadable > 0) return observe({ day, closed: counted.closed, reasons: counted.reasons, text: null,
+    state: 'unmeasured',
+    detail: `사유 못 읽은 closed 로그 ${counted.unreadable}건 — 읽힌 ${counted.closed}건만 셈(부분 미측정)` });
+  const text = composeDraftCloseSummaryText(counted.reasons);
+  try {
+    const ledger = new BriefItemsLedger({ stateDir: root, now: () => now, log });
+    const today = kstDay(now);
+    const recorded = ledger.list().find(item => item.source === DRAFT_CLOSE_BRIEF_SOURCE
+      && kstDay(new Date(item.created_at)) === today);
+    if (recorded) return observe({ day, closed: counted.closed, reasons: counted.reasons, text,
+      state: 'already-recorded', itemId: recorded.id });
+    const item = ledger.add({ text, domain: '운영', priority: 'P2', source: DRAFT_CLOSE_BRIEF_SOURCE,
+      evidence: `elanous logs --category ${SWEPT_DRAFT_LOG.category} --event ${SWEPT_DRAFT_LOG.event} --since 24h`,
+      createdAt: now.toISOString(), dedupeKey: `${DRAFT_CLOSE_BRIEF_SOURCE}:${today}`, dedupeWithinMs: 86_400_000 });
+    return observe({ day, closed: counted.closed, reasons: counted.reasons, text, state: 'recorded', itemId: item.id });
+  } catch (error) {
+    return observe({ day, closed: counted.closed, reasons: counted.reasons, text, state: 'unreadable',
+      detail: shortReason(`브리핑 원장 못 씀 · ${reasonOf(error)}`) });
+  }
+}
+
 /** 기본은 어제 KST 00:00–24:00, 창을 주면 그 안에 실제 병합된 PR만 센다. */
 export async function collectLandings(now: Date, window?: { from: Date; to: Date }, source?: { repoRoot?: string; repoName?: string; stateRoot?: string }): Promise<Landing[]> {
   const configuredTree = source?.repoRoot ?? getUserConfig().ops?.cronRepoRoot;
@@ -495,7 +625,8 @@ export async function runDaily(options: { dryRun?: boolean; noNews?: boolean; st
         else loopEvent('rhythm-daily', 'tick', tick);
       }
     }
-    return { file, markdown, header, risks, sections, sent, ...vault, sendError, recordError, status, deliveryState, deliveryLine };
+    return { file, markdown, header, risks, sections, sent, ...vault, sendError, recordError, status, deliveryState, deliveryLine,
+      draftCloseSummary: undefined };
   }
   const safe = async <T>(fetch: () => Promise<T>): Promise<Section<T>> => {
     try { return { status: 'ok', value: await fetch() }; } catch (e) { return unreadable(reasonOf(e)); }
@@ -589,6 +720,9 @@ export async function runDaily(options: { dryRun?: boolean; noNews?: boolean; st
     writeFileSync(file, review.markdown);
   }
   const { vaultError, vaultFatal } = options.dryRun ? { vaultError: null, vaultFatal: false } : copyToVault(review.markdown, now, deps);
+  // DRAFT-SWEEP-DAILY-SUMMARY — 어제 닫힌 draft 사유를 오늘 브리핑 원장 1건으로 적는다(PR별 댓글 0 유지).
+  // --dry-run 은 원장에 쓰지 않는다(다른 산출물과 같은 규칙).
+  const draftCloseSummary = options.dryRun ? undefined : recordDraftCloseSummary(root, now);
   let enabled = deps.sendEnabled === true;
   let sendError: string | null = null;
   let deliveryState = options.stage === 'collect' ? 'pending' : options.dryRun ? 'dry-run' : 'send-disabled';
@@ -628,7 +762,7 @@ export async function runDaily(options: { dryRun?: boolean; noNews?: boolean; st
       else loopEvent('rhythm-daily', 'tick', tick);
     }
   }
-  return { file, ...review, sent, vaultError, vaultFatal, sendError, recordError, status, deliveryState, deliveryLine };
+  return { file, ...review, sent, vaultError, vaultFatal, sendError, recordError, status, deliveryState, deliveryLine, draftCloseSummary };
 }
 
 export async function main(args: string[] = process.argv.slice(2), deps: DailyDeps = {}): Promise<Awaited<ReturnType<typeof runDaily>>> {

package/scripts/train/green-leg.ts

@@ -0,0 +1,176 @@
+import { execFile as nodeExecFile, spawn } from 'node:child_process';
+import { rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { promisify } from 'node:util';
+import { execFileSync } from 'node:child_process';
+import { validateGoalDoneEvidenceCommand } from '../../src/self-implement/goal-author.js';
+import { listChecklist, setItemIfSnapshot } from '../../src/release-loop/checklist.js';
+
+const execFile = promisify(nodeExecFile);
+const OUTPUT_TAIL_CHARS = 8_000;
+export interface CommandResult { command: string; rc: number | null; timedOut: boolean; outputTail: string; startedAt: string; endedAt: string }
+export interface GreenLegInput { version: string; cellId: string; mergeSha: string; tree: string; timeoutMs?: number }
+export interface GreenLegDeps {
+  run: (command: string, cwd: string, timeoutMs: number) => Promise<CommandResult>;
+  record: (input: GreenLegInput, evidence: string) => Promise<void>;
+  propose: (body: string) => Promise<void>;
+  now: () => string;
+  resolveLandedMerge?: (tree: string, mergeSha: string) => string;
+  getCell?: (version: string, cellId: string) => { title: string; status: string } | undefined;
+}
+
+/** Parse the train lane's required proof command and optional isolated E4 command. */
+export function completionBoundaryCommands(title: string): { evidence?: string; real?: string; errors: string[] } {
+  const errors: string[] = [];
+  const read = (label: string, optional: boolean): string | undefined => {
+    const prefix = `- 완료 경계 ${label}:`;
+    const lines = title.split(/\r?\n/u).filter((line) => line.startsWith(prefix));
+    if (lines.length > 1) { errors.push(`${label}: 중복 선언`); return; }
+    const value = lines[0]?.slice(prefix.length).trim();
+    if (!value) {
+      if (!optional) errors.push(`${label}: 선언 없음`);
+      return;
+    }
+    const parsed = validateGoalDoneEvidenceCommand(value);
+    if (!parsed.command) { errors.push(`${label}: ${parsed.error ?? '잘못된 명령'}`); return; }
+    return parsed.command;
+  };
+  return { evidence: read('증거 명령', false), real: read('실물 명령', true), errors };
+}
+
+function tokenize(command: string): string[] | null {
+  const args: string[] = [];
+  let current = '', quote: '"' | "'" | undefined, escaped = false, active = false;
+  for (const char of command) {
+    if (escaped) { current += char; escaped = false; active = true; continue; }
+    if (char === '\\' && quote !== "'") { escaped = true; active = true; continue; }
+    if (quote) { if (char === quote) quote = undefined; else current += char; active = true; continue; }
+    if (char === '"' || char === "'") { quote = char; active = true; continue; }
+    if (/\s/u.test(char)) { if (active) args.push(current); current = ''; active = false; continue; }
+    current += char; active = true;
+  }
+  if (escaped || quote) return null;
+  if (active) args.push(current);
+  return args;
+}
+
+export function validateIsolatedTestCommand(command: string): { args?: string[]; error?: string } {
+  const args = tokenize(command);
+  if (!args) return { error: '인용부호가 닫히지 않은 명령' };
+  if (args[0] !== 'bun' || args[1] !== 'test' || args.length < 3) return { error: '격리 레인에서는 bun test <시험 경로>만 실행 가능' };
+  if (args.slice(2).some((arg) => arg.startsWith('-'))) return { error: '시험 경로 외 추가 옵션은 허용하지 않음' };
+  if (args.slice(2).some((arg) => arg.split('/').includes('..') || arg.startsWith('/') || arg.includes('\\'))) return { error: '시험 경로는 트리 내부 상대 경로여야 함' };
+  return { args };
+}
+
+export function runIsolatedTestCommand(command: string, cwd: string, timeoutMs: number): Promise<CommandResult> {
+  const parsed = validateIsolatedTestCommand(command);
+  const startedAt = new Date().toISOString();
+  if (!parsed.args) return Promise.resolve({ command, rc: null, timedOut: false, outputTail: `REJECTED: ${parsed.error}`, startedAt, endedAt: new Date().toISOString() });
+  return new Promise((resolveResult) => {
+    const dir = join(tmpdir(), `eln-green-leg-${process.pid}-${Date.now()}`);
+    const child = spawn(parsed.args![0]!, parsed.args!.slice(1), {
+      cwd, shell: false, detached: true, env: { ...process.env, ELANOUS_STATE_DIR: dir },
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    let output = '', timedOut = false, done = false;
+    let forceTimer: ReturnType<typeof setTimeout> | undefined;
+    const append = (chunk: Buffer): void => { output = (output + chunk.toString('utf8')).slice(-OUTPUT_TAIL_CHARS); };
+    child.stdout.on('data', append); child.stderr.on('data', append);
+    const killGroup = (signal: NodeJS.Signals): void => {
+      if (child.pid) { try { process.kill(-child.pid, signal); } catch { /* already exited */ } }
+      else child.kill(signal);
+    };
+    const timer = setTimeout(() => { timedOut = true; killGroup('SIGTERM'); forceTimer = setTimeout(() => killGroup('SIGKILL'), 2_000); forceTimer.unref(); }, timeoutMs);
+    const finish = (rc: number | null): void => {
+      if (done) return; done = true; clearTimeout(timer); if (forceTimer) clearTimeout(forceTimer);
+      void rm(dir, { recursive: true, force: true }).finally(() => resolveResult({ command, rc, timedOut, outputTail: output, startedAt, endedAt: new Date().toISOString() }));
+    };
+    child.on('error', (error) => { append(Buffer.from(`\nSPAWN ERROR: ${error.message}`)); finish(null); });
+    child.on('close', (code) => finish(code));
+  });
+}
+
+export async function runGreenLeg(input: GreenLegInput, deps: GreenLegDeps): Promise<{ passed: boolean; results: CommandResult[]; evidence: string }> {
+  const tree = resolve(input.tree);
+  let mergeSha: string;
+  try {
+    mergeSha = deps.resolveLandedMerge?.(tree, input.mergeSha) ?? resolveLandedMerge(tree, input.mergeSha);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    const now = deps.now();
+    const evidence = [
+      `TRAIN-GREEN-LEG ${now}`,
+      `우주 표기(test:${tree})`,
+      `착지 merge SHA 검증 실패: ${input.mergeSha}`,
+      `검증 오류: ${reason}`,
+      '결과=미측정 · green 금지',
+    ].join('\n');
+    await deps.record(input, evidence);
+    await deps.propose(`evidence-only: ${input.version}/${input.cellId}; 착지 merge SHA 사전 검증 실패로 시험 미실행; 우주 test:${tree}; 입력 SHA ${input.mergeSha}; 체크리스트 상태는 변경하지 않았습니다.`);
+    return { passed: false, results: [], evidence };
+  }
+  const snapshot = deps.getCell?.(input.version, input.cellId) ?? listChecklist(input.version).items.find((item) => item.id === input.cellId);
+  if (!snapshot) throw new Error(`체크리스트 칸 없음: ${input.cellId}`);
+  if (snapshot.status !== 'yellow') throw new Error(`yellow가 아닌 칸에는 TRAIN-GREEN-LEG 실행 불가: ${snapshot.status}`);
+  const declarations = completionBoundaryCommands(snapshot.title);
+  const commands = [declarations.evidence, declarations.real].filter((value): value is string => Boolean(value));
+  const results: CommandResult[] = declarations.errors.length
+    ? [{ command: '', rc: null, timedOut: false, outputTail: `REJECTED: ${declarations.errors.join('; ')}`, startedAt: deps.now(), endedAt: deps.now() }]
+    : await runInOrder(commands, (command) => deps.run(command, tree, input.timeoutMs ?? 120_000));
+  const passed = declarations.errors.length === 0 && results.length > 0 && results.every((result) => result.rc === 0 && !result.timedOut);
+  const proposalReady = passed && Boolean(declarations.real);
+  const evidence = [
+    `TRAIN-GREEN-LEG ${deps.now()}`,
+    `우주 표기(test:${tree})`,
+    `착지 merge SHA ${mergeSha}`,
+    ...results.map((result) => `${result.command || '(선언 검증)'} | rc=${result.rc ?? 'spawn-error'} | timeout=${result.timedOut} | ${result.startedAt}..${result.endedAt}\n${result.outputTail}`),
+    `결과=${proposalReady ? '격리 E4 통과 · OP/OPT 판정 대기' : passed ? '증거 시험 통과 · 실물 E4 미선언 · human-collected 대기' : '미통과 또는 미측정 · green 금지'}`,
+  ].join('\n');
+  await deps.record(input, evidence);
+  await deps.propose(`${proposalReady ? 'propose-green' : 'evidence-only'}: ${input.version}/${input.cellId}; ${proposalReady ? '격리 E4 시험 명령 통과' : passed ? '증거 시험만 통과, 실물 E4는 human-collected 대기' : '명령 실패·시간초과·선언 거부 기록'}; 우주 test:${tree}; 착지 merge SHA ${mergeSha}. 체크리스트 상태는 변경하지 않았습니다.`);
+  return { passed, results, evidence };
+}
+
+function resolveLandedMerge(tree: string, sha: string): string {
+  if (!/^[0-9a-f]{40}$/iu.test(sha)) throw new Error('착지 merge SHA는 전체 40자리여야 합니다');
+  const full = execFileSync('git', ['-C', tree, 'rev-parse', '--verify', `${sha}^{commit}`], { encoding: 'utf8' }).trim();
+  execFileSync('git', ['-C', tree, 'merge-base', '--is-ancestor', full, 'HEAD']);
+  return full;
+}
+
+async function runInOrder<T>(items: readonly T[], run: (item: T) => Promise<CommandResult>): Promise<CommandResult[]> {
+  const results: CommandResult[] = [];
+  for (const item of items) results.push(await run(item));
+  return results;
+}
+
+export const defaultGreenLegDeps: GreenLegDeps = {
+  run: runIsolatedTestCommand,
+  now: () => new Date().toISOString(),
+  async record(input, evidence) {
+    const current = listChecklist(input.version).items.find((item) => item.id === input.cellId);
+    if (!current) throw new Error(`체크리스트 칸 없음: ${input.cellId}`);
+    if (current.status !== 'yellow') throw new Error(`yellow가 아닌 칸에는 TRAIN-GREEN-LEG 기록 불가: ${current.status}`);
+    setItemIfSnapshot(input.version, input.cellId, { evidence: [current.evidence, evidence].filter(Boolean).join('\n\n') }, 'MK', current);
+  },
+  async propose(body) { await execFile('eln', ['msg', 'post', '--from', 'MK', '--to', 'OPT', '--kind', 'report', '--body', body]); },
+};
+
+if (import.meta.main) {
+  const [version, cellId, mergeSha, tree] = process.argv.slice(2);
+  if (!version || !cellId || !mergeSha || !tree) {
+    console.error('usage: bun scripts/train/green-leg.ts <version> <cell-id> <landed-merge-sha> <test-tree>');
+    process.exitCode = 2;
+  } else {
+    try {
+      const result = await runGreenLeg({ version, cellId, mergeSha, tree }, defaultGreenLegDeps);
+      console.log(JSON.stringify({ passed: result.passed, results: result.results }, null, 2));
+      if (!result.passed) process.exitCode = 1;
+    } catch (error) {
+      console.error(error instanceof Error ? error.message : String(error));
+      process.exitCode = 1;
+    }
+  }
+}

package/scripts/tui-continue-real-evidence.ts

@@ -0,0 +1,47 @@
+// 실물 증거: 생산 모듈(src/index.ts)이 쓰는 실제 세션 저장소에서 --continue 해석을 잰다.
+// 픽스처 없음 — createProject/createSession 으로 진짜 스토어에 두 프로젝트·세션을 만든 뒤,
+// 프로덕션 함수 latestSessionIdForContinue 를 호출해 "cwd 최근 세션" 이 이기는지 본다.
+//
+//   bun scripts/tui-continue-real-evidence.ts
+import { mkdirSync, mkdtempSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+const root = mkdtempSync(join(tmpdir(), 'eln-continue-evidence-'));
+process.env.ELANOUS_STATE_DIR = join(root, 'state');
+process.env.ELANOUS_CONFIG_DIR = join(root, 'config');
+
+const cwdA = join(root, 'projA');
+const cwdB = join(root, 'projB');
+mkdirSync(join(cwdA, 'nested'), { recursive: true });
+mkdirSync(cwdB, { recursive: true });
+
+const { createProject } = await import('../src/project/project-store');
+const { createSession } = await import('../src/session/index');
+const { latestSessionIdForContinue } = await import('../src/index');
+
+const projectA = createProject({ name: 'evidence-A', primaryFolder: cwdA });
+const projectB = createProject({ name: 'evidence-B', primaryFolder: cwdB });
+
+const sessionA = createSession({ projectId: projectA.id, source: 'cli', title: 'A turn' });
+await new Promise((resolve) => setTimeout(resolve, 20));
+const sessionB = createSession({ projectId: projectB.id, source: 'cli', title: 'B turn' });
+
+const fromNested = latestSessionIdForContinue(join(cwdA, 'nested'));
+const fromNoProject = latestSessionIdForContinue(join(root, 'unassigned'));
+
+console.log(JSON.stringify({
+  store: root,
+  globalNewest: sessionB.id,
+  pickedFromCwdA: fromNested,
+  pickedIsSessionA: fromNested === sessionA.id,
+  pickedIsGlobalNewest: fromNested === sessionB.id,
+  pickedFromUnassignedCwd: fromNoProject,
+  unassignedFallsBackToGlobal: fromNoProject === sessionB.id,
+}, null, 2));
+
+if (fromNested !== sessionA.id || fromNoProject !== sessionB.id) {
+  console.error('FAIL: --continue resolution did not follow cwd project');
+  process.exit(1);
+}
+console.log('PASS: --continue picks the cwd project session, falls back to global newest elsewhere');

package/scripts/ux-sim.ts

@@ -68,6 +68,59 @@ if (argv[0] === 'emit') {
   process.exit(out.code);
 }
 
+// ── N03 키 순서열 (TUI-NEXT E4) — 진짜 PTY 에 next TUI 를 fake LLM 으로 띄워 단계별 화면 ⊕ 격리 우주 logs ──
+//   bun scripts/ux-sim.ts seat-seq <next-new-session|next-compact|next-queue|next-wakeup|next-paste|next-at-picker|next-goal-continue|next-goal-interim|next-proactive-continue|classic-400-heal|classic-400-exhausted|classic-seat-boot|classic-typing-lag|classic-wakeup|classic-paste|classic-goal-continue|classic-goal-interim|classic-orphan-autostop> --root <빈 폴더> [--installed | --executable <bun> --entry <elanous.mjs>] [--expect-sha <sha256>] [--json]
+//   기본 실행 = 이 트리 bin/elanous.mjs ⊕ 이 bun. --installed = ~/.local/share/elanous/current 의 elanous.mjs.
+//   rc: 0 = 모든 checks 참 · 1 = 거짓이 있다 · 2 = 인자 오류
+if (argv[0] === 'seat-seq') {
+  const rest = argv.slice(1);
+  const SEQ_FLAGS = new Set(['--root', '--installed', '--executable', '--entry', '--expect-sha', '--json']);
+  const SEQ_VALUED = new Set(['--root', '--executable', '--entry', '--expect-sha']);
+  const unknown = rest.filter((a) => a.startsWith('--') && !SEQ_FLAGS.has(a));
+  if (unknown.length > 0) { console.error(`⛔ 모르는 인자다: ${unknown.join(' ')} — 아는 것: ${[...SEQ_FLAGS].join(' · ')}`); process.exit(2); }
+  const value = (flag: string): string | undefined => {
+    const i = rest.indexOf(flag);
+    if (i < 0) return undefined;
+    const v = rest[i + 1];
+    if (!v || v.startsWith('--')) { console.error(`⛔ ${flag} 에 값이 필요하다`); process.exit(2); }
+    return v;
+  };
+  const { NEXT_TUI_SCENARIOS, runNextTuiScenario } = await import('../src/ux-sim/next-tui-seat-scenarios.js');
+  const { CLASSIC_TUI_SCENARIOS, runClassicTuiScenario } = await import('../src/ux-sim/classic-tui-seat-scenarios.js');
+  const ALL_SEQ: readonly string[] = [...NEXT_TUI_SCENARIOS, ...CLASSIC_TUI_SCENARIOS];
+  const scenario = rest.find((a, i) => !a.startsWith('--') && !SEQ_VALUED.has(rest[i - 1] ?? ''));
+  if (!scenario || !ALL_SEQ.includes(scenario)) { console.error(`⛔ 시나리오: ${ALL_SEQ.join(' | ')}`); process.exit(2); }
+  const root = value('--root');
+  if (!root) { console.error('⛔ --root <빈 폴더> 가 필요하다(격리 우주 · 남긴다)'); process.exit(2); }
+  const { homedir } = await import('node:os');
+  const { join: pjoin, resolve: presolve } = await import('node:path');
+  const { realpathSync } = await import('node:fs');
+  const installedEntry = pjoin(homedir(), '.local', 'share', 'elanous', 'current', 'node_modules', 'elanous', 'bin', 'elanous.mjs');
+  if (rest.includes('--installed') && rest.includes('--entry')) { console.error('⛔ --installed 와 --entry 는 함께 못 준다 — 어느 elanous.mjs 로 낸 원문인지 갈라야 한다'); process.exit(2); }
+  let entry: string;
+  if (rest.includes('--installed')) {
+    try { entry = realpathSync(installedEntry); } catch { console.error(`⛔ 설치본 없음: ${installedEntry}`); process.exit(2); }
+  } else entry = presolve(value('--entry') ?? pjoin(import.meta.dir, '..', 'bin', 'elanous.mjs'));
+  const executable = value('--executable') ?? process.execPath;
+  const expected = value('--expect-sha');
+  const pin = expected ? { expectedBinarySha256: expected } : {};
+  // classic-* = bare `elanous`(대시보드) · next-* = `--tui next`. 결과 모양은 같다(run · store · logs · checks).
+  const result = (CLASSIC_TUI_SCENARIOS as readonly string[]).includes(scenario)
+    ? await runClassicTuiScenario({ scenario: scenario as (typeof CLASSIC_TUI_SCENARIOS)[number], root, executable, entry, ...pin })
+    : await runNextTuiScenario({ scenario: scenario as (typeof NEXT_TUI_SCENARIOS)[number], root, executable, entry, ...pin });
+  if (rest.includes('--json')) console.log(JSON.stringify(result, null, 2));
+  else {
+    console.log(`scenario=${result.scenario} universe=${result.universe}`);
+    console.log(`binary=${result.run.executable} sha256=${result.run.binarySha256} entry=${result.run.args[0]} entrySha256=${result.run.entrySha256}`);
+    for (const f of result.run.frames) console.log(`===== ${f.label} =====\n${f.screen}\n`);
+    console.log(`store=${JSON.stringify(result.store)}`);
+    console.log(`logs: ${result.logs.command} (rc=${result.logs.rc})`);
+    for (const l of result.logs.lines) console.log(l);
+    for (const [k, v] of Object.entries(result.checks)) console.log(`check ${k}=${v}`);
+  }
+  process.exit(Object.values(result.checks).every(Boolean) ? 0 : 1);
+}
+
 // ⛔⭐ 모르는 인자를 «조용히 삼키지» 않는다 — 이름을 대고 거부한다.
 //
 //  🚨 2026-08-27 실측: `--trajectory-list`(오타 · 실제는 `--list-trajectories`)를 쳤더니

package/skills/README.md

@@ -66,6 +66,7 @@ bun -e '
 |---|---|---|
 | [`grill-me`](grill-me/SKILL.md) | 계획·설계를 공감대에 이를 때까지 인터뷰 | ⛔ 아니다(`disable-model-invocation`) — 사람이 부른다 |
 | [`video-builder`](video-builder/SKILL.md) | 영상 파이프라인을 «능력·구현·구간»으로 조립 — 추천 스택·크레딧·구멍 | ⛔ 아니다(`autoTrigger` 미선언) — 슬래시로 «먼저» 연다 |
+| [`floorplan-to-film`](floorplan-to-film/SKILL.md) | 평면도(PDF·이미지·치수) → 2D 수정 도면 → Blender 3D 투시도(Higgsfield Bridge MCP · 미연결 대안 cli-anything-blender) → 워크스루 영상 — 조립·자막·BGM 은 video-builder | O — `autoTrigger` 선언(«평면도로 3D»·«인테리어 영상» 명시 트리거 · 점수 2.0↑ 일 때 자동, 그 전엔 제안) |
 
 ---