elanous 0.2.11 → 0.2.13

package/src/cli/pod-memory-advice.ts

@@ -0,0 +1,35 @@
+import { readPodMemoryMeasurement, type MemoryMeasurement } from '../../scripts/measure-pod-memory-by-goal.js';
+
+export type PodMemoryAdvice = {
+  window: MemoryMeasurement['window'];
+  sources: MemoryMeasurement['sources'];
+  byGoalType: Array<{
+    goalType: MemoryMeasurement['byGoalType'][number]['goalType'];
+    recommended: 'standard' | 'high';
+    limit: '16Gi' | '32Gi';
+    reason: string;
+    evidence: MemoryMeasurement['byGoalType'][number];
+  }>;
+};
+
+/** Advice only: the launch selector and its configuration remain independent. */
+export function advisePodMemory(measurement: MemoryMeasurement): PodMemoryAdvice {
+  return {
+    window: measurement.window,
+    sources: measurement.sources,
+    byGoalType: measurement.byGoalType.map((evidence) => {
+      const high = evidence.oomKilled > 0 || (evidence.peakMiB.p95 !== null && evidence.peakMiB.p95 >= 16 * 1024);
+      const reason = evidence.oomKilled > 0
+        ? `${evidence.oomKilled}/${evidence.runs} OOMKilled; measured peak p50=${evidence.peakMiB.p50 ?? 'n/a'} MiB, p95=${evidence.peakMiB.p95 ?? 'n/a'} MiB (${evidence.measured}/${evidence.runs} measured)`
+        : evidence.measured === 0
+          ? `No measured peaks (${evidence.missingPeak}/${evidence.runs} missing); standard is provisional, not evidence of safety`
+          : `Measured peak p50=${evidence.peakMiB.p50} MiB, p95=${evidence.peakMiB.p95} MiB (${evidence.measured}/${evidence.runs} measured, ${evidence.missingPeak} missing); ${high ? 'at or above' : 'below'} 16Gi`;
+      return { goalType: evidence.goalType, recommended: high ? 'high' as const : 'standard' as const,
+        limit: high ? '32Gi' as const : '16Gi' as const, reason, evidence };
+    }),
+  };
+}
+
+export function readPodMemoryAdvice(path?: string): PodMemoryAdvice {
+  return advisePodMemory(readPodMemoryMeasurement(path));
+}

package/src/cli/pr-cli.ts

@@ -53,6 +53,7 @@ import {
 } from './pr-granularity.js';
 import { branchLineageSlug, findSiblingPrs } from './pr-lineage.js';
 import { parseReleaseNoteSection } from '../release-loop/release-note.js';
+import { enqueueL8ShadowQueue, runL8ShadowQueue, shadowPrNumber, statusL8ShadowQueue, type L8ShadowQueueDeps } from '../self-implement/l8-merge-queue.js';
 
 export { branchLineageSlug, findSiblingPrs };
 
@@ -1635,8 +1636,21 @@ export async function runPrLand(opts: PrLandOpts = {}, deps: PrLandDeps = {}): P
   return 0;
 }
 
