elanous 0.2.20 → 0.2.22

package/src/cli/tasks-cli.ts

@@ -1,4 +1,4 @@
-import { closeSync, mkdirSync, openSync, readFileSync, readSync } from 'node:fs';
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { loadRunLedger as loadRunLedgerSync } from '../self-implement/run-ledger.js';
 import { join, resolve } from 'node:path';
@@ -12,6 +12,9 @@ import type { Task } from '../task-orchestrator/types.js';
 import { cardPrNumber, COMPLETION_KINDS, handTask, nextMoveFor, readTaskAgentState, readTaskCard, taskAgentStatePath as taskStatePathDefault, shellQuote, TASK_CARD_PREFIX, TASK_SEATS, type CompletionKind, type TaskCard, type TaskLaunchContext, type TaskLaunchReceipt, type TaskLauncher, type TaskSeat } from '../task-agent/task-hand.js';
 import { readCardSalvageBranch, refreshCardRunBinding, type CardRunEvidenceDeps } from '../task-agent/card-evidence.js';
 import { advanceMission, handMission, MissionAdvanceError, openMissionIds, recordPieceRef, type AdvanceMissionResult, type MissionDecompose, type PieceEvidenceReader } from '../task-agent/mission.js';
+import { formatTaskAgentCover, measureTaskAgentCover, type CoverRow, type TaskAgentCoverInput } from '../task-agent/cover.js';
+import { LogStore, STORE_SAFETY_MAX, type LogQuery, type LogStoreRow } from '../mss/logging/log-store.js';
+import { resolveLogTargets } from './logs-cli.js';
 
 type TaskRow = Pick<Task, 'id' | 'title' | 'priority' | 'status' | 'createdAt' | 'approval' | 'generatedBy'>;
 
@@ -34,6 +37,13 @@ export interface TasksCliDeps {
   releaseBoard?: () => BoardNode[];
   /** `tasks show`·`advance` 의 런 근거 읽기(시험 주입) — 기본 = 런 원장(이 우주 ⊕ 연합) ⊕ 호스트 logs 의 Pod job-finished. */
   cardRunEvidence?: CardRunEvidenceDeps;
+  /** HARNESS-PARENT-ON-MSB1 — 원격 부모 카드의 원장 거울(시험 주입). 기본 = ssh 로 `<prodRoot>/remote-parents/<host>/run-ledger`. */
+  remoteLedgerMirror?: (card: TaskCard) => void;
+  /** `tasks parents` 의 낡은 부모 보고 의존(시험 주입). */
+  staleParents?: import('../task-agent/parent-host.js').StaleParentDeps;
+  /** `tasks cover` logs 조회 seam. 기본은 등록된 모든 우주(운영 ⊕ test)의 logs.db 를 read-only 로 연다 —
+   *  pr land 는 작업 트리마다 파생 test 우주에 기록되므로 현재 우주만 읽으면 분모가 늘 0 이다. */
+  coverLogs?: (query: LogQuery) => LogStoreRow[] | CoverLogRead;
 }
 
 /** `<조각id>=<값>` 반복 인자. */
