elanous 0.2.14 → 0.2.15

package/src/seat-dispatch/seat-request-ledger.ts

@@ -0,0 +1,133 @@
+import { closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, unlinkSync, writeSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { Database } from 'bun:sqlite';
+import { dirname, join } from 'node:path';
+
+export type SeatRequestStatus = 'pending' | 'queued' | 'rejected' | 'done';
+export type SeatRequestRow = {
+  key: string;
+  seat: string;
+  status: SeatRequestStatus;
+  text: string;
+  queuedAt: string;
+  reason?: string;
+  closedAt?: string;
+  [field: string]: unknown;
+};
+
+export type SeatRequestFilters = { seat?: string; status?: SeatRequestStatus };
+export type CloseSeatRequestsOptions = {
+  reason: string;
+  status?: 'rejected' | 'done';
+  /** Minimum age in milliseconds, measured from queuedAt; only strictly older requests qualify. */
+  olderThan?: number;
+  now?: Date;
+  dryRun?: boolean;
+};
+
+const ledgerPath = (root: string): string => join(root, 'seat-requests', 'requests.jsonl');
+
+/** SQLite releases its transaction lock on process death, including SIGKILL. */
+export function withSeatRequestLedgerLock<T>(path: string, work: () => T): T {
+  mkdirSync(dirname(path), { recursive: true });
+  const db = new Database(`${path}.lock.sqlite`);
+  try {
+    db.exec('PRAGMA busy_timeout = 10000');
+    db.exec('BEGIN IMMEDIATE');
+    try {
+      const result = work();
+      db.exec('COMMIT');
+      return result;
+    } catch (error) {
+      db.exec('ROLLBACK');
+      throw error;
+    }
+  } finally { db.close(); }
+}
+
+/** Called under the journal transaction lock; never expose a partial JSON line. */
+export function appendSeatRequestRows<T>(path: string, rows: readonly T[],
+  write: (fd: number, data: Buffer, offset: number, length: number) => number = writeSync): void {
+  if (!rows.length) return;
+  mkdirSync(dirname(path), { recursive: true });
+  const prior = existsSync(path) ? readFileSync(path, 'utf8') : '';
+  if (prior && !prior.endsWith('\n')) throw new Error('invalid seat request journal terminator');
+  const data = Buffer.from(prior + rows.map((row) => `${JSON.stringify(row)}\n`).join(''));
+  const temp = `${path}.${randomUUID()}.tmp`;
+  let fd: number | undefined;
+  try {
+    fd = openSync(temp, 'wx', 0o600);
+    let offset = 0;
+    while (offset < data.length) {
+      const count = write(fd, data, offset, data.length - offset);
+      if (count <= 0) throw new Error('seat request journal write stalled');
+      offset += count;
+    }
+    fsyncSync(fd);
+    closeSync(fd);
+    fd = undefined;
+    renameSync(temp, path);
+    const directory = openSync(dirname(path), 'r');
+    try { fsyncSync(directory); } finally { closeSync(directory); }
+  } catch (error) {
+    if (fd !== undefined) closeSync(fd);
+    try { unlinkSync(temp); } catch { /* temp was not created or already renamed */ }
+    throw error;
+  }
+}
+
+function latestRows(text: string): Map<string, SeatRequestRow> {
+  const latest = new Map<string, SeatRequestRow>();
+  for (const line of text.split('\n')) {
+    if (!line.trim()) continue;
+    const row: unknown = JSON.parse(line);
+    if (!row || typeof row !== 'object' || Array.isArray(row)) throw new Error('invalid seat request row');
+    const request = row as Record<string, unknown>;
+    if (typeof request.key !== 'string' || !request.key || typeof request.seat !== 'string' || !request.seat
+      || !['pending', 'queued', 'rejected', 'done'].includes(String(request.status))
+      || typeof request.text !== 'string' || typeof request.queuedAt !== 'string') {
+      throw new Error('invalid seat request row');
+    }
+    latest.set(request.key, request as SeatRequestRow);
+  }
+  return latest;
+}
+
+/** Filters apply to the latest row, never to a historical row superseded by a closing event. */
+export function listSeatRequests(root: string, filters: SeatRequestFilters = {}): SeatRequestRow[] {
+  const path = ledgerPath(root);
+  return [...latestRows(existsSync(path) ? readFileSync(path, 'utf8') : '').values()].filter((row) =>
+    (filters.seat === undefined || row.seat === filters.seat)
+    && (filters.status === undefined || row.status === filters.status));
+}
+
+/** Append at most one terminal event for each distinct, currently open request key. */
+export function closeSeatRequests(root: string, keys: readonly string[], options: CloseSeatRequestsOptions): SeatRequestRow[] {
+  const reason = options.reason?.trim();
+  if (!reason) throw new Error('seat request close requires a reason');
+  const status = options.status ?? 'rejected';
+  if (status !== 'rejected' && status !== 'done') throw new Error('invalid seat request close status');
+  if (options.olderThan !== undefined && (!Number.isSafeInteger(options.olderThan) || options.olderThan < 0)) {
+    throw new Error('invalid seat request older-than duration');
+  }
+  const now = options.now ?? new Date();
+  if (!Number.isFinite(now.getTime())) throw new Error('invalid seat request close time');
+  const path = ledgerPath(root);
+  const close = (): SeatRequestRow[] => {
+    const latest = latestRows(existsSync(path) ? readFileSync(path, 'utf8') : '');
+    const closed = [...new Set(keys)].flatMap((key) => {
+      const row = latest.get(key);
+      if (!row || (row.status !== 'pending' && row.status !== 'queued')) return [];
+      if (options.olderThan !== undefined) {
+        const queuedAt = Date.parse(row.queuedAt);
+        if (!Number.isFinite(queuedAt) || now.getTime() - queuedAt <= options.olderThan) return [];
+      }
+      return [{ ...row, status, reason, closedAt: now.toISOString(),
+        ...(row.status === 'queued' && typeof row.ref !== 'string' && typeof row.receiptId === 'string'
+          ? { ref: row.receiptId } : {}) } satisfies SeatRequestRow];
+    });
+    if (!options.dryRun) appendSeatRequestRows(path, closed);
+    return closed;
+  };
+  return options.dryRun ? close() : withSeatRequestLedgerLock(path, close);
+}

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

@@ -21,6 +21,7 @@ import { loadLayeredPersonaDirs, resolveRepositoryPersonaDir, resolveStatePerson
 import { orderedPersonaTodos, personaTodoPath, readPersonaTodos, type PersonaTodo } from '../persona/persona-todo.js';
 import { PersonaRegistry } from '../persona/registry.js';
 import { recordSeatAskShadow } from '../seat-dispatch/seat-ask.js';
+import { appendSeatRequestRows, listSeatRequests, withSeatRequestLedgerLock } from '../seat-dispatch/seat-request-ledger.js';
 import { answerCrossCheck, answerSeat, askCrossCheck, askSeat, crossCheckAnswer, deliveredSeatQuestion, hasSeatAnswer, isSeatId, seatCrossChecks, seatQuestions, type CrossCheckJudgment, type SeatId } from '../seat-dispatch/seat-questions.js';
 import { queryRunningRuns } from '../self-implement/running-runs.js';
 import { checklistHistory, listChecklist, type Checklist } from '../release-loop/checklist.js';
@@ -42,8 +43,14 @@ export type TcCandidate =
   | { kind: 'publication-pr-approval-wait'; pr: number; title: string; readyAt: string; approvalWaitAt: string; paths: string[] }
   | { kind: 'other-seat-cell-defect'; version: string; id: string; title: string; to: SeatId };
 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' | 'queued' | 'refused' | 'launched' | 'hitl' | 'wait' | 'asked' | 'answered' | 'awaiting-answer' | 'awaiting-xcheck' | 'awaiting-resolution' | 'resolved-by-neighbor' | 'rejected-no-evidence' | 'skipped-budget' | 'skipped-empty'; item?: SeatItem; candidate?: OpCandidate | TcCandidate; action?: SeatAction; reason?: string; runId?: string; queueId?: string; inquiry?: SeatInquiry; answer?: string; escalated?: boolean; xcheckRequestedAt?: string; xcheckQuestionId?: number; xcheckNeighbor?: SeatId; xcheckNote?: string; xcheckJudgmentEvidence?: string; xcheckWaitMinutes?: number };
-export type SeatLoopResult = SeatEntry | { seat: string; status: 'skipped-off' };
+export type SeatEntry = { seat: string; ts?: string; at: string; modeDowngradeReason?: string; status: 'shadow' | 'attempting' | 'outcome-unknown' | 'queued' | 'refused' | 'launched' | 'hitl' | 'wait' | 'asked' | 'answered' | 'awaiting-answer' | 'awaiting-xcheck' | 'awaiting-resolution' | 'resolved-by-neighbor' | 'rejected-no-evidence' | 'skipped-budget' | 'skipped-empty'; item?: SeatItem; candidate?: OpCandidate | TcCandidate; action?: SeatAction; reason?: string; runId?: string; queueId?: string; inquiry?: SeatInquiry; answer?: string; escalated?: boolean; xcheckRequestedAt?: string; xcheckQuestionId?: number; xcheckNeighbor?: SeatId; xcheckNote?: string; xcheckJudgmentEvidence?: string; xcheckWaitMinutes?: number };
+export type SeatLoopResult = SeatEntry | { seat: string; status: 'skipped-off'; modeDowngradeReason?: string };
+
+export function seatLoopTickLine(result: SeatLoopResult): string {
+  const suffix = (result.status === 'shadow' || result.status === 'skipped-off') && result.modeDowngradeReason
+    ? ` (live-safe 요청 · 이유: ${result.modeDowngradeReason})` : '';
+  return `seat loop ${result.seat}: ${result.status}${'runId' in result && result.runId ? ` ${result.runId}` : ''}${suffix}`;
+}
 export type PersonaShadowEntry = { personaId: string; ts: string; status: 'shadow' | 'skipped-empty'; todo: PersonaTodo | null; action?: 'decision' | 'harness' | 'wait'; what?: string };
 export type SeatDeps = {
   personaConfig?: PersonaLoopConfig;
@@ -77,6 +84,8 @@ export type SeatDeps = {
   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'>>;
+  /** Running-run observation for OP cutoff; incomplete observations cannot establish that a run is absent. */
+  cutoffRuns?: (runIds: readonly string[]) => Pick<ReturnType<typeof queryRunningRuns>, 'completeness' | 'entries' | 'pty'>;
   /** Read-only PR snapshot for TC judgment; defaults to GitHub CLI reads. */
   pullRequests?: () => Promise<TcPullRequest[]>;
   ledgerFiles?: (directory: string) => string[];
@@ -200,6 +209,10 @@ async function pickPersonaShadows(deps: SeatDeps, name?: string): Promise<Person
 
 export async function runSeatLoopTurn(seat: string, deps: SeatDeps = {}): Promise<SeatLoopResult> {
   const result = await runSeatLoopOnce(seat, deps);
+  if ((result.status === 'shadow' || result.status === 'skipped-off') && result.modeDowngradeReason) {
+    try { debug.log('seat-loop', 'mode-downgraded', { seat, requested: 'live-safe', effective: result.status, reason: result.modeDowngradeReason }); }
+    catch { /* logging cannot change execution */ }
+  }
   try { await runPersonaShadowOnce(deps); }
   catch (error) { observe('persona-shadow-error', { error: String(error).slice(0, 200) }); }
   try {
@@ -301,8 +314,18 @@ function decisionRef(seat: string, item: SeatItem): string {
   return `seat-loop:${seat}:${encodeURIComponent(itemKey(item))}`;
 }
 
+// The decision ledger counts Unicode characters and sentence boundaries before it stores a card.
+function decisionSummary(text: string): string {
+  const sentences = text.replace(/\s+/g, ' ').trim().split(/(?<=[.!?。！？])\s+/u).slice(0, 2).join(' ');
+  return Array.from(sentences).slice(0, 240).join('').trim();
+}
+
+function decisionSourceRef(seat: string, item: SeatItem): string {
+  return item.source === 'request' && item.id.startsWith('coord:') ? item.id : decisionRef(seat, item);
+}
+
 function decisionReceipt(root: string, seat: string, item: SeatItem): DecisionEntry | undefined {
-  const ref = decisionRef(seat, item);
+  const ref = decisionSourceRef(seat, item);
   return new DecisionLedger({ stateDir: root }).list({ status: 'all' }).find((card) => card.refs?.includes(ref));
 }
 
@@ -456,6 +479,62 @@ export async function gatherSeatInputs(seat: string, deps: SeatDeps = {}, ledger
   return { requests: pending, checklist, role: read(join(deps.repo ?? repoRoot, 'docs', 'roles', `${seat}.md`)).slice(0, 4_000) };
 }
 
+const OP_CUTOFF_WINDOW_MS = 2 * 60 * 60_000;
+const RUN_REFERENCE = /\brun-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/gi;
+
+function checkOpLandingCutoff(deps: SeatDeps, now: Date, path: string, stateRoot: string): SeatEntry | undefined {
+  const releaseRoot = deps.root ?? releaseLedgerRoot();
+  const shipped = releasedVersion(releaseRoot);
+  const schedule = (deps.schedules ?? (() => readSchedules(releaseRoot)))()
+    .filter((row) => /^\d+\.\d+\.\d+$/.test(row.version) && (!shipped || versionOrder(row.version, shipped) > 0))
+    .sort((a, b) => versionOrder(a.version, b.version))[0];
+  if (!schedule?.landBy) return;
+  const untilLanding = Date.parse(schedule.landBy) - now.getTime();
+  if (!Number.isFinite(untilLanding) || untilLanding < 0 || untilLanding > OP_CUTOFF_WINDOW_MS) return;
+  const append = deps.append ?? defaultAppend;
+  let items: ReturnType<NonNullable<SeatDeps['checklistItems']>>;
+  try { items = (deps.checklistItems ?? ((version: string) => listChecklist(version, releaseRoot).items))(schedule.version); }
+  catch (error) {
+    const entry: SeatEntry = { seat: 'OP', ts: now.toISOString(), at: now.toISOString(), status: 'shadow',
+      reason: `체크리스트 못 읽음: ${schedule.version} (${String(error).slice(0, 200)})`,
+      modeDowngradeReason: 'OP 판정은 shadow 기록만 구현' };
+    append(path, entry);
+    return entry;
+  }
+  const yellow = items.filter((item) => item.status === 'yellow');
+  const runIds = [...new Set(yellow.flatMap((item) => [...(item.evidence ?? '').matchAll(RUN_REFERENCE)].map(([id]) => id.toLowerCase())))];
+  let running = new Set<string>();
+  if (runIds.length) {
+    try {
+      const observed = (deps.cutoffRuns ?? ((ids: readonly string[]) => queryRunningRuns({ runIds: ids, caller: 'seat-loop.op-cutoff' })))(runIds);
+      if (observed.completeness !== 'complete' || observed.pty.unreadable.length) {
+        observe('op-cutoff-runs-unreadable', { version: schedule.version });
+        return;
+      }
+      running = new Set(observed.entries.filter((row) => row.status === 'running' || row.status === 'probable-running' || row.status === 'unknown')
+        .map((row) => row.runId.toLowerCase()));
+    } catch (error) {
+      observe('op-cutoff-runs-unreadable', { version: schedule.version, error: String(error).slice(0, 200) });
+      return;
+    }
+  }
+  const candidates = yellow.filter((item) => ![...(item.evidence ?? '').matchAll(RUN_REFERENCE)]
+    .some(([id]) => running.has(id.toLowerCase())))
+    .sort((a, b) => a.id.localeCompare(b.id))
+    .map(({ id, title, owner }) => ({ id, title, owner: owner ?? '미배정' }));
+  try { debug.log('seat-loop', 'op-cutoff-check', { version: schedule.version, landBy: schedule.landBy, candidates }); }
+  catch { /* Observation cannot change a request. */ }
+  if (!candidates.length) return;
+  const key = `seat-loop:op-cutoff:${schedule.version}:${seatDay(now)}`;
+  const requestPath = join(stateRoot, 'seat-requests', 'requests.jsonl');
+  withSeatRequestLedgerLock(requestPath, () => {
+    if (listSeatRequests(stateRoot).some((row) => row.key === key)) return;
+    appendSeatRequestRows(requestPath, [{ key, seat: 'OP', status: 'pending' as const, queuedAt: now.toISOString(),
+      text: `${schedule.version} 착지 마감 ${schedule.landBy} 전 노랑 칸 점검 — 다음 판으로 옮길지 OP 판단:\n${candidates.map((item) => `${item.id} · ${item.title} · 주인 ${item.owner}`).join('\n')}`,
+      version: schedule.version, landBy: schedule.landBy, candidates }]);
+  });
+}
+
 function opCandidates(deps: SeatDeps, now: Date): OpCandidate[] {
   const releaseRoot = deps.root ?? releaseLedgerRoot();
   const shipped = releasedVersion(releaseRoot);
@@ -827,10 +906,16 @@ function judgeSeatNeighbors(seat: string, config: SeatLoopConfig, deps: SeatDeps
 export async function runSeatLoopOnce(seat: string, deps: SeatDeps = {}): Promise<SeatLoopResult> {
   if (!/^(?:MK|OP|TC|UX)$/.test(seat)) throw new Error(`unknown seat: ${seat}`);
   const config = deps.config ?? getUserConfig().loops?.seat ?? { mode: 'shadow' };
-  if (config.mode === 'off' || !(config.seats ?? ['MK']).includes(seat)) {
+  if (config.mode === 'off') {
     observe('skipped-off', { seat });
     return { seat, status: 'skipped-off' };
   }
+  if (!(config.seats ?? ['MK']).includes(seat)) {
+    // An excluded seat does not read inputs or run the shadow loop; never report it as shadow.
+    observe('skipped-off', { seat });
+    return { seat, status: 'skipped-off',
+      ...(config.mode === 'live-safe' ? { modeDowngradeReason: '자리 목록에 없음 (loops.seat.seats)' } : {}) };
+  }
   const now = (deps.now ?? (() => new Date()))();
   const path = seatLedgerPath(seat, deps.root ?? effectiveInstanceRoot(), now);
   const directory = dirname(path);
@@ -928,6 +1013,7 @@ export async function runSeatLoopOnce(seat: string, deps: SeatDeps = {}): Promis
       return entry;
     }
   }
+  let tcDowngrade: SeatEntry | undefined;
   if (seat === 'TC') {
     const candidates = await tcCandidates(deps, now);
     for (const candidate of candidates) {
@@ -938,19 +1024,27 @@ export async function runSeatLoopOnce(seat: string, deps: SeatDeps = {}): Promis
           && row.candidate.version === candidate.version && row.candidate.id === candidate.id && row.candidate.to === candidate.to);
         if (!inLedger) {
           const entry: SeatEntry = { seat, ts: now.toISOString(), at: now.toISOString(), status: 'shadow', candidate,
+            ...(config.mode === 'live-safe' ? { modeDowngradeReason: 'TC 타 자리 결함 질문은 shadow 기록만 구현' } : {}),
             item: { source: 'checklist', kind: 'cell', id: candidate.id, title: candidate.title, text: candidate.title, version: candidate.version, seat: candidate.to },
             action: 'seat-question', inquiry: { to: candidate.to, question } };
           (deps.append ?? defaultAppend)(path, entry);
+          tcDowngrade ??= entry;
         }
         if (!inLedger || recorded) observe('ask-shadow', { from: seat, to: candidate.to, itemId: candidate.id });
         continue;
       }
       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 };
+      const entry: SeatEntry = { seat, ts: now.toISOString(), at: now.toISOString(), status: 'shadow', candidate,
+        ...(config.mode === 'live-safe' ? { modeDowngradeReason: 'TC PR 판정은 shadow 기록만 구현' } : {}) };
       (deps.append ?? defaultAppend)(path, entry);
+      tcDowngrade ??= entry;
       observe('tc-shadow-candidate', { seat, candidate });
     }
   }
+  if (seat === 'OP' && config.mode === 'live-safe') {
+    const unreadable = checkOpLandingCutoff(deps, now, path, stateRoot);
+    if (unreadable) return unreadable;
+  }
   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}`))) {
@@ -987,7 +1081,8 @@ export async function runSeatLoopOnce(seat: string, deps: SeatDeps = {}): Promis
         if (id !== currentDecision.id) candidates.push({ kind: 'decision-delegation', id, verdict: 'none' });
       }
     }
-    const entries = candidates.map((candidate): SeatEntry => ({ seat, ts: now.toISOString(), at: now.toISOString(), status: 'shadow', candidate }));
+    const entries = candidates.map((candidate): SeatEntry => ({ seat, ts: now.toISOString(), at: now.toISOString(), status: 'shadow', candidate,
+      ...(config.mode === 'live-safe' ? { modeDowngradeReason: 'OP 판정은 shadow 기록만 구현' } : {}) }));
     for (const entry of entries) {
       const candidate = entry.candidate!;
       const previous = [...ledger].reverse().find((row) => row.candidate?.kind === candidate.kind &&
@@ -1003,7 +1098,12 @@ export async function runSeatLoopOnce(seat: string, deps: SeatDeps = {}): Promis
     }
     return entries[0]!;
   }
+  const failedDecisions = new Set<string>();
+  let lastDecisionFailure: SeatEntry | undefined;
+  while (true) {
   const inputs = await gatherSeatInputs(seat, deps, ledger);
+  inputs.requests = inputs.requests.filter((candidate) => !failedDecisions.has(itemKey(candidate)));
+  inputs.checklist = inputs.checklist.filter((candidate) => !failedDecisions.has(itemKey(candidate)));
   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'
@@ -1085,6 +1185,7 @@ export async function runSeatLoopOnce(seat: string, deps: SeatDeps = {}): Promis
         entry.action = 'decision';
       }
       if (questionsMode !== 'on') {
+        if (config.mode === 'live-safe') entry.modeDowngradeReason = '질문 전달 선행 조건 미충족 (questions shadow)';
         if (config.mode === 'live-safe' && !isRescueAllowedAction('seat-question')) {
           observe('refused', { seat, item: item.id, action: 'seat-question', reason: 'question delivery is shadow-only' });
         }
@@ -1192,9 +1293,11 @@ export async function runSeatLoopOnce(seat: string, deps: SeatDeps = {}): Promis
   if (item && config.mode === 'live-safe' && deps.inquire && !isRescueAllowedAction('seat-question')) {
     observe('refused', { seat, item: item.id, action: 'seat-question', reason: 'outbound inquiry not in rescue policy' });
   }
+  if (!item && config.mode === 'live-safe' && tcDowngrade) return tcDowngrade;
   const entry: SeatEntry = { seat, ts: now.toISOString(), at: now.toISOString(), status: item ? 'shadow' : 'skipped-empty',
     ...(item ? { item, action: planned!.kind, ...(planned!.reason ? { reason: planned!.reason } : {}) } : { action: 'skipped-empty' as const }) };
   if (config.mode === 'shadow' || !item) {
+    if (!item && lastDecisionFailure) return lastDecisionFailure;
     append(path, entry);
     if (config.mode === 'shadow') observe('shadow', { seat, item, status: entry.status });
     return entry;
@@ -1282,11 +1385,14 @@ export async function runSeatLoopOnce(seat: string, deps: SeatDeps = {}): Promis
   append(path, { ...entry, status: 'attempting' });
   try {
     if (action.kind === 'decision') {
-      const title = `${seat}: ${action.text.replace(/[\r\n]+/g, ' ')}`;
+      const title = `${seat}: ${decisionSummary(action.text)}`;
+      const source = decisionSourceRef(seat, item);
       const raised = await run(['decisions', 'raise', '--title', title, '--category', 'other',
-        '--s', `${seat} 배정 항목: ${action.text.replace(/[\r\n]+/g, ' ')}\n역할: ${inputs.role}`, '--c', '자동 실행 금지 문면에 해당하여 사람 결정이 필요하다',
+        '--s', decisionSummary(`${seat} 배정 항목: ${action.text.replace(/[\r\n]+/g, ' ')} 역할: ${inputs.role}`),
+        '--c', '자동 실행 금지 문면에 해당하여 사람 결정이 필요하다',
         '--option', 'a=사람 승인:승인 후 별도로 집행', '--option', 'b=보류:집행하지 않음',
-        '--skip-recommend', '금지 문면은 자동으로 권고하지 않는다', '--no-xcheck', '자리 루프 · 이웃 교환은 DEC-XCHECK ②', '--agent', 'seat-loop', '--json']);
+        '--skip-recommend', '금지 문면은 자동으로 권고하지 않는다', '--no-xcheck', '자리 루프 · 이웃 교환은 DEC-XCHECK ②',
+        '--agent', 'seat-loop', '--ref', source, '--json']);
       const decision: unknown = JSON.parse(raised.trim());
       if (!decision || typeof decision !== 'object' || typeof (decision as { id?: unknown }).id !== 'string') {
         throw new Error('decisions raise returned no decision id');
@@ -1332,9 +1438,19 @@ export async function runSeatLoopOnce(seat: string, deps: SeatDeps = {}): Promis
     observe('launched', { seat, item, runId });
     return entry;
   } catch (error) {
-    append(path, { ...entry, status: 'outcome-unknown' });
+    const failure: SeatEntry = { ...entry, status: 'outcome-unknown' };
+    append(path, failure);
+    if (action.kind === 'decision') {
+      lastDecisionFailure = failure;
+      const source = decisionSourceRef(seat, item);
+      try { debug.log('seat-loop', 'decision-raise-failed', { source, error: String(error) }); }
+      catch { /* A failed observation cannot interrupt the remaining items. */ }
+      failedDecisions.add(itemKey(item));
+      continue;
+    }
     throw error;
   }
+  }
   } catch (error) {
     turnError = error;
     throw error;

package/src/self-dev/dev-pipeline.ts

@@ -35,6 +35,7 @@ import type { DocumentReferenceStatus } from '../self-implement/self-implement-r
 import type { SelfDevGoal, OrchestrateSelfDevOptions, SelfDevJobResult } from './orchestrate.js';
 import { launchCapabilityObservation, resolveLaunchCapabilities } from './launch-capabilities.js';
 import { lookupEntrance, type EntranceId } from './entrance-registry.js';
+import { resolveLaunchStamp } from '../harness/launch-stamp.js';
 import type { IngestionEntry } from '../agent-substrate/execution/ingestion-policy.js';
 import type { ReviewerContextItem } from '../agent-substrate/pr-reviewer.js';
 import { resolveRunIdentity, type RunIdSource } from '../harness/harness-space.js';
@@ -42,7 +43,7 @@ import { addSelfDevRunParticipant, processBirthId, saveSelfDevRun } from './run-
 import { getUserConfig, resolveRoleLlm } from '../user-config.js';
 import { reviewReasoningEffort } from '../model-tier/review-effort.js';
 import { getProvider, inferProviderFromModel } from '../llm.js';
-import { buildReviewProviderAttempts, runReviewWithFallback, reviewFallbackModelsFromConfig } from './review-provider-fallback.js';
+import { buildReviewProviderAttempts, defaultReviewFallbackModel, runReviewWithFallback, reviewFallbackModelsFromConfig } from './review-provider-fallback.js';
 import type { DefaultSeamsOptions } from '../self-implement/seams.js';
 import { harnessTargetOptions, resolveHarnessTarget, revalidateHarnessTarget, type HarnessTargetResolution } from '../self-implement/harness-target-options.js';
 import { provisionRepository, type RepoProvisionResult } from '../self-implement/repo-provision.js';
@@ -609,6 +610,7 @@ export function toSelfImplementOptions(text: string, plan: ResolvedDevPlan, seam
     ...(s.correlationId !== undefined ? { correlationId: s.correlationId } : {}),
     ...(s.branchName ? { branchName: s.branchName } : {}),
     ...(s.maxReworkRounds !== undefined ? { maxReworkRounds: s.maxReworkRounds } : {}),
+    launch: resolveLaunchStamp({ entrance: plan.entrance, queueId: process.env.ELANOUS_HARNESS_QUEUE_LAUNCH }),
   };
 }
 
@@ -1093,10 +1095,12 @@ export async function buildDefaultSelfImplementSeams(
     provider: inferProviderFromModel(model) ? getProvider(model) : undefined,
     label,
   });
+  const primaryReviewAttempt = reviewAttemptForModel(reviewModel, 'primary');
   const reviewAttempts = buildReviewProviderAttempts(
-    reviewAttemptForModel(reviewModel, 'primary'),
-    reviewFallbackModels.map((model) => reviewAttemptForModel(model, model)),
-  );
+    primaryReviewAttempt,
+    [...reviewFallbackModels, defaultReviewFallbackModel(primaryReviewAttempt.provider?.name)]
+      .map((model) => reviewAttemptForModel(model, model)),
+  ).slice(0, 2);
   const defaultApiReview = async (prompt: string): Promise<string> => {
     const r = await runReviewWithFallback(
       reviewAttempts,

package/src/self-dev/draft-sweep.ts

@@ -1,6 +1,6 @@
 import { CLAIM_IDLE_HOURS, PR_LABELS, STALLED_DRAFT_HOURS } from '../github/pr-labels.js';
 import { debug } from '../debug/log.js';
-import { decideDraft, type DraftTriagePr } from './draft-triage-rules.js';
+import { decideDraft, sameGoalPr, type DraftTriagePr } from './draft-triage-rules.js';
 
 export interface SweepDraft extends DraftTriagePr {
   readonly title: string;
@@ -33,6 +33,18 @@ export interface DraftSweepAdapters {
   getLatestFileChanges?(draft: SweepDraft, repository: string): Promise<Readonly<Record<string, string>> | undefined>;
   /** Optional merge-time file inventory for the existing all-files-landed decision. */
   getPrFiles?(repository: string, number: number): Promise<readonly string[] | undefined>;
+  /**
+   * Review and gate posture for the daily count. Omitted means unknown — not harvestable and not blocked.
+   * `review: 'pass'` is a review PASS; `mustFix` means must-fix remains; `gate: 'pass'` is a green gate.
+   */
+  getReviewGate?(draft: SweepDraft, repository: string): Promise<SweepReviewGate | undefined>;
+}
+
+/** Review PASS and gate posture used only by the daily old-draft count. */
+export interface SweepReviewGate {
+  readonly review?: 'pass' | 'fail';
+  readonly mustFix?: boolean;
+  readonly gate?: 'pass' | 'fail';
 }
 
 export interface DraftSweepOptions {
@@ -67,9 +79,23 @@ export interface DraftSweepResult {
   claimed?: number;
   /** Running claims older than the idle window, including those kept by liveness. */
   claimExpired?: number;
+  /**
+   * One line per sweep: harness drafts older than 24h, split into closable (a same-goal landing exists),
+   * harvestable (review PASS and gate pass), and blocked (must-fix remains).
+   */
+  daily?: DraftSweepDaily;
   error?: string;
 }
 
+/** Daily old-draft census. `date` is the sweep clock's UTC calendar day. */
+export interface DraftSweepDaily {
+  readonly date: string;
+  readonly over24h: number;
+  readonly closable: number;
+  readonly harvestable: number;
+  readonly blocked: number;
+}
+
 const stateLabels = PR_LABELS.filter((label) => label.axis === 'state');
 const label = (action: 'mark-stalled' | 'close', name?: string): string => {
   const match = PR_LABELS.find((entry) => entry.axis === 'state' && entry.sweep.action === action && (name === undefined || entry.name.endsWith(name)));
@@ -115,7 +141,7 @@ export async function supersedeDraftsOnMerge(input: {
     const mergedFiles = await adapters.getPrFiles?.(repository, merged.number);
     const landed = { ...merged, changedFiles: mergedFiles };
     for (const draft of drafts) {
-      if (draft.number !== merged.number && !liveBranches.has(draft.branch)
+      if (draft.number !== merged.number && draft.branch.startsWith('self-impl/') && !liveBranches.has(draft.branch)
         && Date.parse(draft.createdAt) < Date.parse(merged.mergedAt)) {
         statuses.set(draft.number, await adapters.getRunStatus(draft, repository));
         if (draft.changedFiles?.length && adapters.getLatestFileChanges) {
@@ -125,7 +151,7 @@ export async function supersedeDraftsOnMerge(input: {
     }
     for (const listedDraft of drafts) {
       const draft = { ...listedDraft, latestFileChanges: latestChanges.get(listedDraft.number) };
-      if (draft.number === merged.number || liveBranches.has(draft.branch)
+      if (draft.number === merged.number || !draft.branch.startsWith('self-impl/') || liveBranches.has(draft.branch)
         || Date.parse(draft.createdAt) >= Date.parse(merged.mergedAt)) {
         kept.push(draft.number);
         continue;
@@ -134,7 +160,6 @@ export async function supersedeDraftsOnMerge(input: {
         mergedTwins: [landed], liveBranches, ageHours: NaN });
       if (decision.action !== 'close' || !decision.reason.startsWith(`superseded-by #${merged.number}`)
         || PR_LABELS.filter((entry) => entry.axis === 'state' && draft.labels.includes(entry.name)).length > 1
-        || (draft.labels.length === 0 && !draft.branch.startsWith('self-impl/'))
         || closeAttempts >= DRAFT_SWEEP_CLOSE_CAP) {
         kept.push(draft.number);
         continue;
@@ -144,7 +169,8 @@ export async function supersedeDraftsOnMerge(input: {
       try {
         // Label first: a failed label write must never strand a closed, unlabelled PR outside open-draft sweeps.
         if (!draft.labels.includes(supersededLabel)) await adapters.setLabels(repository, draft.number, { add: supersededLabel, remove });
-        await adapters.closeDraft(repository, draft.number, `Draft sweep: superseded-by #${merged.number}. Branch preserved.`);
+        await adapters.closeDraft(repository, draft.number,
+          `Draft sweep: superseded-by #${merged.number} (https://github.com/${repository}/pull/${merged.number}). Branch preserved.`);
         closed.push(draft.number);
       } catch (failure) {
         kept.push(draft.number);
@@ -171,6 +197,46 @@ async function collectPages<T>(fetch: (page: number, perPage: number) => Promise
   throw new Error('PR listing exceeded pagination limit');
 }
 
+/** First line of a failure, with no stack — the draft-cleanup loop log shows this line as-is. */
+export function sweepFailureReason(error: unknown): string {
+  const message = error instanceof Error ? error.message : String(error);
+  const line = message.split(/\r?\n/).map((part) => part.trim()).find((part) => part.length > 0 && !/^\s*at\s/.test(part));
+  return line && line.length > 0 ? line : 'sweep failed';
+}
+
+function harnessDraft(draft: SweepDraft): boolean {
+  return draft.branch.startsWith('self-impl/') || draft.labels.some((name) => name.startsWith('elanous:'));
+}
+
+/**
+ * Census of harness drafts older than 24h. Same-goal landing uses `sameGoalPr` unchanged.
+ * A draft counts as closable when a same-goal merged PR exists, harvestable when review PASS and the gate passed,
+ * and blocked when must-fix remains. Unknown review/gate is neither harvestable nor blocked.
+ */
+export function draftSweepDaily(
+  drafts: readonly SweepDraft[],
+  merged: readonly SweepMergedPr[],
+  now: Date,
+  reviewGate: ReadonlyMap<number, SweepReviewGate | undefined>,
+): DraftSweepDaily {
+  const cutoff = now.getTime() - STALLED_DRAFT_HOURS * 3_600_000;
+  let over24h = 0;
+  let closable = 0;
+  let harvestable = 0;
+  let blocked = 0;
+  for (const draft of drafts) {
+    if (!harnessDraft(draft)) continue;
+    const created = Date.parse(draft.createdAt);
+    if (!Number.isFinite(created) || created > cutoff) continue;
+    over24h += 1;
+    if (merged.some((pr) => pr.number !== draft.number && sameGoalPr(draft, pr))) closable += 1;
+    const posture = reviewGate.get(draft.number);
+    if (posture?.mustFix === true) blocked += 1;
+    else if (posture?.review === 'pass' && posture.gate === 'pass') harvestable += 1;
+  }
+  return { date: now.toISOString().slice(0, 10), over24h, closable, harvestable, blocked };
+}
+
 /** A failed inventory or liveness lookup is never treated as proof that a draft can be closed. */
 export async function runDraftSweep({ repository, adapters, apply = false, now = new Date() }: DraftSweepOptions): Promise<DraftSweepResult> {
   const result: DraftSweepResult = { repository, apply, complete: false, entries: [], counts: {} };
@@ -181,10 +247,12 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
   };
   const finish = (): DraftSweepResult => {
     debug.log('drafts.cleanup', 'summary', result.counts);
+    if (result.daily) debug.log('harness.drafts', 'daily', result.daily);
+    if (!result.complete && result.error) debug.log('drafts.cleanup', 'failed', { reason: sweepFailureReason(result.error) });
     return result;
   };
-  let drafts: SweepDraft[];
-  let merged: SweepMergedPr[];
+  let drafts: SweepDraft[] = [];
+  let merged: SweepMergedPr[] = [];
   let liveBranches: ReadonlySet<string> | undefined;
   try {
     [drafts, merged, liveBranches] = await Promise.all([
@@ -196,7 +264,8 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
     if (drafts.some((pr) => !Number.isInteger(pr.number) || !pr.branch || !Array.isArray(pr.labels) || !Number.isFinite(Date.parse(pr.createdAt)))
       || merged.some((pr) => !Number.isInteger(pr.number) || !pr.branch)) throw new Error('Invalid PR inventory');
   } catch (error) {
-    result.error = String(error);
+    result.error = sweepFailureReason(error);
+    if (drafts.length > 0) result.daily = draftSweepDaily(drafts, merged, now, new Map());
     return finish();
   }
   let statuses: Map<number, string | undefined>;
@@ -218,9 +287,19 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
       }
     }
   } catch (error) {
-    result.error = String(error);
+    result.error = sweepFailureReason(error);
     return finish();
   }
+  let reviewGate = new Map<number, SweepReviewGate | undefined>();
+  if (adapters.getReviewGate) {
+    try {
+      for (const draft of drafts) reviewGate.set(draft.number, await adapters.getReviewGate(draft, repository));
+    } catch (error) {
+      result.error = sweepFailureReason(error);
+      return finish();
+    }
+  }
+  result.daily = draftSweepDaily(drafts, merged, now, reviewGate);
   result.complete = true;
   let closes = 0;
   let unobserved = 0;
@@ -330,7 +409,8 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
       if (action === 'close') {
         await adapters.closeDraft(repository, draft.number, decision.reason === 'stale-unobserved'
           ? `Draft sweep: run unobserved — no run record reachable here, no host worktree for this branch, idle ≥${STALLED_DRAFT_HOURS}h. Closed as stalled. Branch preserved; reopen to restore.`
-          : `Draft sweep: ${decision.reason}. Branch preserved.`);
+          : `Draft sweep: ${decision.reason}${decision.reason.startsWith('superseded-by #')
+            ? ` (https://github.com/${repository}/pull/${decision.reason.slice('superseded-by #'.length).match(/^\d+/)![0]})` : ''}. Branch preserved.`);
       }
       entry.applied = labelsChanged || action === 'close';
     } catch (error) {