elanous 0.2.16 → 0.2.18

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

@@ -6,11 +6,11 @@ import { dirname, join, resolve } from 'node:path';
 import { promisify } from 'node:util';
 import { TRACK_AGENT_FORBIDDEN_ACTION_REGEX, universeLaunch } from '../autopilot/track-agent.js';
 import { debug } from '../debug/log.js';
-import { surfaceEventsDbPath } from '../domains/surface-events.js';
+import { openSurfaceEventsDb, recordEvent, surfaceEventsDbPath } from '../domains/surface-events.js';
 import { judgeNeighbor } from '../loops/neighbors.js';
 import { addHarnessQueue, harnessQueueIdForKey, harnessQueueOutcome, listHarnessQueue } from '../harness/harness-queue.js';
 import { isRescueAllowedAction } from '../steward/rescue.js';
-import { DecisionLedger, type DecisionEntry } from '../decisions/decision-ledger.js';
+import { DecisionLedger, type DecisionEntry, type DecisionOption, type Recommendation } from '../decisions/decision-ledger.js';
 import { effectiveInstanceRoot, releaseLedgerRoot } from '../instance/resolve.js';
 import { loopEvent } from '../loops/observe.js';
 import { getUserConfig, type PersonaLoopConfig, type SeatLoopConfig, type UserConfig } from '../user-config.js';