@@ -97,6 +107,60 @@ export interface DefaultTaskLauncherDeps {
   writeStop?: import('../self-implement/run-ledger.js').RunLedgerWriter;
   /** 이미 stop 이 있나(시험 주입). 기본 = 이 우주 런 원장 ⊕ 이 프로세스 기록. */
   hasStop?: (runId: string) => boolean;
+  /** HARNESS-PARENT-ON-MSB1 — 원격 부모 대상(시험 주입). undefined = 설정·env 에서 푼다 · null = 끔. */
+  parentHost?: import('../task-agent/parent-host.js').ParentHostConfig | null;
+  /** 원격 ssh(시험 주입). */
+  ssh?: import('../task-agent/parent-host.js').SshRunner;
+  /** HQ 발사 동결(holdLaunches) 여부(시험 주입). */
+  launchHoldActive?: () => boolean;
+  /** HQ 판(시험 주입). */
+  localVersion?: string;
+  /** 원격 → 로컬 되돌림 알림(시험 주입). 기본 = stderr 한 줄. */
+  notice?: (line: string) => void;
+}
+
+/**
+ * HARNESS-PARENT-ON-MSB1 — 켜져 있고 발사 전 점검이 통과하면 원격(ssh)에서 부모를 띄운다(PR 까지만 · 병합은 HQ).
+ * 막히면 null — 호출부가 종전 로컬 발사로 간다(관측: task-agent parent-host-fallback).
+ */
+async function tryRemoteParent(args: string[], cwd: string | undefined, context: TaskLaunchContext, deps: DefaultTaskLauncherDeps): Promise<TaskLaunchReceipt | null> {
+  const parentHostModule = await import('../task-agent/parent-host.js');
+  let target = deps.parentHost;
+  if (target === undefined) {
+    const { getUserConfig } = await import('../user-config.js');
+    let configured: Parameters<typeof parentHostModule.resolveParentHost>[0];
+    try { configured = getUserConfig().taskAgent?.parentHost; } catch { configured = undefined; }
+    target = parentHostModule.resolveParentHost(configured);
+  }
+  if (!target) return null;
+  const notice = deps.notice ?? ((line: string) => { try { process.stderr.write(`${line}\n`); } catch { /* ignore */ } });
+  const fallback = (gaps: string[], facts: Record<string, string> = {}): null => {
+    try { debug.log('task-agent', 'parent-host-fallback', { host: target!.host, runId: context.runId, gaps, facts }); } catch { /* fail-soft */ }
+    notice(`[parent-host] ${target!.host} 로 못 띄움 — 로컬 발사로 간다: ${gaps.join(' · ')}`);
+    return null;
+  };
+  if (cwd) return fallback(['project-target-is-local']);
+  let launchHoldActive = false;
+  try {
+    if (deps.launchHoldActive) launchHoldActive = deps.launchHoldActive();
+    else {
+      const { readLandingFreeze } = await import('../release-loop/landing-freeze.js');
+      const { prodInstanceRoot } = await import('../instance/resolve.js');
+      launchHoldActive = readLandingFreeze(prodInstanceRoot())?.holdLaunches === true;
+    }
+  } catch { launchHoldActive = true; /* 못 읽으면 막힌 것으로(fail-closed) */ }
+  const preflight = parentHostModule.preflightParentHost({ target, localVersion: deps.localVersion ?? parentHostModule.localElanousVersion(), launchHoldActive, ...(deps.ssh ? { ssh: deps.ssh } : {}) });
+  if (!preflight.ok) return fallback(preflight.gaps, preflight.facts);
+  try {
+    const launched = parentHostModule.launchRemoteParent(target, args, context.env, deps.ssh);
+    try { debug.log('task-agent', 'parent-host-launched', { host: target.host, runId: context.runId, pid: launched.pid, log: launched.log }); } catch { /* fail-soft */ }
+    return { runId: context.runId, parentHost: { host: target.host, ...(target.configDir ? { configDir: target.configDir } : {}), pid: launched.pid, log: launched.log } };
+  } catch (error) {
+    // «확실히 안 떴다»일 때만 로컬로 — 불확실(ssh 끊김 등)은 던져 카드를 launch-failed 로 남긴다(중복 발사 방지).
+    if (error instanceof parentHostModule.RemoteParentNotLaunchedError) return fallback([error.message]);
+    try { debug.log('task-agent', 'parent-host-launch-uncertain', { host: target.host, runId: context.runId, error: error instanceof Error ? error.message : String(error) }); } catch { /* fail-soft */ }
+    throw error;
+  }
 }
 
 /** stderr 파일의 첫 비어 있지 않은 줄(최대 4KB 만 읽는다 — 원 로그 꼬리를 싣지 않는다). */
@@ -112,6 +176,10 @@ function firstStderrLine(path: string): string {
 }
 
 export async function defaultTaskLauncher(args: string[], cwd?: string, context?: TaskLaunchContext, deps: DefaultTaskLauncherDeps = {}): Promise<void | TaskLaunchReceipt> {
+  if (context) {
+    const remote = await tryRemoteParent(args, cwd, context, deps);
+    if (remote) return remote;
+  }
   const spawn = deps.spawn ?? ((await import('node:child_process')).spawn as unknown as DetachedSpawn);
   const { getElanousConfigDirOverride } = await import('../elanous-config-dir.js');
   const { prodInstanceRoot } = await import('../instance/resolve.js');
@@ -208,6 +276,21 @@ export function spawnDetachedConfirmed(spawnFn: DetachedSpawn, command: string,
   });
 }
 