-export function registerPrCommands(program: Command, deps: PrLandDeps = {}): void {
+export function registerPrCommands(program: Command, deps: PrLandDeps = {}, queueDeps: L8ShadowQueueDeps = {}): void {
   const pr = program.command('pr').description('PR landing commands');
+  const queue = pr.command('queue').description('Shadow merge queue (never lands PRs)');
+  const queueAction = async (action: () => Promise<unknown>) => {
+    try {
+      (deps.out ?? liveOut).log(JSON.stringify(await action()));
+    } catch (error) {
+      (deps.out ?? liveOut).error(`✗ merge-queue: ${String(error)}`);
+      (deps.setExitCode ?? ((code: number) => { process.exitCode = code; }))(1);
+    }
+  };
+  queue.command('status').description('Show pending PRs and shadow verdicts').action(() => queueAction(() => statusL8ShadowQueue(process.cwd(), queueDeps)));
+  queue.command('enqueue <pr>').description('Pin a ready PR at the tail of the shadow queue').action((prNumber: string) => queueAction(() => enqueueL8ShadowQueue(process.cwd(), shadowPrNumber(prNumber), queueDeps)));
+  queue.command('run').description('Evaluate the first PR without merging').requiredOption('--shadow', 'Only evaluate; never land').action(() => queueAction(() => runL8ShadowQueue(process.cwd(), queueDeps)));
+
   pr.command('land')
     .description('현재 브랜치 PR을 생성 또는 갱신해 ready 상태로 만들고 squash merge')
     .option('--base <branch>', 'PR base branch')

package/src/cli/release-cli.ts

@@ -23,12 +23,15 @@ import { debug } from '../debug/log.js';
 import { effectiveInstanceRoot, releaseLedgerRoot } from '../instance/resolve.js';
 import { getElanousConfigDirOverride } from '../elanous-config-dir.js';
 import { envLiteral } from '../platform/env-literal.js';
-import { userConfigPath } from '../user-config.js';
+import { getUserConfig, userConfigPath } from '../user-config.js';
 import { addItem, claimItem, decodeClaimHistoryEntry, devVersion, listChecklist, ownerMatches, parseOwner, parityGap, removeItem, seedFromRoadmap, setItem, summarizeChecklist, type ChecklistStatus, type ChecklistDisposition, type ChecklistKind } from '../release-loop/checklist.js';
 import * as features from '../release-loop/feature-store.js';
+import { evidencePlan, landedButYellow, type MergedChecklistPr } from '../release-loop/landed-but-yellow.js';
 import { formatSchedule, getSchedule, listSchedules, setSchedule } from '../release-loop/release-schedule.js';
 import { writeStdoutJson } from './stdout-json.js';
 import { CliUserError } from './cli-user-error.js';
+import { hqCliWriteAllowed, type HqDeps } from '../hq/hq.js';
+import { fileLeaseStore } from '../hq/lease.js';
 import { runUnattendedRelease, type UnattendedReleaseDeps } from '../../scripts/release-loop/unattended-release.js';
 import { cutReleaseBranch } from '../../scripts/release-loop/cut-branch.js';
 import { releaseReadiness } from '../../scripts/release-loop/release-readiness.js';
@@ -499,10 +502,48 @@ async function checklistOutput(v: string, codenames: Record<string, string>, mod
   }
 }
 
-export function registerReleaseCommands(program: Command, releaseRunDeps: UnattendedReleaseDeps = {}): void {
+export interface LandedButYellowDeps {
+  run?: Runner;
+  checklist?: typeof listChecklist;
+  now?: () => Date;
+  evidenceAdd?: typeof features.evidenceAdd;
+  schedules?: typeof features.readSchedules;
+  released?: typeof features.releasedVersion;
+}
+
+function printLandedRows(rows: ReturnType<typeof landedButYellow>, items: ReturnType<typeof listChecklist>['items']): void {
+  const updatedAtById = new Map(items.map((item) => [item.id, item.updatedAt]));
+  const date = (iso: string) => {
+    const parts = new Intl.DateTimeFormat('en-US', { timeZone: 'Asia/Seoul', month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit', hourCycle: 'h23' }).formatToParts(new Date(iso));
+    const part = (name: string) => parts.find((entry) => entry.type === name)?.value;
+    return `${part('month')}-${part('day')} ${part('hour')}:${part('minute')}`;
+  };
+  for (const row of rows) {
+    const icon = row.status === 'yellow' ? '🟡' : '🔴';
+    console.log(`${row.id} ${row.owner ?? '-'} ${icon} ← ${row.prs.map((pr, i) => `#${pr.number} «${pr.title}» (${date(pr.mergedAt)} · 근거에 ${row.alreadyInEvidence[i] ? '있음' : '없음'}${pr.mergedAt > (updatedAtById.get(row.id) ?? '') ? ' · 칸보다 새것' : ''})`).join(' · ')}`);
+  }
+  console.log(`${rows.length}칸 · 그중 근거에 없는 PR 이 있는 칸 ${rows.filter((row) => row.alreadyInEvidence.includes(false)).length}`);
+}
+
+function compareReleaseVersions(a: string, b: string): number {
+  const parse = (version: string) => {
+    const [core, pre] = version.split('-');
+    const [major, minor, patch] = core!.split('.').map(Number);
+    const [stage, sequence] = pre?.split('.') ?? [];
+    return [major!, minor!, patch!, stage === undefined ? 3 : ({ alpha: 0, beta: 1, rc: 2 } as Record<string, number>)[stage]!, Number(sequence ?? 0)];
+  };
+  const left = parse(a), right = parse(b);
+  for (let i = 0; i < left.length; i++) if (left[i] !== right[i]) return left[i]! - right[i]!;
+  return 0;
+}
+
+export function registerReleaseCommands(program: Command, releaseRunDeps: UnattendedReleaseDeps = {}, landedDeps: LandedButYellowDeps = {}, hqDeps: HqDeps = {}): void {
   const release = program.command('release').description('공개 배포 한 판 — prepare(로컬) → publish(--yes) → verify (docs/manual/MANUAL-versioning-and-release-2026-09-25.md)');
   const schedule = release.command('schedule').description('판별 컷·착지 마감 조회·갱신');
   const scheduleLedgerRoot = () => releaseRunDeps.ledgerRoot ?? releaseLedgerRoot();
+  const ledgerFenceDeps = (): HqDeps => getElanousConfigDirOverride() && !hqDeps.store && !getUserConfig().hq?.arbiter
+    ? { ...hqDeps, store: fileLeaseStore(join(effectiveInstanceRoot(), 'hq', 'lease.json')), seenPath: join(effectiveInstanceRoot(), 'hq', 'seen-generation'), localPath: join(effectiveInstanceRoot(), 'hq', 'local.json') }
+    : hqDeps;
   schedule.command('list').option('--json', '결과 JSON').action((o: { json?: boolean }) => {
     const rows = listSchedules(scheduleLedgerRoot());
     if (o.json) console.log(JSON.stringify(rows));
@@ -515,21 +556,25 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
       if (o.json) console.log(JSON.stringify(row)); else console.log(formatSchedule(row));
     });
   schedule.command('set').requiredOption('--version <v>', '갱신할 판')
-    .option('--cut-at <iso>', '오프셋 포함 컷 시각').option('--land-by <iso>', '오프셋 포함 착지 마감').option('--json', '결과 JSON')
-    .action((o: { version: string; cutAt?: string; landBy?: string; json?: boolean }) => {
+    .option('--cut-at <iso>', '오프셋 포함 컷 시각').option('--land-by <iso>', '오프셋 포함 착지 마감').option('--json', '결과 JSON').option('--hq-override')
+    .action((o: { version: string; cutAt?: string; landBy?: string; json?: boolean; hqOverride?: boolean }) => {
       if (o.cutAt === undefined && o.landBy === undefined) throw new CliUserError('갱신할 시각을 지정하라', '--cut-at <iso> 또는 --land-by <iso>');
+      if (!hqCliWriteAllowed('release schedule set', Boolean(o.hqOverride), ledgerFenceDeps())) return;
       const row = setSchedule(o.version, { cutAt: o.cutAt, landBy: o.landBy }, process.env.ELANOUS_TRACK || 'cli', scheduleLedgerRoot());
       if (o.json) console.log(JSON.stringify(row)); else console.log(formatSchedule(row));
     });
   const checklist = release.command('checklist').description('판별 확인표 조회·갱신')
     .option('--version <v>', '판 또는 별칭(기본: package.json 의 개발판에서 -dev.N 제거)')
-    .option('--json', '결과 JSON');
+    .option('--json', '결과 JSON')
+    .option('--hq-override', '본부 임대 거부를 관측하며 수동 우회');
+  const mayWrite = (cmd: Command) => hqCliWriteAllowed(`release checklist ${cmd.name()}`, Boolean(cmd.optsWithGlobals().hqOverride), ledgerFenceDeps());
   const context = (cmd: Command) => {
     const opts = { ...(cmd.parent?.parent?.opts() as { version?: string; json?: boolean }), ...(cmd.parent?.opts() as { version?: string; json?: boolean }), ...(cmd.opts() as { version?: string; json?: boolean }) };
     const codenames = checklistCodenames();
     return { version: checklistVersion(opts.version, codenames), codenames, json: opts.json };
   };
-  const withContext = (cmd: Command) => cmd.option('--version <v>', '판 또는 별칭').option('--json', '결과 JSON');
+  const withContext = (cmd: Command) => cmd.option('--version <v>', '판 또는 별칭').option('--json', '결과 JSON').option('--hq-override', '본부 임대 거부를 관측하며 수동 우회');
+  const actor = () => process.env.ELANOUS_TRACK || 'cli';
   withContext(checklist.command('list').description('모든 칸')).option('--owner <owner>', '자리 또는 하위 자리로 거르기').action(async (opts: { owner?: string }, cmd: Command) => {
     const { version, codenames, json } = context(cmd);
     await checklistOutput(version, codenames, 'list', json, opts.owner);
@@ -538,10 +583,78 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
     const { version, codenames, json } = context(cmd);
     await checklistOutput(version, codenames, 'status', json, opts.owner);
   });
+  withContext(checklist.command('landed-but-yellow').description('병합 PR 이 있지만 노랑·빨강인 칸(기본 읽기 전용)'))
+    .option('--owner <owner>', '자리 또는 하위 자리로 거르기')
+    .option('--open', '미발행 일정 판 중 칸이 있는 판 전부')
+    .option('--apply-evidence', '확실한 PR 짝의 근거를 붙인다(상태는 그대로)')
+    .option('--dry-run', '근거 추가 없이 계획만 출력')
+    .action(async (opts: { owner?: string; open?: boolean; applyEvidence?: boolean; dryRun?: boolean }, cmd: Command) => {
+      try {
+        const inherited = cmd.parent?.opts() as { version?: string; json?: boolean } | undefined;
+        const local = cmd.opts() as { version?: string; json?: boolean };
+        if (opts.open && (local.version !== undefined || inherited?.version !== undefined)) throw new CliUserError('--open 과 --version 을 함께 쓸 수 없다');
+        const json = local.json ?? inherited?.json;
+        if (opts.owner !== undefined) parseOwner(opts.owner);
+        const released = opts.open ? (landedDeps.released ?? features.releasedVersion)() : '';
+        const openSnapshots = opts.open
+          ? (landedDeps.schedules ?? features.readSchedules)()
+            .filter(({ version }) => isReleaseVersion(version) && (!released || compareReleaseVersions(version, released) > 0))
+            .sort((a, b) => compareReleaseVersions(a.version, b.version))
+            .map(({ version }) => (landedDeps.checklist ?? listChecklist)(version)).filter((snapshot) => snapshot.items.length > 0)
+          : [];
+        if (opts.open && !openSnapshots.length) {
+          if (json) await writeStdoutJson('[]\n'); else console.log('열린 판 없음');
+          return;
+        }
+        if (opts.applyEvidence && !opts.dryRun && !mayWrite(cmd)) return;
+        const since = new Date((landedDeps.now ?? (() => new Date()))().getTime() - 7 * 86_400_000).toISOString().slice(0, 10);
+        const raw = must((landedDeps.run ?? defaultRunner)('gh', ['pr', 'list', '--state', 'merged', '--search', `merged:>=${since}`, '--limit', '400', '--json', 'number,title,body,mergedAt'], process.cwd()), '병합 PR 조회(gh)');
+        const prs = JSON.parse(raw) as MergedChecklistPr[];
+        if (!Array.isArray(prs)) throw new Error('병합 PR 조회(gh): 배열이 아니다');
+        const snapshots = opts.open ? openSnapshots : [(landedDeps.checklist ?? listChecklist)(context(cmd).version)];
+        const results: Array<{ version: string; rows?: ReturnType<typeof landedButYellow>; plan?: ReturnType<typeof evidencePlan> }> = [];
+        let totalAdded = 0, totalSkipped = 0;
+        for (const snapshot of snapshots) {
+          const { version, items } = snapshot;
+          const rows = landedButYellow(items, prs, { owner: opts.owner });
+          const skippedMention = new Set(rows.flatMap((row) => row.prs.flatMap((pr) =>
+            pr.basis === 'mention' ? [JSON.stringify([row.id, pr.number])] : []))).size;
+          if (opts.open) totalSkipped += skippedMention;
+          if (opts.open && !json) console.log(`— ${version} —`);
+          if (opts.applyEvidence || opts.dryRun) {
+            const plan = evidencePlan(rows);
+            const log = json ? console.error : console.log;
+            for (const { id, ref } of plan) {
+              if (!opts.dryRun) (landedDeps.evidenceAdd ?? features.evidenceAdd)(id, version, ref, actor(), snapshot.released, snapshot.dev);
+              log(`${opts.dryRun ? '·' : '✅'} ${id} 근거 ${ref}`);
+            }
+            const added = opts.dryRun ? 0 : plan.length;
+            totalAdded += added;
+            log(`붙임 ${added} · 건너뜀(언급만) ${skippedMention}`);
+            if (!opts.open && !opts.dryRun) debug.log('release.checklist', 'evidence-synced', { added, skippedMention });
+            results.push({ version, plan });
+          } else {
+            if (!json) printLandedRows(rows, items);
+            results.push({ version, rows });
+          }
+        }
+        if (opts.open) {
+          if (opts.applyEvidence && !opts.dryRun) debug.log('release.checklist', 'evidence-synced', { versions: snapshots.map(({ version }) => version), added: totalAdded, skippedMention: totalSkipped });
+          if (!json) console.log(`판 ${snapshots.length} · 붙임 합 ${totalAdded} · 건너뜀(언급만) 합 ${totalSkipped}`);
+          else await writeStdoutJson(`${JSON.stringify(results)}\n`);
+        } else if (json) await writeStdoutJson(`${JSON.stringify(opts.applyEvidence || opts.dryRun ? results[0]!.plan : results[0]!.rows)}\n`);
+        if (prs.length >= 400) console.error('⚠ 병합 PR 400개 상한: 목록이 잘렸을 수 있다');
+      } catch (error) {
+        console.error(`⛔ ${error instanceof Error ? error.message : String(error)}`);
+        process.exitCode = 1;
+      }
+    });
   withContext(checklist.command('add <id> <title>').description('칸 추가')).option('--owner <owner>', '담당').option('--kind <kind>', 'screen = 다섯 화면 짝 칸 · 근거에 짝: PWA … · 데스크톱 … · 폴드 … · 아이폰 … · 아이패드 … 한 줄')
-    .action((id: string, title: string, opts: { owner?: string; kind?: string }, cmd: Command) => {
+    .option('--allow-duplicate-id', '다른 판에 같은 id 가 있어도 경고 후 추가')
+    .action((id: string, title: string, opts: { owner?: string; kind?: string; allowDuplicateId?: boolean }, cmd: Command) => {
     const { version, json } = context(cmd);
-    const data = addItem(version, { id, title, ...(opts.owner !== undefined ? { owner: opts.owner } : {}), ...(opts.kind !== undefined ? { kind: opts.kind as ChecklistKind } : {}) });
+    if (!mayWrite(cmd)) return;
+    const data = addItem(version, { id, title, ...(opts.owner !== undefined ? { owner: opts.owner } : {}), ...(opts.kind !== undefined ? { kind: opts.kind as ChecklistKind } : {}) }, { allowDuplicateId: opts.allowDuplicateId });
     if (json) console.log(JSON.stringify(data)); else console.log(`✅ ${id} 추가`);
   });
   withContext(checklist.command('set <id>').description('칸 상태·근거·담당·처분 갱신'))
@@ -552,6 +665,7 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
       if (opts.status !== undefined && !['green', 'yellow', 'red', 'done'].includes(opts.status)) throw new CliUserError(`잘못된 상태: ${opts.status}`, 'green|yellow|red|done');
       if (opts.disposition !== undefined && !['move', 'known-issue', 'block'].includes(opts.disposition)) throw new CliUserError(`잘못된 처분: ${opts.disposition}`, 'move|known-issue|block');
       if (opts.status === undefined && opts.evidence === undefined && opts.owner === undefined && opts.disposition === undefined && opts.kind === undefined) throw new CliUserError('갱신할 칸을 지정하라', '--status · --evidence · --owner · --disposition · --kind 중 하나');
+      if (!mayWrite(cmd)) return;
       const data = setItem(version, id, { ...(opts.status !== undefined ? { status: opts.status as ChecklistStatus } : {}), ...(opts.evidence !== undefined ? { evidence: opts.evidence } : {}), ...(opts.owner !== undefined ? { owner: opts.owner } : {}), ...(opts.disposition !== undefined ? { disposition: opts.disposition as ChecklistDisposition } : {}), ...(opts.kind !== undefined ? { kind: opts.kind as ChecklistKind } : {}) }, process.env.ELANOUS_TRACK || 'cli');
       const item = data.items.find((entry) => entry.id === id);
       const why = item?.kind === 'screen' && item.status === 'green' ? parityGap(item.evidence) : null;
@@ -565,40 +679,45 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
     .requiredOption('--by <owner>', '잡을 자리 또는 하위 자리').option('--force', '기존 주인에서 강제로 바꾼다')
     .action((id: string, opts: { by: string; force?: boolean }, cmd: Command) => {
       const { version, json } = context(cmd);
+      if (!mayWrite(cmd)) return;
       const data = claimItem(version, id, opts.by, { force: opts.force });
       if (json) console.log(JSON.stringify(data)); else console.log(`✅ ${id} 주인 ${opts.by}`);
     });
   withContext(checklist.command('rm <id>').description('칸 삭제')).action((id: string, _opts: unknown, cmd: Command) => {
     const { version, json } = context(cmd);
+    if (!mayWrite(cmd)) return;
     const data = removeItem(version, id, process.env.ELANOUS_TRACK || 'cli');
     if (json) console.log(JSON.stringify(data)); else console.log(`✅ ${id} 삭제`);
   });
   withContext(checklist.command('seed').description('마크다운 로드맵에서 빈 칸 들이기')).requiredOption('--from <file>', '로드맵 파일')
     .action((opts: { from: string }, cmd: Command) => {
       const { version, json } = context(cmd);
+      if (!mayWrite(cmd)) return;
       const data = seedFromRoadmap(version, readFileSync(opts.from, 'utf8'));
       if (json) console.log(JSON.stringify(data)); else console.log(`✅ ${version} ${data.items.length}칸`);
     });
-  const actor = () => process.env.ELANOUS_TRACK || 'cli';
   withContext(checklist.command('move <id>').description('칸을 한 트랜잭션으로 다른 판에 옮긴다'))
-    .requiredOption('--from <v>', '현재 판').requiredOption('--to <v>', '새 판')
-    .action((id: string, opts: { from: string; to: string }, cmd: Command) => {
+    .requiredOption('--from <v>', '현재 판').requiredOption('--to <v>', '새 판').option('--reason <reason>', '이동 사유')
+    .action((id: string, opts: { from: string; to: string; reason?: string }, cmd: Command) => {
       const { codenames, json } = context(cmd);
       const from = checklistVersion(opts.from, codenames), to = checklistVersion(opts.to, codenames);
-      features.move(id, from, to, actor());
+      if (!mayWrite(cmd)) return;
+      features.move(id, from, to, actor(), undefined, undefined, opts.reason);
       if (json) console.log(JSON.stringify(listChecklist(to))); else console.log(`✅ ${id} ${from} → ${to}`);
     });
   withContext(checklist.command('retitle <id> <title>').description('칸 제목 수정')).action((id: string, title: string, _opts: unknown, cmd: Command) => {
     const { version, json } = context(cmd);
+    if (!mayWrite(cmd)) return;
     const snapshot = listChecklist(version);
     features.retitle(id, title, actor(), snapshot.released, snapshot.dev);
     if (json) console.log(JSON.stringify(listChecklist(version))); else console.log(`✅ ${id} 제목 수정`);
   });
   const evidence = checklist.command('evidence').description('칸의 PR·커밋 근거');
   withContext(evidence.command('add <id> <ref>').description('근거 참조 추가')).action((id: string, ref: string, _opts: unknown, cmd: Command) => {
-    const { version, json } = context(cmd);
-    const snapshot = listChecklist(version);
-    features.evidenceAdd(id, version, ref, actor(), snapshot.released, snapshot.dev);
+      const { version, json } = context(cmd);
+      if (!mayWrite(cmd)) return;
+      const snapshot = listChecklist(version);
+      features.evidenceAdd(id, version, ref, actor(), snapshot.released, snapshot.dev);
     if (json) console.log(JSON.stringify(features.history(id).map(decodeClaimHistoryEntry))); else console.log(`✅ ${id} 근거 ${ref}`);
   });
   withContext(checklist.command('history <id>').description('칸의 판 이동·변경 이력')).action((id: string, _opts: unknown, cmd: Command) => {
@@ -614,6 +733,7 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
   });
   withContext(checklist.command('export').description('SQLite 에서 checklist.json 스냅샷 생성')).action((_opts: unknown, cmd: Command) => {
     const { version, json } = context(cmd);
+    if (!mayWrite(cmd)) return;
     const snapshot = listChecklist(version);
     features.exportJson(version, snapshot.released, snapshot.dev);
     if (json) console.log(JSON.stringify(listChecklist(version))); else console.log(`✅ ${version} checklist.json 내보냄`);

package/src/context-bus/condense.ts

@@ -0,0 +1,194 @@
+import { Database } from 'bun:sqlite';
+import { closeSync, constants, existsSync, fstatSync, lstatSync, mkdirSync, openSync } from 'node:fs';
+import { dlopen, FFIType } from 'bun:ffi';
+import { join } from 'node:path';
+import { listMemories, memoryRoot, saveMemory, type MemoryEntry } from '../memory.js';
+import { surfaceEventsDbPath } from '../domains/surface-events.js';
+import { DecisionLedger } from '../decisions/decision-ledger.js';
+import { listCoordEvents } from './coord-events.js';
+import { condenseContextWindowWithReport, type CondenseSkipped, type MemoryDeps, type MemoryItem, type MemorySource, type MemorySummary } from './long-term-memory.js';
+
+const summarize = async (source: MemorySource): Promise<MemorySummary> =>
+  (await import('./nightly-condense.js')).summarize(source);
+
+/** Reuse the context-bus reader against a strictly read-only SQLite handle. */
+function readContextEvents(since: string) {
+  const path = surfaceEventsDbPath();
+  if (!existsSync(path)) return [];
+  const db = new Database(path, { readonly: true, strict: true });
+  try { return listCoordEvents({ since }, { db }); }
+  finally { db.close(); }
+}
+
+export interface CondenseReport {
+  since: string;
+  until: string;
+  cards: MemoryItem[];
+  conflicts: number;
+  skipped: CondenseSkipped;
+  folded: number;
+  markdown: string;
+  applied?: { written: number; retired: number; decisions: string[] };
+}
+
+function mdCell(value: string): string {
+  return value.replaceAll('|', '\\|').replaceAll('\n', ' ');
+}
+
+export function renderCondenseMarkdown(report: Pick<CondenseReport, 'since' | 'until' | 'cards' | 'conflicts' | 'skipped'>): string {
+  const lines = [
+    '# Long-term context memory candidates',
+    '',
+    `Window: ${report.since} → ${report.until} · Cards: ${report.cards.length} · Conflicts: ${report.conflicts}`,
+    `Skipped: ${JSON.stringify(report.skipped)}`,
+    '',
+  ];
+  for (const card of report.cards) {
+    lines.push(`## ${mdCell(card.project)} · ${mdCell(card.seat)} · ${mdCell(card.topic)}`,
+      `- Updated: ${card.updatedAt}`,
+      `- Candidate: ${mdCell(card.summary)}`,
+      `- Source: ${card.source}`);
+    if (card.conflict) lines.push(`- 충돌 (${card.conflict.owner}): ${card.conflict.sources.join(' ↔ ')}`);
+    lines.push('');
+  }
+  return lines.join('\n').trimEnd() + '\n';
+}
+
+type CondenseStore = {
+  list(): MemoryEntry[];
+  save(input: Parameters<typeof saveMemory>[0]): MemoryEntry;
+  raise(input: Parameters<DecisionLedger['raiseOnce']>[0], ref: string): string;
+  withLock<T>(action: () => T): T;
+};
+
+/** Persistent inode in the existing memory directory: all condense writers share one cross-process lock. */
+function withMemoryLock<T>(dir: string, action: () => T): T {
+  mkdirSync(dir, { recursive: true });
+  const libc = process.platform === 'darwin' ? '/usr/lib/libSystem.B.dylib' : process.platform === 'linux' ? 'libc.so.6' : null;
+  if (!libc) throw new Error('context memory locking unavailable on this platform');
+  const lib = dlopen(libc, { flock: { args: [FFIType.i32, FFIType.i32], returns: FFIType.i32 } });
+  const flock = lib.symbols.flock as (fd: number, op: number) => number;
+  const path = join(dir, '.context-condense.lock');
+  let fd: number | undefined;
+  let acquired = false;
+  try {
+    fd = openSync(path, constants.O_CREAT | constants.O_RDWR | constants.O_NOFOLLOW, 0o600);
+    const stat = fstatSync(fd);
+    const current = lstatSync(path);
+    if (!stat.isFile() || stat.ino !== current.ino || stat.dev !== current.dev || (stat.mode & 0o077) !== 0) {
+      throw new Error('context memory lock must be a private regular file');
+    }
+    const deadline = Date.now() + 10_000;
+    const pause = new Int32Array(new SharedArrayBuffer(4));
+    while (flock(fd, 2 | 4) !== 0) {
+      if (Date.now() >= deadline) throw new Error('context memory lock timed out');
+      Atomics.wait(pause, 0, 0, 10);
+    }
+    acquired = true;
+    const locked = lstatSync(path);
+    if (stat.ino !== locked.ino || stat.dev !== locked.dev) throw new Error('context memory lock changed');
+    return action();
+  } finally {
+    if (fd !== undefined) {
+      try { if (acquired) flock(fd, 8); } finally { closeSync(fd); }
+    }
+    lib.close();
+  }
+}
+
+function defaultStore(root?: string): CondenseStore {
+  const memoryDir = root ? join(root, 'elanous', 'memory') : memoryRoot();
+  const ledger = new DecisionLedger(root ? { stateDir: root } : {});
+  return {
+    list: () => listMemories({}, memoryDir),
+    save: input => saveMemory(input, memoryDir),
+    raise: (input, ref) => ledger.raiseOnce(input, ref).id,
+    withLock: action => withMemoryLock(memoryDir, action),
+  };
+}
+
+function cardKey(card: Pick<MemoryItem, 'project' | 'seat' | 'topic'>): string {
+  return JSON.stringify([card.project, card.seat, card.topic]);
+}
+
+function newestActive(entries: readonly MemoryEntry[]): MemoryEntry | undefined {
+  return entries.reduce<MemoryEntry | undefined>((best, entry) => {
+    const current = entry.contextCard!;
+    const previous = best?.contextCard;
+    return !previous || current.updatedAt > previous.updatedAt
+      || (current.updatedAt === previous.updatedAt && current.source > previous.source)
+      || (current.updatedAt === previous.updatedAt && current.source === previous.source && entry.id > best!.id)
+      ? entry : best;
+  }, undefined);
+}
+
+/** Apply candidate cards through the existing curated memory and decision ledger paths. */
+export function applyCondensedCards(cards: readonly MemoryItem[], store: CondenseStore): NonNullable<CondenseReport['applied']> {
+  const decisions: string[] = [];
+  let written = 0;
+  let retired = 0;
+  for (const card of cards) {
+    if (card.conflict) {
+      const ref = `context-condense:${JSON.stringify([card.project, card.seat, card.topic, card.source, card.updatedAt])}`;
+      decisions.push(store.raise({
+        title: `Context conflict: ${card.project} / ${card.seat} / ${card.topic}`.slice(0, 120),
+        category: 'scope',
+        scqa: { s: `Candidate (${card.updatedAt}): ${card.summary}`.slice(0, 220), c: `Conflicting sources: ${card.conflict.sources.join(' ↔ ')}`.slice(0, 220) },
+        options: [
+          { key: 'a', label: 'Keep the existing claim', consequence: 'Candidate is not stored' },
+          { key: 'b', label: 'Reconcile and apply the new claim', consequence: 'Resolve source disagreement before memory update' },
+        ],
+        recommendation: { skipped: true, reason: 'Conflicting claims require OP judgment' },
+        raisedBy: { agent: 'context-condense', track: 'OP' },
+        refs: [ref, ...card.conflict.sources],
+      }, ref));
+      continue;
+    }
+    if (card.status !== 'active') continue;
+    const applyTopic = () => {
+      const prior = store.list().filter(entry => entry.contextCard?.status === 'active' && cardKey(entry.contextCard) === cardKey(card));
+      const winner = newestActive(prior);
+      const alreadyPresent = prior.some(entry => entry.contextCard!.updatedAt === card.updatedAt && entry.contextCard!.source === card.source);
+      if (!alreadyPresent && (!winner || winner.contextCard!.updatedAt < card.updatedAt
+        || (winner.contextCard!.updatedAt === card.updatedAt && winner.contextCard!.source < card.source))) {
+        store.save({ type: 'project', name: `${card.project} · ${card.seat} · ${card.topic}`,
+          description: card.summary, body: `${card.summary}\n\nSource: ${card.source}\nUpdated: ${card.updatedAt}\n`,
+          contextCard: { project: card.project, seat: card.seat, topic: card.topic, source: card.source, updatedAt: card.updatedAt, status: 'active' } });
+        written++;
+      }
+      const active = store.list().filter(entry => entry.contextCard?.status === 'active' && cardKey(entry.contextCard) === cardKey(card));
+      const keep = newestActive(active);
+      for (const old of active) {
+        if (old.id === keep?.id) continue;
+        store.save({ type: old.type, name: old.name, description: old.description, body: old.body, id: old.id,
+          pinned: false, priority: old.priority, contextCard: { ...old.contextCard!, status: 'retired' } });
+        retired++;
+      }
+    };
+    store.withLock(applyTopic);
+  }
+  return { written, retired, decisions };
+}
+
+/** Produce a rolling-window candidate snapshot; no store is opened for writing in dry-run. */
+export async function runContextCondense(options: {
+  hours: number; apply?: boolean; now?: Date; root?: string;
+}, deps: MemoryDeps = { summarize }, store?: CondenseStore): Promise<CondenseReport> {
+  if (!Number.isSafeInteger(options.hours) || options.hours <= 0 || options.hours > 24 * 30) {
+    throw new Error('--since must be a positive number of hours (at most 720h)');
+  }
+  const now = options.now ?? new Date();
+  const until = now.toISOString();
+  const since = new Date(now.getTime() - options.hours * 3_600_000).toISOString();
+  const { cards, skipped, folded } = await condenseContextWindowWithReport(since, until, [], {
+    summarize: deps.summarize,
+    events: deps.events ?? readContextEvents,
+    decisions: deps.decisions ?? (() => new DecisionLedger(options.root ? { stateDir: options.root } : {}).list({ status: 'all' })
+      .filter(decision => decision.raisedBy.agent !== 'context-condense')),
+  }, now);
+  const conflicts = cards.filter(card => card.conflict !== undefined).length;
+  const report: CondenseReport = { since, until, cards, conflicts, skipped, folded,
+    markdown: renderCondenseMarkdown({ since, until, cards, conflicts, skipped }) };
+  if (options.apply === true) report.applied = applyCondensedCards(cards, store ?? defaultStore(options.root));
+  return report;
+}

package/src/context-bus/context-day.ts

@@ -0,0 +1,82 @@
+import { Database } from 'bun:sqlite';
+import { existsSync } from 'node:fs';
+import { surfaceEventsDbPath } from '../domains/surface-events.js';
+
+export const CONTEXT_DAY_SOURCES = ['OP', 'TC', 'MK', 'UX', 'claude-code', 'codex-agent-mission', 'harness-child'] as const;
+export type ContextDaySource = typeof CONTEXT_DAY_SOURCES[number];
+export type ContextDayKind = 'task-claimed' | 'done' | 'asked' | 'guidance-changed';
+export interface ContextDayRow {
+  source: ContextDaySource;
+  counts: Record<ContextDayKind, number>;
+  lastAt: string | null;
+  status: '들어옴' | '안 들어옴';
+}
+export interface ContextDayReport { since: string; until: string; rows: ContextDayRow[] }
+
+/** Reject malformed windows instead of silently changing the time range being judged. */
+export function contextDayHours(since: string): number {
+  if (!/^[1-9]\d*h$/.test(since)) throw new Error('--since requires positive hours, e.g. 24h');
+  const hours = Number(since.slice(0, -1));
+  if (!Number.isSafeInteger(hours) || hours * 3_600_000 > 8.64e15) throw new Error('--since is out of range');
+  return hours;
+}
+
+function kindFor(surface: string, kind: string): ContextDayKind | null {
+  if (surface === 'context:external') {
+    if (kind === 'started' || kind === 'claimed') return 'task-claimed';
+    if (kind === 'finished' || kind === 'done') return 'done';
+    if (kind === 'guide-changed') return 'guidance-changed';
+  }
+  if (kind === 'task-claimed' || kind === 'claimed') return 'task-claimed';
+  if (kind === 'task-done' || kind === 'done') return 'done';
+  if (kind === 'asked' || (surface === 'coord:channel' && kind === '요청')) return 'asked';
+  if (kind === 'guidance-changed' || kind === 'guide-changed') return 'guidance-changed';
+  return null;
+}
+
+/** Read only the context journal, not recallEvents (which mutates recall counts) or the writable DB opener. */
+export function contextDay(since = '24h', deps: { now?: () => Date; dbPath?: string } = {}): ContextDayReport {
+  const hours = contextDayHours(since);
+  const now = (deps.now ?? (() => new Date()))();
+  const until = now.toISOString();
+  const from = new Date(now.getTime() - hours * 3_600_000).toISOString();
+  const rows: ContextDayRow[] = CONTEXT_DAY_SOURCES.map(source => ({
+    source, counts: { 'task-claimed': 0, done: 0, asked: 0, 'guidance-changed': 0 }, lastAt: null, status: '안 들어옴',
+  }));
+  const bySource = new Map(rows.map(row => [row.source, row]));
+  const path = deps.dbPath ?? surfaceEventsDbPath();
+  if (!existsSync(path)) return { since: from, until, rows };
+  const db = new Database(path, { readonly: true });
+  try {
+    const events = db.prepare(`SELECT surface, kind, ts, refs FROM events
+      WHERE surface IN ('coord:channel', 'context:session', 'context:external')
+        AND direction='outbound' AND ts>=? AND ts<=? ORDER BY ts ASC`).all(from, until) as Array<{
+      surface: string; kind: string; ts: string; refs: string | null;
+    }>;
+    for (const event of events) {
+      let refs: { seat?: unknown; origin?: unknown };
+      try { refs = JSON.parse(event.refs ?? '{}') as typeof refs; } catch { continue; }
+      const source = event.surface === 'context:external' ? refs.origin : refs.seat;
+      if (typeof source !== 'string') continue;
+      const row = bySource.get(source as ContextDaySource);
+      if (!row) continue;
+      // Do not attribute an external hook to a seat (or a seat event to an external origin).
+      if ((event.surface === 'context:external') !== (rows.indexOf(row) >= 4)) continue;
+      row.lastAt = event.ts;
+      row.status = '들어옴';
+      const kind = kindFor(event.surface, event.kind);
+      if (kind) row.counts[kind]++;
+    }
+  } finally { db.close(); }
+  return { since: from, until, rows };
+}
+
+export function renderContextDay(report: ContextDayReport): string {
+  return [
+    `맥락 이벤트 ${report.since} ~ ${report.until} (UTC)`,
+    '| 출처 | task-claimed | done | asked | guidance-changed | 마지막 시각 (UTC) | 상태 |',
+    '| --- | ---: | ---: | ---: | ---: | --- | --- |',
+    ...report.rows.map(row => `| ${row.source} | ${row.counts['task-claimed']} | ${row.counts.done} | ${row.counts.asked} | ${row.counts['guidance-changed']} | ${row.lastAt ?? '—'} | ${row.status} |`),
+    '안 들어옴 = 이 시간 창에서 해당 출처 이벤트 0건 (Claude Code 훅 미설치 가능성; 설치 여부는 미확인). 카운트 열은 네 종류만 셈.',
+  ].join('\n');
+}

package/src/context-bus/context-now-surfaces.ts

@@ -4,6 +4,23 @@ export function readSlashContextNow(args: string[], deps?: ContextNowDeps): Cont
   return contextNow({ topic: args.join(' ').trim() }, deps);
 }
 
+export function seatsNowLine(answer: ContextNowAnswer, now: number): string | null {
+  const seats = [ ['OP', 'COO'], ['MK', 'CMO'], ['TC', 'CTO'], ['UX', 'CXO'] ] as const;
+  const facts = answer.facts.filter(fact => fact.kind === 'seat');
+  const lines = seats.flatMap(([seat, label]) => {
+    const latest = facts.filter(fact => fact.seat === seat)
+      .sort((a, b) => b.at.localeCompare(a.at))[0];
+    if (!latest) return [];
+    const minutes = Math.max(0, Math.floor((now - Date.parse(latest.at)) / 60_000));
+    const age = minutes >= 24 * 60 ? '하루 넘음'
+      : minutes >= 60 ? `${Math.floor(minutes / 60)}시간 전`
+      : minutes > 0 ? `${minutes}분 전` : '방금';
+    const title = latest.title?.split(/\r?\n/, 1)[0]?.trim();
+    return [`${label} ${title ? title.slice(0, 20) : latest.status} · ${age}`];
+  });
+  return lines.length ? `지금 자리들: ${lines.join(' | ')}` : null;
+}
+
 function factText(fact: ContextFact): string {
   switch (fact.kind) {
     case 'version': return fact.version;
@@ -26,10 +43,23 @@ export function renderTelegramNow(answer: ContextNowAnswer): string {
 }
 
 export function renderTuiNow(answer: ContextNowAnswer): string[] {
+  const shortText = (text: string) => {
+    const characters = Array.from(text);
+    return characters.length > 100 ? `${characters.slice(0, 100).join('')}…` : text;
+  };
+  const shortSource = (source: string) => {
+    if (/^https?:\/\/github\.com\/[^/]+\/[^/]+\/pull\/\d+#issuecomment-/.test(source)) return '채널';
+    if (source.startsWith('elanous://release/')) return '원장';
+    return Array.from(source).slice(0, 40).join('');
+  };
+  const factLabels = { version: '판', cell: '칸', decision: '결정', seat: '자리' } as const;
+  const eventLabels: Record<string, string> = { report: '보고', dispatch: '발사', decision: '결정' };
+  const events = answer.events.slice().sort((a, b) => Date.parse(b.at) - Date.parse(a.at));
   const rows = [
-    ...answer.facts.map(f => [f.kind, factText(f), f.source]),
-    ...answer.events.map(e => [e.kind, e.summary, e.source]),
+    ...answer.facts.map(f => [factLabels[f.kind], shortText(factText(f)), shortSource(f.source)]),
+    ...events.slice(0, 8).map(e => [eventLabels[e.kind] ?? '소식', shortText(e.summary), shortSource(e.source)]),
     ...answer.guide.map(guide => ['안내', guide, '']),
+    ...(events.length > 8 ? [['안내', `… 사건 ${events.length - 8}개 더(/now <주제> 로 좁히기)`, '']] : []),
   ];
   return [
     `지금${answer.topic ? ` · ${answer.topic}` : ''} (${answer.at})`,