elanous 0.2.11 → 0.2.12

package/src/nexus/api/workflows.ts

@@ -32,7 +32,9 @@ import { requirePosixShellCommand } from '../../platform/default-shell.js';
 import { spawn } from 'child_process';
 import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
 import { join } from 'path';
+import { debug } from '../../debug/log.js';
 import { elanousStateRoot } from '../../autopilot/state-paths.js';
+import { getWorkflowHistoryVersion, listWorkflowHistory, snapshotBeforeSave } from './workflow-history.js';
 import {
   deleteWorkflow,
   discoverWorkflows,
@@ -232,6 +234,45 @@ export function handleWorkflowGet(
   );
 }
 
+export function handleWorkflowHistoryList(
+  req: Request,
+  name: string,
+  opts: MetaApiOpts,
+): Response {
+  if (!checkAuth(req, opts)) return jsonResponse({ error: 'unauthorized' }, 401);
+  if (req.method !== 'GET') return jsonResponse({ error: 'method-not-allowed', method: req.method }, 405);
+  const scope = new URL(req.url).searchParams.get('scope') === 'global' ? 'global' : 'project';
+  try {
+    return jsonResponse({ versions: listWorkflowHistory(name, { scope }) }, 200);
+  } catch (err) {
+    if (err instanceof Error && err.message === 'invalid workflow name') {
+      return jsonResponse({ error: 'bad_request', reason: err.message }, 400);
+    }
+    throw err;
+  }
+}
+
+export function handleWorkflowHistoryVersionGet(
+  req: Request,
+  name: string,
+  id: string,
+  opts: MetaApiOpts,
+): Response {
+  if (!checkAuth(req, opts)) return jsonResponse({ error: 'unauthorized' }, 401);
+  if (req.method !== 'GET') return jsonResponse({ error: 'method-not-allowed', method: req.method }, 405);
+  const scope = new URL(req.url).searchParams.get('scope') === 'global' ? 'global' : 'project';
+  try {
+    const yaml = getWorkflowHistoryVersion(name, id, { scope });
+    if (yaml === null) return jsonResponse({ error: 'not_found', name, id }, 404);
+    return jsonResponse({ yaml }, 200);
+  } catch (err) {
+    if (err instanceof Error && (err.message === 'invalid workflow name' || err.message === 'invalid workflow history version id')) {
+      return jsonResponse({ error: 'bad_request', reason: err.message }, 400);
+    }
+    throw err;
+  }
+}
+
 export async function handleWorkflowPut(
   req: Request,
   name: string,
@@ -248,6 +289,17 @@ export async function handleWorkflowPut(
     return jsonResponse({ error: 'bad_request', reason: '`yaml` must be a string' }, 400);
   }
   const scope = scopeRaw === 'global' ? 'global' : 'project';
+  const parsed = parseWorkflowYaml(yamlText);
+  if (parsed.ok && parsed.workflow?.name === name) {
+    // Capture the existing file before saveWorkflow overwrites it; a failed snapshot is non-fatal.
+    try {
+      snapshotBeforeSave(name, { scope });
+    } catch (err) {
+      debug.log('nexus.workflow-history', 'snapshot-failed', {
+        name, scope, error: err instanceof Error ? err.message : String(err),
+      }, { level: 'warn' });
+    }
+  }
   const r = saveWorkflow(name, yamlText, { scope });
   if (!r.ok) {
     return jsonResponse(

package/src/nexus/outbound/delivery-ledger.ts

@@ -52,20 +52,29 @@ export function deliveryDedupKey(kind: string, text: string): string {
   return createHash('sha1').update(`${kind}\n${norm}`).digest('hex').slice(0, 16);
 }
 
-/** ① 중복 발사 제어 — 같은 dedupKey가 windowSec 내에 이미 발송됐나(재팬아웃 억제).
- *  보수적 짧은 창(기본 120s) — 크론 재시도·이중호출 같은 즉시 중복만 잡고,
- *  시간 지난 정당한 재발송은 통과. (의미 중복은 상류 signal-dedup 6h 담당.) */
-export function recentlyDelivered(
+/** ① 중복 발사 제어 — windowSec 내 동일 메시지가 한 채널 이상 성공했으면 그 messageId.
+ *  실패 기록은 재시도를 막지 않는다. 짧은 창(기본 120s) 밖의 재발송은 통과. */
+export function successfulDeliveryId(
   db: Database, dedupKey: string, windowSec = 120, nowMs: number = Date.now(),
-): boolean {
+): string | null {
   // ⚠️ 축 ②(JS 임계 · db-window 참조) — 같은 파일의 `recentDeliveryCount` 와 동형이다.
   //    SQL 안의 `datetime('now')` 를 쓰면 **시계를 주입할 수 없어** 테스트가 실제 시각에
   //    매달린다. 실제로 이 함수의 테스트가 고정 날짜로 seed 한 채 시간이 흘러 어느 날 빨개진
   //    시한폭탄이었다. `deliveries.ts` 는 ISO 로만 쓰므로 raw 비교가 옳고 인덱스도 산다.
   const row = db.prepare(
-    `SELECT 1 FROM deliveries WHERE dedup_key = ? AND ts >= ? LIMIT 1`,
-  ).get(dedupKey, sinceTs(SECONDS(windowSec), nowMs));
-  return !!row;
+    `SELECT message_id FROM deliveries
+     WHERE dedup_key = ? AND ts >= ?
+       AND EXISTS (SELECT 1 FROM json_each(deliveries.channels) WHERE json_extract(value, '$.ok') = 1)
+     ORDER BY ts DESC LIMIT 1`,
+  ).get(dedupKey, sinceTs(SECONDS(windowSec), nowMs)) as { message_id: string } | null;
+  return row?.message_id ?? null;
+}
+
+/** 기존 boolean 호출부 호환 — 성공 배송 기록만 중복으로 센다. */
+export function recentlyDelivered(
+  db: Database, dedupKey: string, windowSec = 120, nowMs: number = Date.now(),
+): boolean {
+  return successfulDeliveryId(db, dedupKey, windowSec, nowMs) !== null;
 }
 
 /** 최근 창(windowSec) 내 총 발송 수 — 버스트(밀림) 판정용. 전 kind 합산.

package/src/nexus/outbound/router.ts

@@ -27,13 +27,14 @@
 // that boolean before falling back to direct Telegram).
 
 import { createHash } from 'node:crypto';
+import { debug } from '../../debug/log.js';
 import { sendTelegramReport } from '../../telegram-report.js';
 import { getPushcutClient } from '../../pushcut/client.js';
 import type { UserConfig } from '../../user-config.js';
 import { formatForChannel, type OutboundChannelType, type OutboundMsg } from './format.js';
 import { spillLongContent } from '../../storage/content-spill.js';
 import {
-  openDeliveryDb, deliveryDedupKey, recentlyDelivered, recordDelivery, type ChannelDelivery,
+  openDeliveryDb, deliveryDedupKey, successfulDeliveryId, recordDelivery, type ChannelDelivery,
 } from './delivery-ledger.js';
 
 // 채널 타입·메시지·분할기는 format.ts가 단일 출처 — 기존 소비처(test 등) 호환 재export.
@@ -71,6 +72,8 @@ export interface RouteResult {
   channels: ChannelResult[];
   /** 중복 발사 제어(dedup)로 재팬아웃이 억제됨 — 최근 동일 발송 존재. */
   suppressed?: boolean;
+  /** 억제 근거가 된 앞선 성공 발송의 식별자. */
+  suppressedBy?: string;
   /** 이 발송의 식별자(리드 동기화·회상 교차참조용). */
   messageId?: string;
 }
@@ -207,9 +210,11 @@ export async function routeOutbound(cfg: UserConfig, msg: OutboundMsg, deps: Rou
   // ① 중복 발사 제어 — 최근(120s) 동일 발송이면 재팬아웃 억제.
   if (ledger && deps.dedup !== false) {
     try {
-      if (recentlyDelivered(ledger, dedupKey)) {
+      const suppressedBy = successfulDeliveryId(ledger, dedupKey);
+      if (suppressedBy) {
         if (ownLedger) ledger.close();
-        return { delivered: true, channels: [], suppressed: true, messageId };
+        try { debug.log('outbound.send', 'suppressed', { kind: msg.kind, suppressedBy }); } catch { /* 관측 실패는 발송 결과에 영향 없음 */ }
+        return { delivered: true, channels: [], suppressed: true, suppressedBy, messageId };
       }
     } catch { /* 원장 조회 실패 — 억제 없이 진행 */ }
   }

package/src/persona/presets.ts

@@ -111,11 +111,18 @@ function mapping(value: unknown): value is Record<string, unknown> {
   return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
 
+export class UnknownPersonaSchemaKeyError extends Error {
+  constructor(key: string) {
+    super(`unknown persona schema key: ${key}`);
+    this.name = 'UnknownPersonaSchemaKeyError';
+  }
+}
+
 function assertSchemaKeys(value: Record<string, unknown>, parent = ''): void {
   const allowed: ReadonlySet<string> = parent ? new Set(NESTED_KEYS[parent] ?? []) : PROFILE_KEYS;
   for (const [key, child] of Object.entries(value)) {
     if (!allowed.has(key)) {
-      throw new Error(`unknown persona schema key: ${parent ? `${parent}.` : ''}${key}`);
+      throw new UnknownPersonaSchemaKeyError(`${parent ? `${parent}.` : ''}${key}`);
     }
     const path = parent ? `${parent}.${key}` : key;
     if (NESTED_KEYS[path] && mapping(child)) assertSchemaKeys(child, path);

package/src/plugins/maker/market-bundle.ts

@@ -17,7 +17,8 @@ function packageFiles(dir: string, prefix = ''): string[] {
   const files: string[] = [];
   for (const entry of readdirSync(join(dir, prefix), { withFileTypes: true })) {
     const path = prefix ? `${prefix}/${entry.name}` : entry.name;
-    if (entry.name === '.git' || entry.name === '.elanous' || entry.name === 'node_modules') continue;
+    if (entry.name === '.git' || entry.name === '.elanous' || entry.name === '.elanous-local' ||
+      entry.name === '.elanous-test' || entry.name === 'graph-runs' || entry.name === 'node_modules') continue;
     if (entry.isSymbolicLink() || (!entry.isFile() && !entry.isDirectory())) throw new Error(`unsafe market bundle entry: ${path}`);
     if (entry.isDirectory()) files.push(...packageFiles(dir, path));
     else files.push(path);

package/src/release-loop/checklist.ts

@@ -29,6 +29,7 @@ export interface ChecklistHistory {
   released: string;
   dev: string;
   force?: true;
+  reason?: string;
 }
 export interface Checklist {
   version: string;
@@ -72,13 +73,18 @@ export function listChecklist(v: string, root?: string): Checklist {
   return decodeClaimHistory(root === undefined ? store.list(v) : store.list(v, undefined, undefined, root));
 }
 
+/** Events for this id across every release, ordered by event time (then ledger sequence). */
+export function checklistHistory(id: string): Array<ChecklistHistory & { version: string; seq: number }> {
+  return store.history(id).map(decodeClaimHistoryEntry);
+}
+
 /** Status events in the requested window; other ledger fields never become status changes. */
 export function statusChangesSince(history: readonly ChecklistHistory[], sinceIso: string): ChecklistHistory[] {
   const since = Date.parse(sinceIso);
   return history.filter((entry) => entry.field === 'status' && Date.parse(entry.at) >= since);
 }
 
-function mutate(v: string, apply: (data: Checklist) => boolean): Checklist {
+function mutate(v: string, apply: (data: Checklist, otherItems: (id: string) => store.ChecklistCollision[]) => boolean): Checklist {
   return decodeClaimHistory(store.mutate(v, store.releasedVersion(), devVersion(), apply));
 }
 
@@ -87,13 +93,19 @@ function change(data: Checklist, id: string, field: string, from: unknown, to: u
   debug.log('release-loop.checklist', 'change', { version: data.version, id, field, from: from ?? null, to: to ?? null, by });
 }
 
-export function addItem(v: string, input: { id: string; title: string; owner?: string; kind?: ChecklistKind }): Checklist {
+export function addItem(v: string, input: { id: string; title: string; owner?: string; kind?: ChecklistKind }, options: { allowDuplicateId?: boolean } = {}): Checklist {
   if (!input.id.trim()) throw new CliUserError('칸 id 가 비었다');
   if (!input.title.trim()) throw new CliUserError('칸 제목이 비었다');
   if (input.kind !== undefined && input.kind !== 'screen') throw new CliUserError(`잘못된 종류: ${input.kind}`, 'screen');
   if (input.owner !== undefined) parseOwner(input.owner);
-  return mutate(v, (data) => {
+  return mutate(v, (data, otherItems) => {
     if (data.items.some((item) => item.id === input.id)) throw new CliUserError(`이미 있는 칸: ${input.id}`, 'set <id> 로 고친다');
+    const collisions = otherItems(input.id);
+    if (collisions.length) {
+      const displayedId = JSON.stringify(input.id).slice(1, -1);
+      console.error(`⚠ 중복 id: ${displayedId} — ${collisions.map((item) => `${item.version} · 담당 ${JSON.stringify(item.owner ?? '-').slice(1, -1)} · ${item.title.replace(/\s+/g, ' ').slice(0, 40)}`).join(' / ')}`);
+      if (!options.allowDuplicateId) throw new CliUserError(`다른 판에 이미 있는 칸: ${displayedId}`, '--allow-duplicate-id 로 허용');
+    }
     const by = process.env.ELANOUS_TRACK || 'cli';
     const at = new Date().toISOString();
     const item: ChecklistItem = { id: input.id, title: input.title, status: 'yellow', ...(input.owner !== undefined ? { owner: input.owner } : {}), ...(input.kind !== undefined ? { kind: input.kind } : {}), updatedAt: at, updatedBy: by };

package/src/release-loop/feature-store.ts

@@ -50,12 +50,13 @@ function open(root = releaseLedgerRoot()): Database {
     db.exec('PRAGMA foreign_keys = ON');
     if (!db.query("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'imported_versions'").get()) db.exec(`CREATE TABLE IF NOT EXISTS features (id TEXT PRIMARY KEY, title TEXT NOT NULL, owner TEXT, kind TEXT, created_at TEXT NOT NULL);
     CREATE TABLE IF NOT EXISTS assignments (feature_id TEXT NOT NULL REFERENCES features(id), version TEXT NOT NULL, status TEXT NOT NULL, disposition TEXT, evidence TEXT, title_override TEXT, owner TEXT, kind TEXT, updated_at TEXT NOT NULL, updated_by TEXT NOT NULL, PRIMARY KEY(feature_id, version));
-    CREATE TABLE IF NOT EXISTS events (seq INTEGER PRIMARY KEY AUTOINCREMENT, at TEXT NOT NULL, by TEXT NOT NULL, feature_id TEXT NOT NULL, version TEXT NOT NULL, field TEXT NOT NULL, "from" TEXT, "to" TEXT, released TEXT NOT NULL, dev TEXT NOT NULL);
+    CREATE TABLE IF NOT EXISTS events (seq INTEGER PRIMARY KEY AUTOINCREMENT, at TEXT NOT NULL, by TEXT NOT NULL, feature_id TEXT NOT NULL, version TEXT NOT NULL, field TEXT NOT NULL, "from" TEXT, "to" TEXT, released TEXT NOT NULL, dev TEXT NOT NULL, reason TEXT);
     CREATE TABLE IF NOT EXISTS evidence (feature_id TEXT NOT NULL, version TEXT NOT NULL, ref TEXT NOT NULL, at TEXT NOT NULL, by TEXT NOT NULL);
     CREATE TABLE IF NOT EXISTS imported_versions (version TEXT PRIMARY KEY, json_hash TEXT, imported_at TEXT);`);
     const columns = db.query('PRAGMA table_info(imported_versions)').all() as Array<{ name: string }>;
     if (!columns.some((column) => column.name === 'json_hash')) db.exec('ALTER TABLE imported_versions ADD COLUMN json_hash TEXT');
     if (!columns.some((column) => column.name === 'imported_at')) db.exec('ALTER TABLE imported_versions ADD COLUMN imported_at TEXT');
+    if (!(db.query('PRAGMA table_info(events)').all() as Array<{ name: string }>).some((column) => column.name === 'reason')) db.exec('ALTER TABLE events ADD COLUMN reason TEXT');
     db.exec('CREATE TABLE IF NOT EXISTS release_schedules (version TEXT PRIMARY KEY, cut_at TEXT NOT NULL, land_by TEXT, updated_at TEXT NOT NULL, updated_by TEXT NOT NULL)');
     return db;
   } catch (error) { db.close(); throw error; }
@@ -119,14 +120,15 @@ function readTransaction<T>(db: Database, work: () => T): T {
   catch (error) { db.exec('ROLLBACK'); throw error; }
 }
 
-type EventRow = { seq: number; at: string; by: string; feature_id: string; version: string; field: string; from: string; to: string; released: string; dev: string };
+type EventRow = { seq: number; at: string; by: string; feature_id: string; version: string; field: string; from: string; to: string; released: string; dev: string; reason: string | null };
 function decode(value: string | null): unknown { return value === null ? null : JSON.parse(value); }
 function historyRow(row: EventRow): ChecklistHistory {
-  return { at: row.at, by: row.by, id: row.feature_id, field: row.field, from: decode(row.from), to: decode(row.to), released: row.released, dev: row.dev };
+  return { at: row.at, by: row.by, id: row.feature_id, field: row.field, from: decode(row.from), to: decode(row.to), released: row.released, dev: row.dev,
+    ...(row.reason !== null ? { reason: row.reason } : {}) };
 }
 function record(db: Database, version: string, entry: ChecklistHistory): void {
-  db.query('INSERT INTO events (at, by, feature_id, version, field, "from", "to", released, dev) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)')
-    .run(entry.at, entry.by, entry.id, version, entry.field, JSON.stringify(entry.from ?? null), JSON.stringify(entry.to ?? null), entry.released, entry.dev);
+  db.query('INSERT INTO events (at, by, feature_id, version, field, "from", "to", released, dev, reason) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)')
+    .run(entry.at, entry.by, entry.id, version, entry.field, JSON.stringify(entry.from ?? null), JSON.stringify(entry.to ?? null), entry.released, entry.dev, entry.reason ?? null);
 }
 function evidenceRefs(db: Database, version: string, id: string): string[] {
   return (db.query('SELECT ref FROM evidence WHERE feature_id = ? AND version = ? ORDER BY rowid').all(id, version) as Array<{ ref: string }>).map((row) => row.ref);
@@ -288,7 +290,9 @@ export function list(version: string, released?: string, dev = devVersion(), roo
 }
 
 /** The checklist API supplies its existing validation, field ordering and legacy history shape. */
-export function mutate(version: string, released: string, dev: string, apply: (data: Checklist) => boolean): Checklist {
+export interface ChecklistCollision { version: string; owner?: string; title: string }
+
+export function mutate(version: string, released: string, dev: string, apply: (data: Checklist, otherItems: (id: string) => ChecklistCollision[]) => boolean): Checklist {
   validateVersion(version);
   const db = open();
   try {
@@ -298,7 +302,16 @@ export function mutate(version: string, released: string, dev: string, apply: (d
       const data = snapshot(db, version, released, dev);
       const before = new Map(data.items.map((item) => [item.id, JSON.stringify(item)]));
       const count = data.history.length;
-      if (apply(data)) {
+      if (apply(data, (id) => {
+        for (const other of legacyVersions()) if (other !== version) importOnDb(db, other);
+        return db.query(`SELECT a.version, a.owner, COALESCE(a.title_override, f.title) AS title
+          FROM assignments a JOIN features f ON f.id = a.feature_id
+          WHERE a.feature_id = ? AND a.version <> ? ORDER BY a.version`).all(id, version)
+          .map((row) => {
+            const item = row as { version: string; owner: string | null; title: string };
+            return { version: item.version, ...(item.owner !== null ? { owner: item.owner } : {}), title: item.title };
+          });
+      })) {
         for (const item of data.items) if (before.get(item.id) !== JSON.stringify(item)) {
           const previous = before.get(item.id);
           const evidenceChanged = previous && (JSON.parse(previous) as ChecklistItem).evidence !== item.evidence;
@@ -356,7 +369,7 @@ export function remove(version: string, id: string, by: string, released = relea
     return true;
   });
 }
-export function move(id: string, from: string, to: string, by: string, released = releasedVersion(), dev = devVersion()): Checklist {
+export function move(id: string, from: string, to: string, by: string, released = releasedVersion(), dev = devVersion(), reason?: string): Checklist {
   validateVersion(from); validateVersion(to);
   if (from === to) throw new CliUserError('같은 판으로 옮길 수 없다');
   const db = open();
@@ -366,11 +379,12 @@ export function move(id: string, from: string, to: string, by: string, released
       importedFrom = importOnDb(db, from); importedTo = importOnDb(db, to);
       const item = items(db, from).find((i) => i.id === id);
       if (!item) throw new CliUserError(`없는 칸: ${id}`, 'list 로 칸 목록을 본다');
-      if (db.query('SELECT 1 FROM assignments WHERE feature_id = ? AND version = ?').get(id, to)) throw new CliUserError(`이미 있는 칸: ${id}`);
+      const collision = items(db, to).find((i) => i.id === id);
+      if (collision) throw new CliUserError(`이미 있는 칸: ${JSON.stringify(id).slice(1, -1)} — ${to} · 담당 ${JSON.stringify(collision.owner ?? '-').slice(1, -1)} · ${collision.title.replace(/\s+/g, ' ').slice(0, 40)}`);
       const at = new Date().toISOString();
       db.query('UPDATE assignments SET version = ?, updated_at = ?, updated_by = ? WHERE feature_id = ? AND version = ?').run(to, at, by, id, from);
       db.query('UPDATE evidence SET version = ? WHERE feature_id = ? AND version = ?').run(to, id, from);
-      record(db, to, { at, by, id, field: 'move', from, to, released, dev });
+      record(db, to, { at, by, id, field: 'move', from, to, released, dev, ...(reason !== undefined ? { reason } : {}) });
       return snapshot(db, to, released, dev);
     });
     if (importedFrom) debug.log('release.features', 'imported', { version: from });

package/src/release-loop/landed-but-yellow.ts

@@ -0,0 +1,48 @@
+import { ownerMatches, type ChecklistItem } from './checklist.js';
+
+export interface MergedChecklistPr { number: number; title: string; body: string | null; mergedAt: string }
+type PrMatchBasis = 'cell-line' | 'title-strong' | 'mention';
+export interface LandedButYellowRow {
+  id: string;
+  owner: string | undefined;
+  status: 'yellow' | 'red';
+  prs: Array<Pick<MergedChecklistPr, 'number' | 'title' | 'mergedAt'> & { basis: PrMatchBasis }>;
+  alreadyInEvidence: boolean[];
+  newer: boolean;
+}
+
+/** Prefer a dedicated body cell line over title evidence; incidental mentions only qualify for long ids. */
+export function landedButYellow(items: readonly ChecklistItem[], prs: readonly MergedChecklistPr[], { owner }: { owner?: string } = {}): LandedButYellowRow[] {
+  const rows: LandedButYellowRow[] = [];
+  for (const item of items) {
+    if (item.status !== 'yellow' && item.status !== 'red') continue;
+    if (owner !== undefined && !ownerMatches(item.owner, owner)) continue;
+    const id = item.id.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const word = new RegExp(`(?<![A-Za-z0-9])${id}(?![A-Za-z0-9])`);
+    const shortId = /^[A-Z]{1,2}\d{1,2}[a-z]?$/.test(item.id);
+    const titleStart = shortId
+      ? new RegExp(`^${id}(?:$|\\s+(?:수확|(?:첫|둘째|셋째)\\s*조각|fixed|new|old)(?=\\s|:|$))`)
+      : new RegExp(`^${id}(?:\\s|$)`);
+    const explicitTitle = new RegExp(`(?<![A-Za-z0-9])${id}\\s+(?:수확|(?:첫|둘째|셋째)\\s*조각)(?![A-Za-z0-9가-힣])|\\(${id}\\)`);
+    const rank: Record<PrMatchBasis, number> = { 'cell-line': 0, 'title-strong': 1, mention: 2 };
+    const matched = prs.flatMap((pr) => {
+      const cellLine = (pr.body ?? '').split('\n').some((line) => {
+        const match = /^[ \t]*칸(?:[ \t]*:[ \t]*|[ \t]+)([A-Za-z0-9_-]+(?:[ \t]*,[ \t]*[A-Za-z0-9_-]+)*)[ \t]*$/.exec(line.endsWith('\r') ? line.slice(0, -1) : line);
+        return match?.[1]?.split(',').some((candidate) => candidate.trim() === item.id) ?? false;
+      });
+      const basis: PrMatchBasis | undefined = cellLine ? 'cell-line'
+        : titleStart.test(pr.title) || explicitTitle.test(pr.title) ? 'title-strong'
+          : !shortId && (word.test(pr.title) || word.test(pr.body ?? '')) ? 'mention' : undefined;
+      return basis ? [{ number: pr.number, title: pr.title, mergedAt: pr.mergedAt, basis }] : [];
+    }).sort((a, b) => rank[a.basis] - rank[b.basis] || b.mergedAt.localeCompare(a.mergedAt) || b.number - a.number);
+    if (!matched.length) continue;
+    const shown = matched.slice(0, 5);
+    rows.push({
+      id: item.id, owner: item.owner, status: item.status,
+      prs: shown,
+      alreadyInEvidence: shown.map(({ number }) => new RegExp(`(?<![A-Za-z0-9_#])#${number}(?![A-Za-z0-9_])`).test(item.evidence ?? '')),
+      newer: matched.some((pr) => pr.mergedAt > item.updatedAt),
+    });
+  }
+  return rows.sort((a, b) => Number(b.newer) - Number(a.newer));
+}

package/src/seat-loop/seat-loop.ts

@@ -17,7 +17,7 @@ import { nextPersonaTodo, personaTodoPath, readPersonaTodos, type PersonaTodo }
 import { PersonaRegistry } from '../persona/registry.js';
 import { answerSeat, askSeat, deliveredSeatQuestion, hasSeatAnswer, isSeatId, seatQuestions, type SeatId } from '../seat-dispatch/seat-questions.js';
 import { queryRunningRuns } from '../self-implement/running-runs.js';
-import { listChecklist, type Checklist } from '../release-loop/checklist.js';
+import { checklistHistory, listChecklist, type Checklist } from '../release-loop/checklist.js';
 import { readSchedules, releasedVersion } from '../release-loop/feature-store.js';
 
 // `kind`/`createdAt` are the V3 shadow-compare keys (내부 문서 `METHOD-v3-shadow-compare-2026-10-02` · MK 10-02 18:54).
@@ -31,7 +31,11 @@ export type OpCandidate =
   | { kind: 'release-readiness'; version: string | null; verdict: 'ready' | 'not-ready' | 'no-open-release'; cutAt?: string; landBy?: string | null; red: string[]; undecided: string[]; blocked: string[] }
   | { kind: 'unassigned-cell'; version: string | null; id: string | null; title?: string; status?: string; verdict: 'assign' | 'none' }
   | { kind: 'decision-delegation'; id: string | null; title?: string; category?: DecisionEntry['category']; dueAt?: string; verdict: 'review-delegation' | 'none' };
-export type SeatEntry = { seat: string; ts?: string; at: string; status: 'shadow' | 'attempting' | 'outcome-unknown' | 'launched' | 'hitl' | 'wait' | 'asked' | 'answered' | 'awaiting-answer' | 'skipped-budget' | 'skipped-empty'; item?: SeatItem; candidate?: OpCandidate; action?: SeatAction; reason?: string; runId?: string; inquiry?: SeatInquiry; answer?: string; escalated?: boolean };
+export type TcCandidate =
+  | { kind: 'merged-pr-yellow-cell'; version: string; id: string; title: string; pr: number; mergedAt: string }
+  | { kind: 'publication-pr-approval-wait'; pr: number; title: string; readyAt: string; approvalWaitAt: string; paths: string[] };
+export type TcPullRequest = { number: number; title: string; body?: string; state: 'OPEN' | 'MERGED' | 'CLOSED'; isDraft: boolean; createdAt: string; updatedAt?: string; mergedAt?: string | null; readyAt?: string; approvalWaitAt?: string; paths?: string[]; reviewDecision?: string };
+export type SeatEntry = { seat: string; ts?: string; at: string; status: 'shadow' | 'attempting' | 'outcome-unknown' | 'launched' | 'hitl' | 'wait' | 'asked' | 'answered' | 'awaiting-answer' | 'skipped-budget' | 'skipped-empty'; item?: SeatItem; candidate?: OpCandidate | TcCandidate; action?: SeatAction; reason?: string; runId?: string; inquiry?: SeatInquiry; answer?: string; escalated?: boolean };
 export type SeatLoopResult = SeatEntry | { seat: string; status: 'skipped-off' };
 export type PersonaShadowEntry = { personaId: string; ts: string; status: 'shadow' | 'skipped-empty'; todo: PersonaTodo | null };
 export type SeatDeps = {
@@ -54,12 +58,16 @@ export type SeatDeps = {
   schedules?: () => Array<{ version: string; cutAt: string; landBy?: string | null }>;
   /** Checklist items of one version — default reads the release ledger DB (checklist.json is only a legacy import source since REL5b). */
   checklistItems?: (version: string) => Array<{ id: string; title: string; status: string; owner?: string | null; disposition?: string; evidence?: string }>;
+  /** Chronological release-ledger events for a checklist id; injected for isolated release fixtures. */
+  checklistHistory?: (id: string) => ReturnType<typeof checklistHistory>;
   /** Full checklist snapshot including history, for stall detection. */
   stallChecklist?: (version: string) => Checklist;
   /** Inject a mailbox write for isolated failure tests; production uses the seat message store. */
   stallDelivery?: (message: MessageEnvelope, key: string, root: string) => boolean;
   /** Open cards from the decision ledger; injected only for isolated ledger tests. */
   pendingDecisions?: () => Array<Pick<DecisionEntry, 'id' | 'title' | 'category' | 'dueAt'>>;
+  /** Read-only PR snapshot for TC judgment; defaults to GitHub CLI reads. */
+  pullRequests?: () => Promise<TcPullRequest[]>;
   ledgerFiles?: (directory: string) => string[];
   lockContended?: () => void;
   /** Supply a question only when this seat lacks evidence for the selected work item. */
@@ -211,17 +219,19 @@ function eligibleItem(item: SeatItem, ledger: readonly SeatEntry[], handled: Rea
   return !lastWait?.item || itemSnapshot(lastWait.item) !== itemSnapshot(item);
 }
 
-// Compare checklist snapshots without consulting release history or treating a version move as new work.
+const CHECKLIST_HANDLED_WINDOW_MS = 7 * 24 * 60 * 60 * 1000;
+
+// Same-version snapshots are handled here; carried work requires an explicit release-ledger move.
 export function alreadyHandled(item: SeatItem, ledger: readonly SeatEntry[]): boolean {
   if (item.source !== 'checklist' || !item.seat || !item.asOf || item.evidenceHash === undefined) return false;
   const now = Date.parse(item.asOf);
   if (!Number.isFinite(now)) return false;
   return ledger.some((entry) => {
     const at = Date.parse(entry.at || entry.ts || '');
-    return entry.seat === item.seat && at >= now - 7 * 24 * 60 * 60 * 1000 && at <= now
+    return entry.seat === item.seat && at >= now - CHECKLIST_HANDLED_WINDOW_MS && at <= now
       // A shadowed seat question was never delivered — it must be picked again once delivery is on (RM3 · TC merge 10-03).
       && (entry.status === 'launched' || (entry.status === 'shadow' && !entry.inquiry))
-      && entry.item?.source === 'checklist' && entry.item.id === item.id
+      && entry.item?.source === 'checklist' && entry.item.id === item.id && entry.item.version === item.version
       && entry.item.title === item.title && entry.item.evidenceHash === item.evidenceHash;
   });
 }
@@ -357,6 +367,126 @@ function opCandidates(deps: SeatDeps, now: Date): OpCandidate[] {
   ];
 }
 
+const TC_APPROVAL_WAIT_MS = 2 * 60 * 60 * 1000;
+
+function readTcChecklist(root: string): Array<{ version: string; id: string; title: string; status: string; owner: string | null }> {
+  const path = join(root, 'release', 'features.sqlite');
+  if (!existsSync(path)) return [];
+  const db = new Database(path, { readonly: true, strict: true });
+  try {
+    return db.query(`SELECT a.version, f.id, COALESCE(a.title_override, f.title) AS title, a.status, a.owner
+      FROM assignments a JOIN features f ON f.id = a.feature_id WHERE a.status = 'yellow' AND a.owner = 'TC'
+      ORDER BY a.version, f.id`).all() as Array<{ version: string; id: string; title: string; status: string; owner: string | null }>;
+  } finally { db.close(); }
+}
+
+type TcTimelineEvent = { event: string; created_at: string };
+
+export function tcApprovalWaitAt(pr: TcPullRequest, timeline: readonly TcTimelineEvent[]): { readyAt: string; approvalWaitAt: string } | undefined {
+  if (pr.state !== 'OPEN' || pr.isDraft || pr.reviewDecision !== 'REVIEW_REQUIRED') return undefined;
+  const events = timeline.filter((event) => typeof event.created_at === 'string' && Number.isFinite(Date.parse(event.created_at)))
+    .sort((a, b) => Date.parse(a.created_at) - Date.parse(b.created_at));
+  let readyAt: string | undefined = pr.createdAt;
+  let waitAt: string | undefined = pr.createdAt;
+  for (const event of events) {
+    if (event.event === 'converted_to_draft') { readyAt = undefined; waitAt = undefined; }
+    if (event.event === 'ready_for_review') { readyAt = event.created_at; waitAt = event.created_at; }
+    if (event.event === 'review_requested' && readyAt && Date.parse(event.created_at) >= Date.parse(readyAt)) waitAt = event.created_at;
+  }
+  return readyAt && waitAt && Number.isFinite(Date.parse(readyAt)) && Date.parse(waitAt) >= Date.parse(readyAt)
+    ? { readyAt, approvalWaitAt: waitAt } : undefined;
+}
+
+export async function readTcPullRequests(query: (args: string[]) => Promise<string> = async (args) => {
+  const { stdout } = await exec('gh', args, { cwd: repoRoot, encoding: 'utf8', timeout: 120_000, maxBuffer: 64 * 1024 * 1024 });
+  return stdout;
+}): Promise<TcPullRequest[]> {
+  const pages: unknown = JSON.parse(await query(['api', '--paginate', '--slurp', 'repos/{owner}/{repo}/pulls?state=all&per_page=100']));
+  if (!Array.isArray(pages) || !pages.every((page) => Array.isArray(page))) throw new Error('PR list is not an array of pages');
+  const prs = pages.flatMap((page: unknown[]) => page).filter((pr) => pr && typeof pr === 'object'
+    && ((pr as Record<string, unknown>).state === 'open' || typeof (pr as Record<string, unknown>).merged_at === 'string'));
+  const results: TcPullRequest[] = [];
+  for (let offset = 0; offset < prs.length; offset += 10) {
+    results.push(...await Promise.all(prs.slice(offset, offset + 10).map(async (pr): Promise<TcPullRequest> => {
+    const listing = pr as Record<string, unknown>;
+    if (typeof listing.number !== 'number' || typeof listing.title !== 'string' || typeof listing.created_at !== 'string'
+      || typeof listing.draft !== 'boolean' || (listing.state !== 'open' && listing.state !== 'closed')) {
+      throw new Error('incomplete PR record');
+    }
+    const details: unknown = listing.state === 'open'
+      ? JSON.parse(await query(['pr', 'view', String(listing.number), '--json', 'number,title,body,state,isDraft,createdAt,mergedAt,files,reviewDecision']))
+      : { number: listing.number, title: listing.title, body: listing.body, state: 'MERGED', isDraft: listing.draft,
+        createdAt: listing.created_at, mergedAt: listing.merged_at, files: [] };
+    if (!details || typeof details !== 'object' || Array.isArray(details)) throw new Error('invalid PR record');
+    const row = details as Record<string, unknown>;
+    if (typeof row.number !== 'number' || typeof row.title !== 'string' || typeof row.createdAt !== 'string'
+      || typeof row.isDraft !== 'boolean' || (row.state !== 'OPEN' && row.state !== 'MERGED' && row.state !== 'CLOSED')) {
+      throw new Error('incomplete PR record');
+    }
+    const paths = Array.isArray(row.files) ? row.files.flatMap((file: unknown) =>
+      file && typeof file === 'object' && typeof (file as { path?: unknown }).path === 'string' ? [(file as { path: string }).path] : []) : [];
+    const result: TcPullRequest = { number: row.number, title: row.title, body: typeof row.body === 'string' ? row.body : '',
+      state: row.state, isDraft: row.isDraft, createdAt: row.createdAt,
+      mergedAt: typeof row.mergedAt === 'string' ? row.mergedAt : null, paths,
+      reviewDecision: typeof row.reviewDecision === 'string' ? row.reviewDecision : undefined };
+    if (result.state === 'OPEN' && !result.isDraft && result.reviewDecision === 'REVIEW_REQUIRED'
+      && paths.some((path) => path.startsWith('release/public/') || path.startsWith('scripts/public-export') || path.startsWith('src/market/'))) {
+      try {
+        const pages: unknown = JSON.parse(await query(['api', '--paginate', '--slurp', `repos/{owner}/{repo}/issues/${result.number}/timeline`]));
+        if (!Array.isArray(pages) || !pages.every((page) => Array.isArray(page))) throw new Error('PR timeline is not an array of pages');
+        const timeline: unknown[] = pages.flatMap((page: unknown[]) => page);
+        const transitions = timeline.filter((event): event is Record<string, unknown> => event !== null && typeof event === 'object'
+          && ['converted_to_draft', 'ready_for_review', 'review_requested'].includes((event as Record<string, unknown>).event as string));
+        if (!transitions.every((event) => typeof event.created_at === 'string' && Number.isFinite(Date.parse(event.created_at)))) {
+          throw new Error('invalid PR timeline transition date');
+        }
+        Object.assign(result, tcApprovalWaitAt(result, transitions as TcTimelineEvent[]));
+      } catch (error) { observe('tc-pr-timeline-unreadable', { pr: result.number, error: String(error).slice(0, 200) }); }
+    }
+    return result;
+    })));
+  }
+  return results;
+}
+
+async function tcCandidates(deps: SeatDeps, now: Date): Promise<TcCandidate[]> {
+  let prs: TcPullRequest[];
+  // An injected instance root must not fetch unrelated live GitHub state.
+  try { prs = await (deps.pullRequests ?? (deps.root ? async () => [] : readTcPullRequests))(); }
+  catch (error) {
+    observe('tc-pr-unreadable', { seat: 'TC', error: String(error).slice(0, 200) });
+    return [];
+  }
+  const merged = prs.filter((pr) => pr.state === 'MERGED' && pr.mergedAt && Number.isFinite(Date.parse(pr.mergedAt)) && Date.parse(pr.mergedAt) <= now.getTime());
+  const candidates: TcCandidate[] = [];
+  const releaseRoot = deps.root ?? releaseLedgerRoot();
+  try {
+    const cells = merged.length === 0 ? [] : deps.checklistItems && deps.schedules
+      ? deps.schedules().flatMap(({ version }) => deps.checklistItems!(version).map((cell) => ({ ...cell, version })))
+      : readTcChecklist(releaseRoot);
+    for (const cell of cells) {
+      if (cell.owner !== 'TC' || cell.status !== 'yellow') continue;
+      for (const pr of merged) {
+        const id = cell.id.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const reference = new RegExp(`(?<![A-Za-z0-9])${id}(?![A-Za-z0-9])`);
+        if (reference.test(pr.title) || reference.test(pr.body ?? '')) {
+          candidates.push({ kind: 'merged-pr-yellow-cell', version: cell.version, id: cell.id, title: cell.title, pr: pr.number, mergedAt: pr.mergedAt! });
+        }
+      }
+    }
+  } catch (error) { observe('tc-checklist-unreadable', { seat: 'TC', error: String(error).slice(0, 200) }); }
+  for (const pr of prs) {
+    if (pr.state !== 'OPEN' || pr.isDraft || pr.reviewDecision !== 'REVIEW_REQUIRED'
+      || !pr.paths?.some((path) => path.startsWith('release/public/') || path.startsWith('scripts/public-export') || path.startsWith('src/market/'))) continue;
+    const readyAt = pr.readyAt;
+    const age = now.getTime() - Date.parse(pr.approvalWaitAt ?? '');
+    if (!readyAt || !Number.isFinite(Date.parse(readyAt)) || Date.parse(readyAt) > now.getTime()
+      || !Number.isFinite(age) || age < TC_APPROVAL_WAIT_MS) continue;
+    candidates.push({ kind: 'publication-pr-approval-wait', pr: pr.number, title: pr.title, readyAt, approvalWaitAt: pr.approvalWaitAt!, paths: pr.paths });
+  }
+  return candidates;
+}
+
 function deliverStall(message: MessageEnvelope, key: string, root: string): boolean {
   const store = openMsgStore(join(root, 'msg', 'messages.db'));
   try {
@@ -411,13 +541,34 @@ function escalateStalls(seat: string, deps: SeatDeps, config: SeatLoopConfig, no
 }
 
 // In shadow mode a shadowed item counts as handled, so a rehearsal day walks the queue like the seat would.
-export function pickNext(inputs: SeatInputs, ledger: readonly SeatEntry[], opts: { shadow?: boolean; root?: string } = {}): SeatItem | null {
+export function pickNext(inputs: SeatInputs, ledger: readonly SeatEntry[], opts: { shadow?: boolean; root?: string; history?: SeatDeps['checklistHistory'] } = {}): SeatItem | null {
   const handled = handledKeys(ledger, opts.shadow === true, opts.root);
   return [...inputs.requests, ...inputs.checklist].find((item) => {
     if (alreadyHandled(item, ledger)) {
       debug.log('seat.loop', 'skip-handled', { id: item.id });
       return false;
     }
+    if (item.source === 'checklist' && item.version && item.seat && item.asOf && item.evidenceHash !== undefined && opts.history
+      && ledger.some((entry) => entry.seat === item.seat && entry.status === 'shadow'
+        && entry.item?.source === 'checklist' && entry.item.id === item.id && entry.item.version !== item.version)) {
+      // Only an actual move into this version identifies a carried cell; unrelated releases may reuse an id.
+      const moves = opts.history(item.id).filter((event) => event.field === 'move'
+        && typeof event.from === 'string' && typeof event.to === 'string' && Date.parse(event.at) <= Date.parse(item.asOf!));
+      const latest = moves.at(-1);
+      if (latest?.to === item.version) {
+        const processed = [...ledger].reverse().find((entry) => entry.seat === item.seat
+          && entry.status === 'shadow' && !entry.inquiry && entry.action !== 'wait'
+          && entry.item?.source === 'checklist' && entry.item.id === item.id);
+        if (processed && processed.item && processed.item.version === latest.from && processed.item.title === item.title
+          && processed.item.evidenceHash === item.evidenceHash
+          && Date.parse(processed.at || processed.ts || '') >= Date.parse(item.asOf) - CHECKLIST_HANDLED_WINDOW_MS
+          && Date.parse(processed.at || processed.ts || '') <= Date.parse(item.asOf)
+          && Date.parse(processed.at || processed.ts || '') <= Date.parse(latest.at)) {
+          debug.log('seat.loop', 'skip-carried', { id: item.id, from: latest.from, version: item.version });
+          return false;
+        }
+      }
+    }
     return eligibleItem(item, ledger, handled, opts.shadow === true);
   }) ?? null;
 }
@@ -470,6 +621,15 @@ export async function runSeatLoopOnce(seat: string, deps: SeatDeps = {}): Promis
   const stateRoot = deps.root ?? effectiveInstanceRoot();
   let turnError: unknown;
   try {
+  if (seat === 'TC') {
+    const candidates = await tcCandidates(deps, now);
+    for (const candidate of candidates) {
+      if (ledger.some((row) => row.status === 'shadow' && JSON.stringify(row.candidate) === JSON.stringify(candidate))) continue;
+      const entry: SeatEntry = { seat, ts: now.toISOString(), at: now.toISOString(), status: 'shadow', candidate };
+      (deps.append ?? defaultAppend)(path, entry);
+      observe('tc-shadow-candidate', { seat, candidate });
+    }
+  }
   if (seat === 'OP' && !seatQuestions(stateRoot, 'OP').some((question) =>
     !hasSeatAnswer(stateRoot, question)
     && !handledKeys(ledger, config.mode !== 'on' || (config.questions ?? 'shadow') !== 'on', stateRoot).has(`seat-question::${question.id}`))) {
@@ -526,7 +686,8 @@ export async function runSeatLoopOnce(seat: string, deps: SeatDeps = {}): Promis
   const questionsMode = config.mode === 'on' ? config.questions ?? 'shadow' : 'shadow';
   const questionHandled = handledKeys(ledger, questionsMode !== 'on', stateRoot);
   const pendingQuestion = inputs.requests.find((candidate) => candidate.source === 'seat-question' && !questionHandled.has(itemKey(candidate)));
-  const ordinary = pickNext({ ...inputs, requests: inputs.requests.filter((candidate) => candidate.source !== 'seat-question') }, ledger, { shadow: config.mode === 'shadow', root: stateRoot });
+  const ordinary = pickNext({ ...inputs, requests: inputs.requests.filter((candidate) => candidate.source !== 'seat-question') }, ledger,
+    { shadow: config.mode === 'shadow', root: stateRoot, history: deps.checklistHistory ?? checklistHistory });
   const item = pendingQuestion ?? ordinary;
   const append = deps.append ?? defaultAppend;
   // RM3 review must-fix: `questions` now has a default, so it can't be the trigger — a shadow seat loop never calls the model on its own.