+/** HARNESS-PARENT-ON-MSB1 — 카드가 원격 부모면 그 런 원장(⊕ Pod 자식)을 HQ 거울로 당긴다. 실패는 관측만(«없음»으로 읽히지 않게). */
+async function mirrorRemoteCardLedger(cardId: string, deps: TasksCliDeps): Promise<void> {
+  let card: TaskCard | undefined;
+  try { card = readTaskCard(cardId, deps.taskStatePath); } catch { return; }
+  if (!card?.parentHost || !card.runId) return;
+  try {
+    if (deps.remoteLedgerMirror) { deps.remoteLedgerMirror(card); return; }
+    const { mirrorRemoteRunLedgers } = await import('../task-agent/parent-host.js');
+    const { prodInstanceRoot } = await import('../instance/resolve.js');
+    mirrorRemoteRunLedgers(card.parentHost, card.runId, prodInstanceRoot());
+  } catch (error) {
+    try { debug.log('task-agent', 'remote-ledger-mirror-failed', { card: cardId, host: card.parentHost.host, runId: card.runId, error: error instanceof Error ? error.message : String(error) }); } catch { /* fail-soft */ }
+  }
+}
+
 function moveLine(card: TaskCard): string {
   const move = nextMoveFor(card);
   return `${move.kind}${move.command ? ` — elanous ${move.command.map(shellQuote).join(' ')}` : ''} (${move.reason})`;
@@ -313,6 +396,74 @@ function handleError(error: unknown, out: (line: string) => void): void {
   }
 }
 
+const COVER_QUERY_LIMIT = STORE_SAFETY_MAX;
+
+/** Federated read: rows from every store, whether any single store hit the bound, and how many stores could not be read. */
+export interface CoverLogRead { rows: LogStoreRow[]; limitReached: boolean; unreadableStores: number; storesRead: number }
+
+function queryCoverLogs(query: LogQuery): CoverLogRead {
+  const { targets, error } = resolveLogTargets({ all: true, includeTest: true });
+  if (error) throw new Error(error);
+  const read: CoverLogRead = { rows: [], limitReached: false, unreadableStores: 0, storesRead: 0 };
+  for (const target of targets) {
+    if (!existsSync(target.dbPath)) continue;
+    let store: LogStore | undefined;
+    try {
+      store = LogStore.openReadOnly(target.dbPath);
+      const rows = store.query(query);
+      if (query.limit !== undefined && rows.length >= query.limit) read.limitReached = true;
+      read.rows.push(...rows);
+      read.storesRead++;
+    } catch { read.unreadableStores++; }
+    finally { try { store?.close(); } catch { /* already closed */ } }
+  }
+  if (read.storesRead === 0) throw new Error('읽을 수 있는 logs.db 없음');
+  return read;
+}
+
+function coverEvents<T>(rows: readonly LogStoreRow[], category: string, event: string, parse: (data: Record<string, unknown>) => T | null): T[] {
+  const events: T[] = [];
+  for (const row of rows) {
+    if (row.category !== category || row.event !== event || !row.data) continue;
+    try {
+      const data: unknown = JSON.parse(row.data);
+      if (data === null || typeof data !== 'object' || Array.isArray(data)) continue;
+      const parsed = parse(data as Record<string, unknown>);
+      if (parsed !== null) events.push(parsed);
+    } catch { /* malformed log data is not evidence of an action */ }
+  }
+  return events;
+}
+
+export function readTaskAgentCover(
+  window: { sinceMs?: number; untilMs?: number } = {},
+  query: NonNullable<TasksCliDeps['coverLogs']> = queryCoverLogs,
+): { rows: CoverRow[]; limitReached: boolean; unreadableStores: number } {
+  let unreadableStores = 0;
+  const read = (category: 'task-agent' | 'pr.land', event: 'action' | 'step'): { rows: LogStoreRow[]; limitReached: boolean } | null => {
+    try {
+      const result = query({ ...window, limit: COVER_QUERY_LIMIT, exactCategories: [category], events: [event] });
+      if (Array.isArray(result)) return { rows: result, limitReached: result.length >= COVER_QUERY_LIMIT };
+      unreadableStores = Math.max(unreadableStores, result.unreadableStores);
+      return { rows: result.rows, limitReached: result.limitReached };
+    } catch { return null; }
+  };
+  const actionRead = read('task-agent', 'action');
+  const landRead = read('pr.land', 'step');
+  const actions = actionRead?.rows ?? null;
+  const lands = landRead?.rows ?? null;
+  const truncated = { taskAgentActions: actionRead?.limitReached === true, allLands: landRead?.limitReached === true };
+  const input: TaskAgentCoverInput = {
+    taskAgentActions: actions === null ? null : coverEvents(actions, 'task-agent', 'action', (data) =>
+      typeof data.kind === 'string' && typeof data.result === 'string'
+        ? { kind: data.kind as NonNullable<TaskAgentCoverInput['taskAgentActions']>[number]['kind'], result: data.result } : null),
+    allLands: lands === null ? null : coverEvents(lands, 'pr.land', 'step', (data) =>
+      typeof data.step === 'string' && typeof data.ok === 'boolean' ? { step: data.step, ok: data.ok } : null),
+    truncated,
+  };
+  return { rows: measureTaskAgentCover(input), limitReached: truncated.taskAgentActions || truncated.allLands, unreadableStores };
+}
+
 export function registerTasksCommands(program: Command, deps: TasksCliDeps = {}): void {
   let activeToken: string | undefined;
   const output = deps.output ?? console.log;
@@ -325,6 +476,39 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
   };
   const tasks = program.command('tasks').alias('task').description('TOX 태스크 조회 및 승인 · TASK-AGENT 과제 넘기기(hand)');
 