@@ -43,7 +43,7 @@ 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; modeDowngradeReason?: string; status: 'shadow' | 'attempting' | 'outcome-unknown' | 'queued' | 'refused' | 'held' | '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 SeatEntry = { seat: string; ts?: string; at: string; modeDowngradeReason?: string; status: 'shadow' | 'attempting' | 'outcome-unknown' | 'queued' | 'refused' | 'held' | 'launched' | 'hitl' | 'wait' | 'asked' | 'answered' | 'awaiting-answer' | 'awaiting-xcheck' | 'awaiting-resolution' | 'resolved-by-neighbor' | 'resolved' | '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 {
@@ -68,7 +68,7 @@ export type SeatDeps = {
   now?: () => Date;
   read?: (path: string) => string;
   run?: (args: string[]) => Promise<string>;
-  enqueue?: (seat: string, text: string, root: string, idempotencyKey: string) => Promise<{ id: string }>;
+  enqueue?: (seat: string, text: string, root: string, idempotencyKey: string, item: SeatItem) => Promise<{ id: string }>;
   queueOutcome?: (id: string, root: string) => ReturnType<typeof harnessQueueOutcome>;
   queueItems?: (root: string) => ReturnType<typeof listHarnessQueue>;
   queueIdForKey?: (key: string, root: string) => string | undefined;
@@ -375,6 +375,23 @@ function decisionSummary(text: string): string {
   return Array.from(sentences).slice(0, 240).join('').trim();
 }
 
+function decisionCardMaterial(input: {
+  what: string; soFar: string; current: string; question: string; answer: string;
+  options: DecisionOption[]; recommendation: Recommendation; ifUntouched: string; evidence: string; confidence: string;
+}): { scqa: { s: string; c: string; q: string; a: string }; pendingQuestion: string } {
+  const short = (value: string) => decisionSummary(value) || '관측되지 않음';
+  return {
+    scqa: { s: short(input.what), c: short(input.current), q: short(input.question), a: short(input.answer) },
+    pendingQuestion: [
+      `무엇: ${input.what}`, `지금까지: ${input.soFar}`, `지금 상태 재측: ${input.current}`,
+      ...input.options.map((option) => `선택지 ${option.key} (${option.label}) 결과: ${option.consequence}`),
+      'skipped' in input.recommendation ? `권고 비움: ${input.recommendation.reason}` : `권고: ${input.recommendation.option} — ${input.recommendation.why}`,
+      `확신: ${input.confidence}`, `그냥 두면: ${input.ifUntouched}`, `근거: ${input.evidence}`,
+      `Q: ${input.question}`, `A: ${input.answer}`,
+    ].join('\n'),
+  };
+}
+
 function decisionSourceRef(seat: string, item: SeatItem): string {
   return item.source === 'request' && item.id.startsWith('coord:') ? item.id : decisionRef(seat, item);
 }
@@ -388,7 +405,7 @@ function decisionReceipt(root: string, seat: string, item: SeatItem): DecisionEn
 function handledKeys(ledger: readonly SeatEntry[], shadow: boolean, root?: string, liveSafe = false): Set<string> {
   const inquiryRow = (entry: SeatEntry) => entry.action === 'seat-question' || entry.action === 'seat-answer' || !!entry.inquiry;
   return new Set(ledger.filter((entry, index) => entry.status === 'asked' || entry.status === 'answered'
-    || entry.status === 'resolved-by-neighbor'
+    || entry.status === 'resolved-by-neighbor' || entry.status === 'resolved'
     // RM3a: only TC's other-seat defect ask-shadows are deduplicated here — an ordinary inquiry recorded in shadow must still be delivered once questions turn on.
     || (entry.status === 'shadow' && entry.candidate?.kind === 'other-seat-cell-defect')
     || (entry.status === 'hitl' && (!entry.inquiry || (!!root && !!entry.item && !!decisionReceipt(root, entry.seat, entry.item))))
@@ -853,7 +870,7 @@ const SEAT_ACTION_RULES: ReadonlyArray<{ kind: 'wait' | 'harness' | 'decision';
   { kind: 'wait', signal: /실측\s*대기|(?:사람|실제)\s*기기(?!\s*(?:(?:실측|측정|확인)\s*)?완료)(?:\s*(?:실측|측정|확인|대기))?|실물\s*측정(?!\s*완료)/iu, source: 'content', resolvedBy: /(?:실측|측정|(?:사람|실제)\s*기기|실물\s*측정)\s*완료/iu },
   { kind: 'wait', signal: /\u{1F451}\s*확인\s*대기/iu, source: 'content', resolvedBy: /\u{1F451}\s*확인\s*완료/iu },
   { kind: 'decision', signal: TRACK_AGENT_FORBIDDEN_ACTION_REGEX, source: 'task' },
-  { kind: 'decision', signal: /(?:마켓|레지스트리)(?:에|로)?\s*(?:게시|등록|발행)|사이트\s*운영\s*반영|SNS(?:에|로)?\s*(?:게시|발행|업로드)|공개\s*발행/iu, source: 'content' },
+  { kind: 'decision', signal: /(?:마켓|레지스트리)(?:에|로)?\s*(?:게시|등록|발행)|사이트\s*운영\s*반영|SNS(?:에|로)?\s*(?:게시|발행|업로드)|공개\s*발행/iu, source: 'task' },
   { kind: 'harness', signal: /(?:마켓|레지스트리|사이트|SNS|공개)?(?:에|로)?\s*(?:게시|발행|배포|등록|운영\s*반영)(?:를?\s*위한)?\s*(?:준비|초안|원고|자료|구현|점검|테스트)|(?:마켓|레지스트리|사이트|SNS|공개)?(?:에|로)?\s*(?:게시|발행|배포|등록)(?:용|를?\s*위한)\s*(?:초안|원고|자료|코드|기능)/iu, source: 'task' },
 ];
 
@@ -861,9 +878,9 @@ export function planAction(item: SeatItem, seat?: string): { kind: 'decision' |
   const task = `${item.id}\n${item.title}\n${item.text}`;
   const content = `${task}\n${item.evidence ?? ''}`;
   const preparation = SEAT_ACTION_RULES.find(({ kind }) => kind === 'harness')!;
-  const prepared = [...content.matchAll(new RegExp(preparation.signal.source, `${preparation.signal.flags.replace('g', '')}g`))];
+  const prepared = [...item.text.matchAll(new RegExp(preparation.signal.source, `${preparation.signal.flags.replace('g', '')}g`))];
   const rule = SEAT_ACTION_RULES.map(({ kind, signal, source, resolvedBy }) => {
-    const text = source === 'content' ? content : task;
+    const text = kind === 'decision' ? item.text : source === 'content' ? content : task;
     if (resolvedBy?.test(item.evidence ?? '')) return null;
     const hits = [...text.matchAll(new RegExp(signal.source, `${signal.flags.replace('g', '')}g`))];
     const hit = kind === 'decision' ? hits.find((match) => !prepared.some((prep) =>
@@ -893,11 +910,11 @@ function neighborLastSeen(root: string, isolated: boolean, now: Date, wanted: Re
   if (!existsSync(path)) return last;
   const db = new Database(path, { readonly: true });
   try {
-    // Same outbound seat events and refs.seat as context day; unlike its 24h display window,
-    // look back across the whole journal so a genuinely old ACK can be judged absent.
+    // Read outbound seat context and loop heartbeats across the whole journal,
+    // unlike context day's 24h display window, so a genuinely old ACK can be judged absent.
     // Newest first and stop once every wanted seat has an ACK, so a long journal is not read and sorted in full each turn.
     const statement = db.prepare(`SELECT ts, refs FROM events
-      WHERE surface IN ('coord:channel', 'context:session') AND direction='outbound' AND ts<=? ORDER BY ts DESC`);
+      WHERE surface IN ('coord:channel', 'context:session', 'loop:heartbeat') AND direction='outbound' AND ts<=? ORDER BY ts DESC`);
     try {
       const events = statement.iterate(now.toISOString()) as Iterable<{ ts: string; refs: string | null }>;
       for (const event of events) {
@@ -936,13 +953,16 @@ function judgeSeatNeighbors(seat: string, config: SeatLoopConfig, deps: SeatDeps
       if (judgment.state === 'absent') {
         if (config.mode === 'live-safe' && judgment.action?.action === 'escalate' && isRescueAllowedAction('decision-card')) {
           const ref = `seat-loop:neighbor:${seat}:${neighbor.id}:${lastSeenAt}`;
+          const options = [{ key: 'a', label: '사람 판단 후 별도 조치', consequence: '자리 루프는 대행하지 않는다' },
+            { key: 'b', label: '현상 유지', consequence: '결측 상태를 계속 관측한다' }];
+          const recommendation = { option: 'b', why: '새 사건을 확인하기 전에는 이웃 업무를 대행하지 않는다' };
           cardLedger(root, deps, now).raiseOnce({ title: `${seat}: 이웃 ${neighbor.id} 결측`, category: 'other',
-            scqa: { s: `${seat} 이웃 ${neighbor.id}의 마지막 맥락 버스 사건: ${lastSeenAt}.`,
-              c: `설정한 heartbeat ${neighbor.heartbeat.everyMinutes}분 × ${neighbor.heartbeat.missedTicks}회 동안 새 사건이 없다.`,
-              q: '결측 이웃의 업무를 어떻게 처리할까?' },
-            options: [{ key: 'a', label: '사람 판단 후 별도 조치', consequence: '자리 루프는 대행하지 않는다' },
-              { key: 'b', label: '현상 유지', consequence: '결측 상태를 계속 관측한다' }],
-            recommendation: { skipped: true, reason: '결측만으로 대행이나 보류를 자동 결정하지 않는다' },
+            ...decisionCardMaterial({ what: `${seat} 이웃 ${neighbor.id} 결측`, soFar: '마지막 맥락 버스 사건 이후 새 ACK 없음',
+              current: `현재 시각 ${now.toISOString()}; 마지막 사건 ${lastSeenAt}; heartbeat ${neighbor.heartbeat.everyMinutes}분 × ${neighbor.heartbeat.missedTicks}회 결측`,
+              question: '결측 이웃의 업무를 어떻게 처리할까?', answer: '새 ACK까지 현상 유지하고 이웃 업무는 대행하지 않는다',
+              options, recommendation, confidence: '중간 — 사건의 부재만 관측됨',
+              ifUntouched: '결측 상태를 계속 관측하며 대행은 하지 않는다', evidence: `맥락 버스 마지막 사건 ${lastSeenAt}; ${ref}` }),
+            options, recommendation,
             raisedBy: { agent: 'seat-loop' }, refs: [ref], raisedAt: now.toISOString(),
             crossCheckSkipped: '이웃 결측으로 교차 확인 불가' }, ref);
           action = 'decision-card';
@@ -976,6 +996,12 @@ export async function runSeatLoopOnce(seat: string, deps: SeatDeps = {}): Promis
   const directory = dirname(path);
   return withSeatLock(directory, async () => {
   const stateRoot = deps.root ?? effectiveInstanceRoot();
+  try {
+    const db = openSurfaceEventsDb(deps.root ? join(stateRoot, 'surface_events.db') : surfaceEventsDbPath());
+    try { recordEvent(db, { surface: 'loop:heartbeat', direction: 'outbound', kind: 'heartbeat',
+      text: `seat loop ${seat} heartbeat`, refs: JSON.stringify({ seat }), ts: now.toISOString() }); }
+    finally { db.close(); }
+  } catch (error) { observe('heartbeat-write-failed', { seat, error: String(error).slice(0, 200) }); }
   const recorded = readSeatLedger(seat, deps, now);
   const ledger = config.mode === 'live-safe' ? reconciledQueueLedger(recorded, stateRoot, deps) : recorded;
   let turnError: unknown;
@@ -1012,10 +1038,17 @@ export async function runSeatLoopOnce(seat: string, deps: SeatDeps = {}): Promis
         const question = proposal.inquiry?.question ?? proposal.item!.title;
         const note = `${proposal.xcheckNote ?? ''} — 해결 가능하다고 했으나 ${waited}분 안 해소 안 됨`.trim();
         if (!decisionReceipt(stateRoot, seat, proposal.item!)) {
+          const options = [{ key: 'a', label: '승인', consequence: '사람 판단으로 진행' }, { key: 'b', label: '보류', consequence: '진행하지 않음' }];
+          const recommendation = { option: 'b', why: `기한 ${waited}분 뒤에도 ${cell?.status ?? '질문 미해결'}이므로 착지 확인 전에는 진행하지 않는다` };
+          const material = decisionCardMaterial({ what: `${seat} 질문 · ${proposal.item!.title}`, soFar: `이웃 ${neighbor} 해결 제안: ${proposal.xcheckNote ?? '기록 없음'}`,
+            current: `기한 ${waited}분 경과 · 칸 상태 ${cell?.status ?? '질문 미해결'}`, question, answer: '재측상 미해결이므로 보류를 권고한다',
+            options, recommendation, confidence: '중간 — 기한 경과와 미해결을 재측함', ifUntouched: '질문/칸은 미해결로 남는다',
+            evidence: `${proposal.item!.evidence ?? '원천 근거 미기재'} · ${note} · ${decisionRef(seat, proposal.item!)}` });
           await (deps.run ?? defaultRun)(['decisions', 'raise', '--title', `${seat}: ${question}`, '--category', 'other',
-            '--s', `${seat} 질문 · ${proposal.item!.title}`, '--c', '이웃 자리 해결 제안이 기한 안에 해소되지 않았다',
+            '--s', material.scqa.s, '--c', material.scqa.c, '--q', material.scqa.q, '--a', material.scqa.a,
+            '--pending-question', material.pendingQuestion,
             '--option', 'a=승인:사람 판단으로 진행', '--option', 'b=보류:진행하지 않음',
-            '--skip-recommend', '근거가 부족하다', '--xcheck', `${neighbor}:${note}`,
+            '--recommend', recommendation.option, '--why', recommendation.why, '--xcheck', `${neighbor}:${note}`,
             '--agent', 'seat-loop', '--ref', decisionRef(seat, proposal.item!), '--json']);
         }
         const entry: SeatEntry = { ...proposal, ts: now.toISOString(), at: now.toISOString(), status: 'hitl' };
@@ -1313,10 +1346,18 @@ export async function runSeatLoopOnce(seat: string, deps: SeatDeps = {}): Promis
                   const check = answer ? ['--xcheck', `${requestedNeighbor}:${answer.note}`,
                     ...(answer.agree ? [] : ['--dissent', `${requestedNeighbor}: ${answer.note}`])]
                     : ['--no-xcheck', `이웃 ${requestedNeighbor} 무응답 ${entry.xcheckWaitMinutes}분`];
+                  const options = [{ key: 'a', label: '승인', consequence: '사람 판단으로 진행' }, { key: 'b', label: '보류', consequence: '진행하지 않음' }];
+                  const recommendation = { option: 'b', why: '교차 확인에서 해소 근거가 확보되지 않았다' };
+                  const material = decisionCardMaterial({ what: `${seat} 질문 · ${item.title}`, soFar: `이웃 ${requestedNeighbor}에 교차 확인 요청`,
+                    current: answer ? `이웃 응답: ${answer.note}` : `이웃 ${requestedNeighbor} 무응답 ${entry.xcheckWaitMinutes}분`,
+                    question: ask.question, answer: '해소 근거 확인 전까지 보류를 권고한다', options, recommendation,
+                    confidence: answer ? '중간 — 이웃 응답을 확인함' : '낮음 — 기한 내 이웃 응답 없음',
+                    ifUntouched: '사람 판단 전 집행하지 않는다', evidence: `${item.evidence ?? '원천 근거 미기재'} · ${decisionRef(seat, item)}` });
                   await (deps.run ?? defaultRun)(['decisions', 'raise', '--title', `${seat}: ${ask.question}`, '--category', 'other',
-                    '--s', `${seat} 질문 · ${item.title}`, '--c', '판단 근거 부족 — 사람의 결정이 필요하다',
+                    '--s', material.scqa.s, '--c', material.scqa.c, '--q', material.scqa.q, '--a', material.scqa.a,
+                    '--pending-question', material.pendingQuestion,
                     '--option', 'a=승인:사람 판단으로 진행', '--option', 'b=보류:진행하지 않음',
-                    '--skip-recommend', '근거가 부족하다', ...check, '--agent', 'seat-loop', '--ref', decisionRef(seat, item), '--json']);
+                    '--recommend', recommendation.option, '--why', recommendation.why, ...check, '--agent', 'seat-loop', '--ref', decisionRef(seat, item), '--json']);
                   if (!decisionReceipt(root, seat, item)) throw new Error('decisions raise did not deliver a matching card');
                   entry.status = 'hitl';
                   xcheckEvent('raised', seat, requestedNeighbor, itemKey(item), answer ? answer.agree ? 'agree' : 'dissent' : 'timed-out');
@@ -1442,11 +1483,27 @@ export async function runSeatLoopOnce(seat: string, deps: SeatDeps = {}): Promis
     if (action.kind === 'decision') {
       const title = `${seat}: ${decisionSummary(action.text)}`;
       const source = decisionSourceRef(seat, item);
+      const options = [{ key: 'a', label: '사람 승인', consequence: '승인 후 별도로 집행' }, { key: 'b', label: '보류', consequence: '집행하지 않음' }];
+      const recommendation = { option: 'b', why: `요청에서 걸린 문면 «${action.reason}»은 자동 집행 대상이 아니므로 보류한다` };
+      let currentStatus: string | undefined;
+      try {
+        currentStatus = item.source === 'checklist' && item.version
+          ? (deps.checklistItems ?? ((version: string) => listChecklist(version, deps.root ?? releaseLedgerRoot()).items))(item.version)
+            .find((cell) => cell.id === item.id && cell.owner === seat)?.status
+          : item.source === 'request' ? listSeatRequests(stateRoot).find((row) => row.key === item.id && row.seat === seat)?.status
+            : undefined;
+      } catch (error) { observe('decision-source-unreadable', { seat, item: item.id, error: String(error).slice(0, 200) }); }
+      const material = decisionCardMaterial({ what: `${seat} 배정 항목: ${item.title} 역할: ${inputs.role || '역할 근거 없음'}`, soFar: `요청 내용: ${item.text}`,
+        current: `밑바탕 재측: ${currentStatus ?? '상태 미확인'}; 요청에서 금지 문면 «${action.reason}» 발견 — 실행 전 사람 승인 필요`,
+        question: `금지 문면 «${action.reason}»이 걸린 요청을 승인할까?`, answer: '승인 전에는 집행하지 않고 보류한다',
+        options, recommendation, confidence: '높음 — 요청에 금지 문면 직접 일치',
+        ifUntouched: '자동 집행되지 않고 해당 칸은 보류 상태로 남는다',
+        evidence: `${item.evidence?.trim() || '추가 근거 미기재'} · 요청 ${source} · 걸린 낱말 ${action.reason}` });
       const raised = await run(['decisions', 'raise', '--title', title, '--category', 'other',
-        '--s', decisionSummary(`${seat} 배정 항목: ${action.text.replace(/[\r\n]+/g, ' ')} 역할: ${inputs.role}`),
-        '--c', '자동 실행 금지 문면에 해당하여 사람 결정이 필요하다',
+        '--s', material.scqa.s, '--c', material.scqa.c, '--q', material.scqa.q, '--a', material.scqa.a,
+        '--pending-question', material.pendingQuestion,
         '--option', 'a=사람 승인:승인 후 별도로 집행', '--option', 'b=보류:집행하지 않음',
-        '--skip-recommend', '금지 문면은 자동으로 권고하지 않는다', '--no-xcheck', '자리 루프 · 이웃 교환은 DEC-XCHECK ②',
+        '--recommend', recommendation.option, '--why', recommendation.why, '--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') {
@@ -1461,25 +1518,38 @@ export async function runSeatLoopOnce(seat: string, deps: SeatDeps = {}): Promis
       const limit = repeatStopLimit(config);
       const attempts = unlandedAttemptCount(seat, item, ledger, stateRoot, deps);
       if (attempts >= limit && !personReopened(ledger, seat, item, stateRoot)) {
+        // Re-read the underlying item at the decision boundary, not the picked snapshot.
+        const current = item.source === 'checklist' && item.version
+          ? (deps.checklistItems ?? ((version: string) => listChecklist(version, deps.root ?? releaseLedgerRoot()).items))(item.version)
+            .find((cell) => cell.id === item.id && cell.owner === seat)?.status
+          : item.source === 'request' ? listSeatRequests(stateRoot).find((row) => row.key === item.id && row.seat === seat)?.status
+            : undefined;
+        if (current === 'green' || current === 'done') {
+          entry.status = 'resolved';
+          entry.reason = `밑바탕 재측: ${current} — 반복 정지 카드 불필요`;
+          append(path, entry);
+          observe('repeat-recovered', { seat, item: item.id, status: current });
+          return entry;
+        }
         const reason = repeatStopReason(attempts);
         entry.status = 'held';
         entry.reason = reason;
         const ref = decisionRef(seat, item);
         const prior = new DecisionLedger({ stateDir: stateRoot }).list({ status: 'all' }).find((card) => card.refs?.includes(ref) && card.status === 'open');
         if (!prior) {
+          const options = [
+            { key: 'a', label: '다시 연다', consequence: '결정 뒤에 자리 루프가 한 번 더 시도할 수 있다' },
+            { key: 'b', label: '멈춘다', consequence: '같은 칸은 다시 발사하지 않는다' },
+          ];
+          const recommendation = { option: 'b', why: `착지 없는 ${attempts}회 재시도보다 현재 칸을 멈추는 편이 중복 실행을 피한다` };
           cardLedger(stateRoot, deps, now).raiseOnce({
-            title: `${seat}: ${item.id} 반복 착지 0`,
-            category: 'other',
-            scqa: {
-              s: `${seat} 칸 ${item.id} 가 착지 없이 ${attempts}회 끝났다.`,
-              c: '같은 칸을 다시 발사하지 않고 사람 판단을 기다린다.',
-              q: '이 칸을 계속할까, 멈출까?',
-            },
-            options: [
-              { key: 'a', label: '다시 연다', consequence: '결정 뒤에 자리 루프가 한 번 더 시도할 수 있다' },
-              { key: 'b', label: '멈춘다', consequence: '같은 칸은 다시 발사하지 않는다' },
-            ],
-            recommendation: { skipped: true, reason: '착지 없는 반복만으로 계속할지 자동 결정하지 않는다' },
+            title: `${seat}: ${item.id} 반복 착지 0`, category: 'other',
+            ...decisionCardMaterial({ what: `${seat} 칸 ${item.id} · ${item.title}`, soFar: `${attempts}회 착지 없이 종료`,
+              current: `발행 직전 밑바탕 재측: ${current ?? '상태 미확인'}; 같은 칸 착지 0`,
+              question: '이 칸을 계속할까, 멈출까?', answer: '중복 발사를 멈추고 사람의 재개 결정을 기다린다',
+              options, recommendation, confidence: current ? '높음 — 밑바탕 상태 재측됨' : '낮음 — 밑바탕 상태 미확인',
+              ifUntouched: '같은 칸은 다시 발사되지 않는다', evidence: `${item.evidence ?? '원천 근거 미기재'} · ${ref} · 완료되지 않은 시도 ${attempts}회` }),
+            options, recommendation,
             raisedBy: { agent: 'seat-loop' },
             refs: [ref],
             raisedAt: now.toISOString(),
@@ -1492,7 +1562,7 @@ export async function runSeatLoopOnce(seat: string, deps: SeatDeps = {}): Promis
       }
       let queued: { id: string };
       try {
-        queued = await (deps.enqueue ?? ((assigned, text, root, idempotencyKey) => addHarnessQueue({ seat: assigned, say: text, idempotencyKey }, { root })))(seat, action.text, stateRoot, queueKey(seat, item));
+        queued = await (deps.enqueue ?? ((assigned, text, root, idempotencyKey) => addHarnessQueue({ seat: assigned, say: text, idempotencyKey }, { root })))(seat, action.text, stateRoot, queueKey(seat, item), item);
       } catch (error) {
         // Same key, different task body: never adopt the other work. Refuse this turn; the key frees once that item finishes.
         if (!/idempotency key collision/.test(String(error))) throw error;

package/src/self-dev/ask-launch-flow.ts

@@ -12,6 +12,7 @@
 //   그래서 결과를 «세 값»으로 낸다: 발사 / 저작 전 중단 / 전제 검사 중단.
 import { linesOutsideFencedCode } from '../self-implement/goal-author.js';
 import { recordAuthoredGoal } from './authored-goal-trace.js';
+import { findAskPathCandidates, type AskPathCandidateOptions } from './ask-path-candidates.js';
 import { retiredEntranceNotice, type EntranceDeclaration } from './entrance-registry.js';
 import {
   classifyConcurrentAuthoring,
@@ -35,6 +36,8 @@ import { dirname, isAbsolute as isAbsolutePath, relative as relativePath, resolv
 import {
   applyClarificationReply,
   planClarificationIntake,
+  selfAnswerGoalDocumentClarifications,
+  type GoalClarificationSelfResolver,
 } from '../self-implement/goal-author-clarification.js';
 import { classifyReauthoredAsk, countMissingAuthoredConstraintMarkers, askGoalTypeDeclaration, declaredGoalType, parseGoalId } from '../self-implement/goal-author.js';
 import { observeFrontNodeEntry } from './graph-front-nodes.js';
@@ -143,6 +146,9 @@ export interface AskLaunchFlowDeps {
   /** Optional structured clarification adapter. Omitted callers retain the
    * existing CLI line-input contract exactly. */
   readClarification?(clarification: GoalDocumentClarification): Promise<string>;
+  selfResolveClarification?: GoalClarificationSelfResolver;
+  /** Replaces the goal document after a self-answer; production entrances pass an atomic writer. */
+  writeGoalDocument?(path: string, document: string): void;
   readFile(path: string): string;
   writeFile(path: string, data: string): void;
   cwd(): string;
@@ -159,6 +165,8 @@ export interface AskLaunchFlowDeps {
   /** ⛔ 못 얻으면 `null` — 같은 이유. */
   recentAuthoringSamples(): RecentAuthoringSample[] | null;
   authorGoal(args: readonly string[], options: Record<string, unknown>): Promise<AskAuthoredGoal>;
+  /** Code-search seam for the one automatic no-target-paths retry. */
+  findPathCandidates?: (askText: string, options: AskPathCandidateOptions) => ReturnType<typeof findAskPathCandidates>;
   /** AUTHOR-TRACE seam (tests). */
   recordAuthoredGoal?: typeof recordAuthoredGoal;
   /** Pod launches reserve a host slot before goal authoring begins. */
@@ -188,6 +196,7 @@ export interface AskLaunchFlowInput {
   readonly askFile?: string;
   /** Optional repository root used only for code grounding during goal authoring. */
   readonly groundingCwd?: string;
+  readonly authorGrade?: import('../self-implement/goal-author.js').GoalAuthorGradeSelection;
   readonly liveRunWindowMinutes: number;
   readonly recentChangeWindowDays: number;
   readonly forceRequested: boolean;
@@ -724,16 +733,27 @@ async function intakeClarifications(
     return effectiveGoalFile;
   }
   if (mode === 'deferred-noninteractive') {
-    // ⛔⭐ 종전엔 「N건 있다」만 말하고 «무엇을 묻는지»도 «어떻게 답하는지»도 안 줬다.
-    //   ⇒ 비대화형 표면(무인 런 · TUI 슬래시)에서 그 물음은 사실상 «사라졌다».
-    //   ⛔ 여기에 새 인터뷰 UI 를 만들지 «않는다» — 답변 창구는 `elanous self clarify answer` 로 «이미» 있다.
-    //     이 자리는 그것을 «가리키기»만 한다(2026-08-11 72차: 오늘만 `F12` 를 여섯 번 셌다).
-    deps.print(`[ask] ⑴b ⚠️ 미답 되묻기 ${pending.length}건 — 저작은 그대로 간다 · 구현 전에 LLM 릴레이가 먼저 답하고, 못 하면 미답으로 진행한다 (사람을 기다리지 않는다)`);
-    for (const item of pending) {
+    // The resolver comes in through deps (I/O seam): production entrances pass the author
+    // self-resolver; a caller that injects none keeps the previous deferred behaviour.
+    if (selfResolveClarifications.value && deps.selfResolveClarification) try {
+      const resolution = await selfAnswerGoalDocumentClarifications(document, {
+        path: 'ask', ask: input.askText, resolver: deps.selfResolveClarification,
+      });
+      if (resolution.newlyAnswered > 0) {
+        (deps.writeGoalDocument ?? deps.writeFile)(effectiveGoalFile, resolution.document);
+        document = resolution.document;
+      }
+    } catch (error) {
+      deps.log('ask-clarify', { goalFile: effectiveGoalFile, reason: 'self-answer-failed', error: error instanceof Error ? error.message : String(error) }, 'warn');
+    }
+    const remaining = planClarificationIntake(document, false).pending;
+    // 미답으로 남은 문항만 기존 답변 창구를 안내한다.
+    deps.print(`[ask] ⑴b ⚠️ 미답 되묻기 ${remaining.length}건 — 저작은 그대로 간다 · 구현 전에 LLM 릴레이가 먼저 답하고, 못 하면 미답으로 진행한다 (사람을 기다리지 않는다)`);
+    for (const item of remaining) {
       deps.print(`[ask]    ❓ [${item.questionId}] ${item.question}`);
       item.options.forEach((option, index) => deps.print(`[ask]       ${index}) ${option.label}`));
     }
-    if (pending.length > 0) {
+    if (remaining.length > 0) {
       const goalArg = deps.relativeToCwd(effectiveGoalFile);
       deps.print(`[ask]    ▶ 답하려면: elanous self clarify answer ${goalArg} <questionId> <옵션번호>   (자유 답은 --other "<문장>")`);
       deps.print(`[ask]    ▶ 답한 뒤 재저작: elanous self author --supersedes ${goalArg}`);
@@ -771,6 +791,7 @@ async function intakeClarifications(
   const reauthored = await deps.authorGoal([], {
     cwd: deps.cwd(),
     ...(input.groundingCwd === undefined ? {} : { groundingCwd: input.groundingCwd }),
+    ...(input.authorGrade === undefined ? {} : { authorGrade: input.authorGrade }),
     fromClarification: `${deps.relativeToCwd(effectiveGoalFile)}#${seedQuestionId}`,
     reauthorFromAnsweredClarification: true,
     selfResolveClarifications: selfResolveClarifications.value,
@@ -831,7 +852,7 @@ export async function runAskLaunchFlow(
   if (launchPreflight === false) return { kind: 'stopped-before-authoring' };
 
   await deps.beforeAuthoring?.();
-  const authorAndPreflight = async (): Promise<{
+  const authorAndPreflight = async (authorAskText: string = input.askText): Promise<{
     readonly goalFile: string;
     readonly decision: ReturnType<typeof decideAskPreflight>;
   }> => {
@@ -850,9 +871,10 @@ export async function runAskLaunchFlow(
     };
     // ⭐ RFC §5 5단계 — 확인된 implement 저작만 활성 구현 그래프에 이름을 잇는다.
     observeFrontNodeEntry('author', { ...frontObservation, provenance: 'authoring-start' });
-    const authored = await deps.authorGoal([input.askText], {
+    const authored = await deps.authorGoal([authorAskText], {
       cwd: deps.cwd(),
       ...(input.groundingCwd === undefined ? {} : { groundingCwd: input.groundingCwd }),
+      ...(input.authorGrade === undefined ? {} : { authorGrade: input.authorGrade }),
       ...(goalType === null ? {} : { goalType }),
       // ⛔ 인라인 ask(`harness say`)는 askFile 이 없다 — 그 칸을 넘기면 저작기가 빈 줄을 쓴다.
       ...(() => {
@@ -992,8 +1014,26 @@ export async function runAskLaunchFlow(
     const first = authored;
     reauthored = true;
     deps.print('[ask] ⑴ ⚠️ 대상 경로를 못 찾아 자동 재저작 한 번을 시도한다');
-    authored = await authorAndPreflight();
+    let candidates: ReturnType<typeof findAskPathCandidates> = { tokens: [], paths: [] };
+    if (parseAskTargetPathHintsResult(input.askText).labelMissing) {
+      try {
+        candidates = (deps.findPathCandidates ?? findAskPathCandidates)(input.askText, { cwd: deps.cwd() });
+      } catch (error) {
+        candidates = { tokens: [], paths: [], error: error instanceof Error ? error.message : String(error) };
+      }
+      deps.log('ask-auto-target-candidates', {
+        tokens: candidates.tokens, paths: candidates.paths,
+        ...(candidates.error === undefined ? {} : { error: candidates.error }),
+      }, candidates.error === undefined ? 'info' : 'warn');
+    }
+    if (candidates.paths.length > 0) {
+      deps.print(`[ask] ⑴ 코드에서 후보 경로 ${candidates.paths.length}개를 찾아 넣고 다시 저작한다: ${candidates.paths.join(' · ')}`);
+    }
+    authored = await authorAndPreflight(candidates.paths.length > 0
+      ? `대상 경로: ${candidates.paths.join(' · ')}\n${input.askText}`
+      : input.askText);
     deps.log('ask-auto-reauthor', {
+      candidatePathCount: candidates.paths.length,
       firstGoalFile: first.goalFile,
       secondGoalFile: authored.goalFile,
       firstPathCount: first.decision.result.paths.length,

package/src/self-dev/ask-path-candidates.ts

@@ -0,0 +1,68 @@
+import { execFileSync } from 'node:child_process';
+import { statSync } from 'node:fs';
+import { isAbsolute, relative, resolve } from 'node:path';
+
+export interface AskPathCandidateOptions {
+  readonly cwd: string;
+  readonly run?: (command: string, args: readonly string[], options: { cwd: string; encoding: 'utf8' }) => string;
+}
+
+export type AskPathCandidates =
+  | { readonly tokens: string[]; readonly paths: string[]; readonly error?: undefined }
+  | { readonly tokens: string[]; readonly paths: string[]; readonly error: string };
+
+const STOP_WORDS = new Set(['the', 'and', 'test', 'src', 'scripts', 'file', 'path', 'paths', 'code', 'with', 'from', 'this', 'that', 'into', 'for', 'then', 'when', 'have', 'does', 'should', 'will', 'please', 'target', 'change']);
+const WORD = /[-/]?[A-Za-z][A-Za-z0-9_.-]*(?:\/[A-Za-z0-9_.-]+)*/g;
+
+function existingFile(fragment: string, cwd: string): string | null {
+  const path = fragment.replace(/^\.\//, '');
+  if (!path.includes('/') && !/\.[A-Za-z][A-Za-z0-9]*$/.test(path)) return null;
+  const absolute = resolve(cwd, path);
+  const rel = relative(cwd, absolute);
+  if (!rel || rel.startsWith('..') || isAbsolute(rel)) return null;
+  try { return statSync(absolute).isFile() ? rel.split('\\').join('/') : null; }
+  catch { return null; }
+}
+
+/** Find existing code paths by lexical evidence from an unmodified ask. */
+export function findAskPathCandidates(askText: string, { cwd, run = execFileSync }: AskPathCandidateOptions): AskPathCandidates {
+  const scores = new Map<string, Set<string>>();
+  const tokens: string[] = [];
+  const seen = new Set<string>();
+  const chunks = [...askText.matchAll(/`([^`]+)`/g)].map((match) => match[1]!).concat([askText]);
+  for (const chunk of chunks) {
+    for (const match of chunk.matchAll(WORD)) {
+      const raw = match[0];
+      const token = raw.replace(/^\//, '');
+      const file = existingFile(token, cwd);
+      if (file) {
+        const hits = scores.get(file) ?? new Set<string>();
+        hits.add(token);
+        scores.set(file, hits);
+      }
+      if (STOP_WORDS.has(token.toLowerCase()) || seen.has(token)) continue;
+      if (!file && !token.includes('/') && !token.includes('.') && !token.includes('-') && !token.includes('_')
+        && !/[a-z][A-Z]/.test(token) && token.length < 4) continue;
+      seen.add(token);
+      tokens.push(token);
+    }
+  }
+  for (const token of tokens) {
+    let matches: string;
+    try {
+      matches = run('rg', ['-l', '-F', '--glob', '!*.test.ts', '--', token, 'src', 'scripts'], { cwd, encoding: 'utf8' });
+    } catch (error) {
+      if ((error as { status?: number }).status === 1) continue; // rg: no matches
+      return { tokens, paths: [], error: error instanceof Error ? error.message : String(error) };
+    }
+    for (const path of matches.split(/\r?\n/).filter(Boolean)) {
+      const hits = scores.get(path) ?? new Set<string>();
+      hits.add(token);
+      scores.set(path, hits);
+    }
+  }
+  return {
+    tokens,
+    paths: [...scores].sort(([a, aHits], [b, bHits]) => bHits.size - aHits.size || a.localeCompare(b, 'en')).slice(0, 5).map(([path]) => path),
+  };
+}

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

@@ -721,6 +721,8 @@ export function buildSelfImplementDevSpec(o: {
   ground?: boolean;
   draft: boolean;
   autoMerge?: boolean;
+  /** Pod child: stop at merge-ready so the launching host re-gates (and checks the landing freeze) before merging. */
+  mergeByHost?: boolean;
   openPr?: boolean;
   autoReview?: boolean;
   autoReviewSource?: DevSelectionSource;
@@ -755,6 +757,8 @@ export function buildSelfImplementDevSpec(o: {
     ...(o.runId ? { runId: o.runId } : {}),
     self: {
       draft: o.draft,
+      // FREEZE-POD: this flag used to be dropped here, so `self implement --merge-by-host` in a Pod merged by itself (#24478).
+      ...(o.mergeByHost === true ? { mergeByHost: true } : {}),
       ...(o.childLlm ? { childLlm: o.childLlm } : {}),
       ...(o.maxWaitSec !== undefined ? { maxWaitSec: o.maxWaitSec } : {}),
       ...(o.ground ? { ground: true } : {}),

package/src/self-dev/draft-triage-rules.ts

@@ -31,7 +31,7 @@ export type DraftDecision = { action: 'close' | 'keep'; reason: string };
 
 // Labels the sweeper must never close: an approval-waiting state and the human «keep» / release holds (R-PRK3).
 // RELGUARD's release-path hold waits for OP approval — a long wait is not «stale» (TC review #23217).
-const PROTECTED_LABELS: ReadonlySet<string> = new Set<string>([...PR_LABELS
+export const PROTECTED_LABELS: ReadonlySet<string> = new Set<string>([...PR_LABELS
   .filter((label) => label.sweep.action === 'exclude' || (label.sweep.action === 'none' && (label.axis === 'state' || label.axis === 'addon')))
   .map((label) => label.name), RELEASE_PATH_LABEL]);
 

package/src/self-dev/orchestrate-cli.ts

@@ -16,6 +16,7 @@ import { resolveOrchestrateConcurrency } from './orchestrate.js';
 import type { FailureClassification, SelfDevGoal, SelfDevJobResult } from './orchestrate.js';
 import { superviseRun, type SupervisorDecision } from './run-supervisor.js';
 import { readDecomposeProposals, applyDecomposeProposals } from './decompose-proposal.js';
+import { createRoundPrTracker, defaultRoundPrAdapters, type RoundPrAdapters } from './round-pr-supersede.js';
 import { createHash } from 'node:crypto';
 import { debug } from '../debug/log.js';
 
@@ -211,6 +212,8 @@ export interface OrchestrateCliDeps {
   pipelineDeps?: DevPipelineDeps;
   /** 분해 제안과 골 개정 시도 되채움 조회(테스트 주입). 기본 readDecomposeProposals(원장). */
   readProposals?: typeof readDecomposeProposals;
+  /** DRAFT-TRIAGE — gh seams for superseding the previous supervisor round's draft PR (tests). */
+  roundPrAdapters?: RoundPrAdapters;
 }
 
 /**
@@ -399,6 +402,23 @@ export async function runSelfOrchestrateCliCommand(
       };
       // ⭐ 루프는 «공용»이다(run-supervisor.superviseRun) — 단일 실행도 같은 자를 쓴다.
       //   ⛔ 여기가 아는 것은 「어떻게 다시 거나」뿐이고, 「걸까 말까」는 그 자가 안다.
+      // DRAFT-TRIAGE — a rework round of the same goal opens a new PR; the previous round's draft is superseded.
+      let roundPrTracker: ReturnType<typeof createRoundPrTracker> | undefined;
+      let supervisedRound = 0;
+      const recordRoundPrs = async (rs: readonly SelfDevJobResult[]): Promise<void> => {
+        try {
+          // Once a PR is tracked, every round runs — an unfinished supersede is retried even without a new PR.
+          if (!roundPrTracker && !rs.some((r) => r.prUrl)) return;
+          roundPrTracker ??= createRoundPrTracker({
+            runId: process.env.ELANOUS_RUN_ID ?? rs.find((r) => r.runId?.trim())?.runId ?? null,
+            adapters: deps.roundPrAdapters ?? await defaultRoundPrAdapters(),
+          });
+          roundPrTracker.record(rs, supervisedRound);
+        } catch (error) {
+          try { debug.log('self-dev.supervisor', 'round-pr-record-failed', { round: supervisedRound, error: String(error) }); } catch { /* fail-open */ }
+        }
+      };
+      await recordRoundPrs(results);
       results = await superviseRun({
         initial: results,
         limits,
@@ -467,6 +487,8 @@ export async function runSelfOrchestrateCliCommand(
           const resumeHold = currentDecision?.needsHuman ?? [];
           const next = await exec(spec, { ...baseRuntime, resumeFrom: [...previous], ...(resumeHold.length > 0 ? { resumeHold } : {}) }, pipelineDeps);
           exitCode = next.exitCode;
+          supervisedRound += 1;
+          await recordRoundPrs(next.results);
           return next.results;
         },
       });