+  tasks.command('cover')
+    .description('TASK-AGENT 가 대신한 착지 비율과 리뷰·재발사·green 의 아직 없는 분모를 조회(읽기 전용)')
+    .option('--since <iso>', '시작 시각 (ISO)')
+    .option('--until <iso>', '끝 시각 (ISO)')
+    .option('--json', 'JSON 출력')
+    .option('--lines', '동사별 한 줄 요약 출력 (읽기 전용)')
+    .action((opts: { since?: string; until?: string; json?: boolean; lines?: boolean }) => {
+      const parseIso = (value: string | undefined, flag: string): number | undefined => {
+        if (value === undefined) return undefined;
+        const time = Date.parse(value);
+        if (!/^\d{4}-\d{2}-\d{2}T.*(?:Z|[+-]\d\d:\d\d)$/.test(value) || !Number.isFinite(time)) throw new Error(`${flag} 는 ISO 시각이어야 한다`);
+        return time;
+      };
+      try {
+        const sinceMs = parseIso(opts.since, '--since');
+        const untilMs = parseIso(opts.until, '--until');
+        if (sinceMs !== undefined && untilMs !== undefined && sinceMs > untilMs) throw new Error('--since 가 --until 보다 늦다');
+        const { rows, limitReached, unreadableStores } = readTaskAgentCover({ sinceMs, untilMs }, deps.coverLogs);
+        const limitWarning = limitReached ? `조회 상한 ${COVER_QUERY_LIMIT} 도달 — 더 오래된 사건이 있을 수 있다(절단된 수를 전체로 읽지 말 것)` : null;
+        const storeWarning = unreadableStores > 0 ? `logs.db ${unreadableStores}개를 못 읽었다 — 그 우주의 사건은 수에 없다(«없다»로 읽지 말 것)` : null;
+        if (opts.json) out(JSON.stringify({ rows, limitReached, unreadableStores, ...(limitWarning ? { warning: limitWarning } : {}), ...(storeWarning ? { storeWarning } : {}) }));
+        else {
+          if (opts.lines) for (const row of rows) out(formatTaskAgentCover(row));
+          else {
+            out('동사\t대신\t전체\t비율\t상태\t관측 사건');
+            for (const row of rows) out(`${row.verb}\t${row.byTaskAgent ?? '-'}\t${row.total ?? '-'}\t${row.ratio ?? '-'}\t${row.state}\t${row.observedActions ?? '-'}`);
+          }
+          if (limitWarning) out(`⚠ ${limitWarning}`);
+          if (storeWarning) out(`⚠ ${storeWarning}`);
+        }
+      } catch (error) { out(error instanceof Error ? error.message : '커버 조회 실패'); process.exitCode = 1; }
+    });
+
   tasks.command('list')
     .description('우선순위와 생성 시각 순으로 태스크 보기')
     .option('--status <s>', '상태로 필터')
@@ -442,6 +626,32 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
       }
     });
 
+  tasks.command('parents')
+    .description('낡은 하니스 부모 보고(읽기 전용 · 죽이지 않는다) — 나이 ≥ N 시간이고 런 원장이 끝났거나(run-status) Pod 이 없는 `harness say|ask` 부모')
+    .option('--older-than <hours>', '나이 하한(시간)', '6')
+    .option('--no-pods', 'Pod 목록을 재지 않는다(원장 근거만)')
+    .option('--json', 'JSON 출력')
+    .action(async (opts: { olderThan: string; pods?: boolean; json?: boolean }) => {
+      const hours = Number(opts.olderThan);
+      if (!Number.isFinite(hours) || hours < 0) { out(`--older-than 는 0 이상 수다: ${opts.olderThan}`); process.exitCode = 1; return; }
+      const { staleHarnessParents } = await import('../task-agent/parent-host.js');
+      const injected = deps.staleParents ?? {};
+      const loadLedger = injected.loadLedger ?? ((runId: string) => loadRunLedgerSync(runId));
+      let podRuns = injected.podRuns;
+      let labelOf = injected.labelOf;
+      if (!podRuns && opts.pods !== false) {
+        const queue = await import('../harness/harness-queue.js');
+        podRuns = () => queue.readHarnessQueuePodRuns();
+        labelOf = queue.queueRunLabelValue;
+      }
+      const report = staleHarnessParents(hours, { ...injected, loadLedger, ...(podRuns ? { podRuns } : {}), ...(labelOf ? { labelOf } : {}) });
+      try { debug.log('task-agent', 'stale-parents', { olderThanHours: hours, scanned: report.scanned, stale: report.rows.length, podRunsMeasured: report.podRunsMeasured }); } catch { /* fail-soft */ }
+      if (opts.json) { out(JSON.stringify({ olderThanHours: hours, ...report })); return; }
+      out(`하니스 부모 ${report.scanned} · 나이 ≥ ${hours}h 중 낡음 후보 ${report.rows.length}${report.podRunsMeasured ? '' : ' · ⚠ Pod 목록 못 잼(원장 근거만)'} — 읽기 전용(죽이지 않는다)`);
+      out('pid\t나이h\t자리\t판\t런\t사유');
+      for (const row of report.rows) out([row.pid, row.ageHours, row.seat ?? '-', row.version ?? '-', row.runId ?? '-', row.reasons.join(',')].join('\t'));
+    });
+
   tasks.command('board')
     .description('보드 — 프로젝트 › 목표 › 이정표 › 과제. 과제 카드(project·goal·milestone)와 내부 팩(릴리스 체크리스트 = elanous › 판 › 칸)을 합쳐 읽는다(쓰지 않는다)')
     .option('--project <id>', '이 프로젝트만')
@@ -569,6 +779,8 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
           // 런 id 가 있으면 원장에서 골 id · PR 을 묶는다(찾았을 때만 적는다 · 실패는 그대로 보인다).
           const bindable = card?.pieces ? card.pieces : card ? [card.id] : [];
           for (const cardId of bindable) {
+            // HARNESS-PARENT-ON-MSB1: 원격 부모 런은 원장이 그 호스트에 있다 — HQ 거울로 먼저 당긴다(읽기 전용).
+            await mirrorRemoteCardLedger(cardId, deps);
             try { await refreshCardRunBinding(cardId, deps.taskStatePath ?? taskStatePathDefault(), deps.cardRunEvidence ?? {}); } catch (error) {
               // 근거 없음으로 보인다 — 원장 부재와 갈리게 실패는 남긴다.
               try { debug.log('task-agent', 'card-bind-failed', { card: cardId, via: 'show', error: error instanceof Error ? error.message : String(error) }); } catch { /* fail-soft */ }
@@ -608,6 +820,7 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
         if (opts.json) out(JSON.stringify({ card, nextMove: nextMoveFor(card), salvageBranch: salvage.salvageBranch, ...(salvageUnread ? { salvageBranchUnread: true } : {}) }));
         else {
           for (const line of taskCardLines(card)) out(line);
+          if (card.parentHost) out(`부모 호스트: ${card.parentHost.host}${card.parentHost.pid ? ` (pid ${card.parentHost.pid})` : ''} · PR 까지만 — 병합은 HQ${card.parentHost.log ? ` · 로그 ${card.parentHost.host}:${card.parentHost.log}` : ''}`);
           if (salvage.salvageBranch) out(`수확 가지: ${salvage.salvageBranch} (draft PR 대신)`);
           else if (salvageUnread) out('수확 가지: 못 읽음(원장 읽기 실패)');
         }

package/src/connectors/types.ts

@@ -1,5 +1,5 @@
-export interface ExternalTaskEvent {
-  provider: 'linear' | 'asana';
+export interface ExternalTaskEvent<Provider extends string = 'linear' | 'asana'> {
+  provider: Provider;
   eventId: string;
   kind: 'created' | 'updated';
   ref: string;
@@ -11,9 +11,9 @@ export interface ExternalTaskEvent {
   occurredAt: string;
 }
 
-export interface TaskConnector {
-  provider: ExternalTaskEvent['provider'];
+export interface TaskConnector<Provider extends string = ExternalTaskEvent['provider']> {
+  provider: Provider;
   verify(req: { rawBody: string | Uint8Array; signature: string; secret: string; now?: number }): { ok: true } | { ok: false; reason: string };
-  parse(body: unknown, deliveryId: string): ExternalTaskEvent | null;
-  idempotencyKey(event: ExternalTaskEvent): string;
+  parse(body: unknown, deliveryId: string): ExternalTaskEvent<Provider> | null;
+  idempotencyKey(event: ExternalTaskEvent<Provider>): string;
 }

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

@@ -53,6 +53,24 @@ export function renderTelegramNow(input: ContextNowAnswer, audience: ContextNowA
   return lines.map(line => line.replace(/\s+/g, ' ').trim()).join('\n');
 }
 
+/** Context-first opening for chat connectors: up to three operational rows (live runs, an unfinished
+ *  release run, late schedules) ahead of the same `/now` body. `/now` itself stays unchanged. */
+export function renderContextFirstNow(input: ContextNowAnswer, audience: ContextNowAudience = 'operator'): string {
+  const answer = forAudience(input, audience);
+  const labels = { run: '도는 런', release: '발행 런', 'schedule-late': '지연 스케줄' } as const;
+  const operational = answer.facts.filter(fact => fact.kind === 'run' ||
+    (fact.kind === 'release' && (fact.unreadable || fact.status !== 'done')) ||
+    (fact.kind === 'schedule-late' && (fact.unreadable || !!fact.count)));
+  // Run goals are whole asks (often thousands of characters); one line each keeps the opening to one screen.
+  const short = (text: string) => { const chars = Array.from(text); return chars.length > 60 ? `${chars.slice(0, 60).join('')}…` : text; };
+  const lines = operational.slice(0, 3).map(fact => {
+    const text = fact.kind === 'run' && !fact.unreadable ? `${short(fact.goal.replace(/\s+/g, ' ').trim())} · ${fact.phase} · ${fact.elapsed}` : factText(fact);
+    return `${labels[fact.kind as keyof typeof labels]}: ${text} — ${fact.source}`.replace(/\s+/g, ' ').trim();
+  });
+  if (operational.length > lines.length) lines.push(`… 운영 항목 ${operational.length - lines.length}개 더 (/now)`);
+  return [...lines, renderTelegramNow(answer, 'operator')].join('\n');
+}
+
 export function renderTuiNow(input: ContextNowAnswer, audience: ContextNowAudience = 'operator'): string[] {
   const answer = forAudience(input, audience);
   const shortText = (text: string) => {

package/src/context-bus/coord-events.ts

@@ -2,7 +2,9 @@ import { Database } from 'bun:sqlite';
 import { readFileSync, existsSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { debug, redactSecretText } from '../debug/log.js';
+import { DecisionLedger, type Seat } from '../decisions/decision-ledger.js';
 import { openSurfaceEventsDb, recordEvent, surfaceEventsDbPath } from '../domains/surface-events.js';
+import { registeredSeats } from '../seat-address/seat-address.js';
 
 export interface CoordEventInput {
   seat: string;
@@ -31,6 +33,13 @@ function seatIds(): Set<string> {
 }
 const kinds = new Set(['요청', '결정', '사고', '보고', '정정']);
 
+function cleanCoordHeadline(value: string): string {
+  const first = value.split(/\r?\n/, 1)[0] ?? '';
+  const withoutPrefix = first.replace(/^\*\*\[[A-Z]+\]\*\*\s*/, '')
+    .replace(/^(?:📌안내\s*)?\d{4}-\d\d-\d\d\s+\d\d:\d\d\s+KST\s*/, '');
+  return redactSecretText(withoutPrefix).trim().slice(0, 120);
+}
+
 /** Mirror the sender's ordered envelope fields; only the first line enters this parser. */
 export function parseCoordHeader(seat: string, header: string): Omit<CoordEventInput, 'url' | 'at'> {
   const first = header.split(/\r?\n/, 1)[0] ?? '';
@@ -69,10 +78,7 @@ export function recordCoordEvent(input: CoordEventInput, deps: { db?: Database }
   try {
     db = deps.db ?? openSurfaceEventsDb();
     const at = input.at ?? new Date().toISOString();
-    const first = input.headline.split(/\r?\n/, 1)[0] ?? '';
-    const withoutPrefix = first.replace(/^\*\*\[[A-Z]+\]\*\*\s*/, '')
-      .replace(/^(?:📌안내\s*)?\d{4}-\d\d-\d\d\s+\d\d:\d\d\s+KST\s*/, '');
-    const headline = redactSecretText(withoutPrefix).trim().slice(0, 120);
+    const headline = cleanCoordHeadline(input.headline);
     const safe = (value: string) => redactSecretText(value.split(/\r?\n/, 1)[0] ?? '');
     const refs = { seat: safe(input.seat), recipients: input.recipients.map(safe), all: input.all,
       kind: input.kind === null ? null : safe(input.kind), slot: input.slot === null ? null : safe(input.slot),
@@ -98,6 +104,28 @@ export function recordCoordEvent(input: CoordEventInput, deps: { db?: Database }
   } finally { if (!deps.db) db?.close(); }
 }
 
+/** A failed decision mirror must never turn a successful channel/context record into a failure. */
+export function mirrorCoordDecision(input: CoordEventInput, deps: { ledger?: Pick<DecisionLedger, 'recordSeatDecision'> } = {}): void {
+  if (input.kind !== '결정') return;
+  try {
+    if (!registeredSeats().some(({ id }) => id === input.seat)) return;
+    const entry = (deps.ledger ?? new DecisionLedger()).recordSeatDecision({
+      seat: input.seat as Seat,
+      title: input.slot ? redactSecretText(input.slot.split(/\r?\n/, 1)[0] ?? '').trim() : cleanCoordHeadline(input.headline),
+      decision: cleanCoordHeadline(input.headline),
+      delegation: '조율 채널 — 자리 위임 범위',
+      ...(input.url ? { refs: [input.url] } : {}),
+      decidedAt: input.at ?? new Date().toISOString(),
+    });
+    try { debug.log('context.coord', 'decision-mirrored', { seat: entry.seat, id: entry.id }); }
+    catch { /* observation cannot turn a successful write into a failed send */ }
+  } catch (error) {
+    if (error instanceof Error && error.message === 'seat decision source already recorded') return;
+    try { debug.log('context.coord', 'decision-mirror-failed', { seat: redactSecretText(input.seat) }); }
+    catch { /* observation cannot turn a successful send into a failure */ }
+  }
+}
+
 /** Read-only chronological list; a missing store is an empty ledger, not a newly created one. */
 export function listCoordEvents(opts: { since: string; seat?: string; channelOnly?: boolean }, deps: { db?: Database } = {}): CoordEvent[] {
   if (!deps.db && !existsSync(surfaceEventsDbPath())) return [];

package/src/context-bus/long-term-memory.ts

@@ -18,6 +18,14 @@ export interface MemoryItem {
   conflict?: { owner: 'OP'; sources: [string, string] };
 }
 
+/** Guardian retention boundary: lifecycle hygiene, independent of librarian promotion. */
+export function guardianRetireAged(items: readonly MemoryItem[], now: Date): MemoryItem[] {
+  const cutoff = now.getTime() - 30 * DAY_MS;
+  return items.map(item => ({ ...item,
+    status: Date.parse(item.updatedAt) < cutoff ? 'retired' as const : item.status,
+  }));
+}
+
 export type MemorySource =
   | { kind: 'event'; at: string; seat: string; text: string; source: string }
   | { kind: 'decision'; at: string; seat: string; text: string; source: string };
@@ -28,6 +36,8 @@ export interface MemorySummary {
   summary: string;
   /** Only supply this when the two strings identify the same fact and mutually exclusive values. */
   claim?: { key: string; value: string };
+  /** Sleep-review task agent's promotion decision; not stored in a MemoryItem. */
+  promote?: boolean;
 }
 
 type CondenseEvent = CoordEvent & { surface?: string };
@@ -38,7 +48,7 @@ export interface MemoryDeps {
   decisions?: () => DecisionEntry[];
 }
 
-export type CondenseSkipReason = 'no-seat' | 'no-project' | 'no-topic' | 'no-summary' | 'bad-link' | 'bad-claim' | 'no-claim' | 'summarize-failed';
+export type CondenseSkipReason = 'not-promoted' | 'no-seat' | 'no-project' | 'no-topic' | 'no-summary' | 'bad-link' | 'bad-claim' | 'no-claim' | 'summarize-failed';
 export type CondenseSkipped = Partial<Record<CondenseSkipReason, number>>;
 export interface FunnelCount { total: number; bySeat: Record<string, number> }
 export interface CondenseFunnel {
@@ -77,22 +87,25 @@ export function readCondenseEvents(since: string): CondenseEvent[] {
 /** Condense one UTC day; callers persist the returned snapshot, not raw transcripts. Read-only ledger access. */
 export async function condenseContextDay(
   day: string, previous: readonly MemoryItem[], deps: MemoryDeps, now: Date = new Date(),
+  policy: { promotion?: 'sleep-review'; retention?: 'guardian' } = {},
 ): Promise<MemoryItem[]> {
   if (!/^\d{4}-\d\d-\d\d$/.test(day) || new Date(`${day}T00:00:00.000Z`).toISOString().slice(0, 10) !== day) {
     throw new Error('day must be a valid UTC YYYY-MM-DD');
   }
-  return condenseContextWindow(`${day}T00:00:00.000Z`, new Date(Date.parse(`${day}T00:00:00.000Z`) + DAY_MS).toISOString(), previous, deps, now);
+  return condenseContextWindow(`${day}T00:00:00.000Z`, new Date(Date.parse(`${day}T00:00:00.000Z`) + DAY_MS).toISOString(), previous, deps, now, policy);
 }
 
 /** Read-only condensation over an exact rolling UTC window; the caller owns any persistence. */
 export async function condenseContextWindow(
   since: string, until: string, previous: readonly MemoryItem[], deps: MemoryDeps, now: Date = new Date(),
+  policy: { promotion?: 'sleep-review'; retention?: 'guardian' } = {},
 ): Promise<MemoryItem[]> {
-  return (await condenseContextWindowWithReport(since, until, previous, deps, now)).cards;
+  return (await condenseContextWindowWithReport(since, until, previous, deps, now, policy)).cards;
 }
 
 export async function condenseContextWindowWithReport(
   since: string, until: string, previous: readonly MemoryItem[], deps: MemoryDeps, now: Date = new Date(),
+  policy: { promotion?: 'sleep-review'; retention?: 'guardian' } = {},
 ): Promise<CondenseWindowReport> {
   const start = Date.parse(since);
   const end = Date.parse(until);
@@ -228,6 +241,7 @@ export async function condenseContextWindowWithReport(
     try { summary = await deps.summarize(source); }
     catch { skip('summarize-failed', source); continue; }
     bump(funnel.summarized, source.seat);
+    if (policy.promotion === 'sleep-review' && summary.promote !== true) { skip('not-promoted', source); continue; }
     const project = safeLine(summary?.project);
     const topic = safeLine(summary?.topic);
     const text = safeLine(summary?.summary);
@@ -253,17 +267,20 @@ export async function condenseContextWindowWithReport(
     updatedKeys.add(key);
   }
   const cutoff = now.getTime() - 30 * DAY_MS;
-  // Compare only the winning, non-retired assertions; a superseded claim cannot keep a decision candidate alive.
+  // The nightly librarian makes promotion judgments; guardian retention runs at the record boundary.
+  // The ordinary condense command keeps its existing retention behavior.
   const finalItems: MemoryItem[] = [...items.values()].map(({ conflict: _conflict, ...item }) => ({ ...item,
-    status: Date.parse(item.updatedAt) < cutoff ? 'retired' as const : 'active' as const,
+    status: policy.retention === 'guardian' ? item.status
+      : Date.parse(item.updatedAt) < cutoff ? 'retired' as const : 'active' as const,
   }));
   finalItems.sort((a, b) => Date.parse(a.updatedAt) - Date.parse(b.updatedAt) || a.source.localeCompare(b.source)
     || a.seat.localeCompare(b.seat));
   for (let index = 0; index < finalItems.length; index++) {
     const item = finalItems[index]!;
-    if (item.status !== 'active' || !item.claim) continue;
+    if (item.status !== 'active' || !item.claim || (policy.retention === 'guardian' && Date.parse(item.updatedAt) < cutoff)) continue;
     const { key, value } = item.claim;
     const conflicting = finalItems.slice(0, index).find(other => other.status === 'active'
+      && (policy.retention !== 'guardian' || Date.parse(other.updatedAt) >= cutoff)
       && other.project === item.project
       && other.claim?.key === key && other.claim.value !== value);
     if (conflicting) {