elanous 0.2.16 → 0.2.17

package/src/release-loop/landing-freeze.ts

@@ -1,7 +1,7 @@
-import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
 import { randomUUID } from 'node:crypto';
 import { join } from 'node:path';
-import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { effectiveInstanceRoot, prodInstanceRoot } from '../instance/resolve.js';
 
 export interface LandingFreeze {
   reason: string;
@@ -60,15 +60,23 @@ function mergesDir(root: string): string { return join(root, 'landing-merges');
 
 export interface LandingMergeGuard { frozen: LandingFreeze | null; end: () => void }
 
-export function beginLandingMerge(root = effectiveInstanceRoot(), now = new Date()): LandingMergeGuard {
-  const dir = mergesDir(root);
-  mkdirSync(dir, { recursive: true });
-  const marker = join(dir, `${process.pid}-${randomUUID()}.json`);
-  writeFileSync(marker, `${JSON.stringify({ pid: process.pid, startedAt: now.toISOString() })}\n`, { mode: 0o600 });
-  const end = () => { rmSync(marker, { force: true }); };
+/** Mark both authorities before reading either freeze: the host and the child each drain their own in-flight merges. */
+export function beginLandingMerge(root = effectiveInstanceRoot(), now = new Date(), prodFreezeRoot = prodInstanceRoot(), forceReason?: string): LandingMergeGuard {
+  const markers: string[] = [];
+  const end = () => { for (const marker of markers) rmSync(marker, { force: true }); };
+  try {
+    for (const authority of new Set([prodFreezeRoot, root])) {
+      const dir = mergesDir(authority);
+      mkdirSync(dir, { recursive: true });
+      const marker = join(dir, `${process.pid}-${randomUUID()}.json`);
+      markers.push(marker);
+      writeFileSync(marker, `${JSON.stringify({ pid: process.pid, startedAt: now.toISOString() })}\n`, { mode: 0o600 });
+    }
+  } catch (error) { end(); throw error; }
   let frozen: LandingFreeze | null;
-  try { frozen = readLandingFreeze(root, now); } catch (error) { end(); throw error; }
-  if (frozen) { end(); return { frozen, end: () => {} }; }
+  try { frozen = readLandingFreeze(prodFreezeRoot, now) ?? (root === prodFreezeRoot ? null : readLandingFreeze(root, now)); }
+  catch (error) { end(); throw error; }
+  if (frozen && !forceReason?.trim()) { end(); return { frozen, end: () => {} }; }
   return { frozen: null, end };
 }
 

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

@@ -10,7 +10,7 @@ import { 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 {
@@ -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) =>
@@ -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';
@@ -1012,10 +1032,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 +1340,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 +1477,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 +1512,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(),

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

@@ -35,6 +35,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 +145,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;
@@ -188,6 +193,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 +730,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 +788,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,
@@ -853,6 +871,7 @@ export async function runAskLaunchFlow(
     const authored = await deps.authorGoal([input.askText], {
       cwd: deps.cwd(),
       ...(input.groundingCwd === undefined ? {} : { groundingCwd: input.groundingCwd }),
+      ...(input.authorGrade === undefined ? {} : { authorGrade: input.authorGrade }),
       ...(goalType === null ? {} : { goalType }),
       // ⛔ 인라인 ask(`harness say`)는 askFile 이 없다 — 그 칸을 넘기면 저작기가 빈 줄을 쓴다.
       ...(() => {

package/src/self-dev/run-store.ts

@@ -28,6 +28,7 @@ import type { RunIdSource } from '../harness/harness-space.js';
 import { withFileLockSync } from '../storage/file-lock.js';
 import type { SelfDevJobResult, SelfDevGoal } from './orchestrate.js';
 import type { SupervisorStopReason } from './run-supervisor.js';
+import type { SupervisorNext } from './supervisor-verdict-edges.js';
 import { loadMirroredRunRecord, mirrorRunRecord } from './run-record-mirror.js';
 
 export interface SelfDevRunParticipant {
@@ -92,6 +93,8 @@ export interface SelfDevRunState {
   parkedResolution?: SelfDevRunResolution;
   /** The closed supervisor termination reason, persisted independently from per-goal results. */
   supervisorStopReason?: SupervisorStopReason;
+  /** Named next step at supervisor termination; legacy checkpoints omit it. */
+  next?: SupervisorNext;
   /** ★ C(2026-07-21·HITL 정황 품질) — 이 run 을 구동하는 오케스트레이터 프로세스 pid. 살아있으면
    *  non-terminal goal 은 **실행중(running)** 이지 막힌(interrupted) 게 아니다. 죽었으면(오케스트레이터
    *  killed) 진짜 interrupted. isPidAlive 로 구분해 라이브 잡을 parked/repair-signals 에서 제외. */
@@ -311,13 +314,14 @@ export function recordSelfDevRunSupervisorStop(
   runId: string,
   supervisorStopReason: SupervisorStopReason,
   dir = selfDevRunsDir(),
+  next?: SupervisorNext,
 ): SupervisorStopPersistenceOutcome {
   try {
     if (!existsSync(dir)) return { outcome: 'missing-directory' };
     return withFileLockSync(join(dir, `${runId}.lock`), () => {
       const state = loadSelfDevRunFromPath(runPath(runId, dir));
       if (!state) return { outcome: 'missing-record' };
-      writeSelfDevRun({ ...state, updatedAt: Date.now(), supervisorStopReason }, dir);
+      writeSelfDevRun({ ...state, updatedAt: Date.now(), supervisorStopReason, ...(next === undefined ? {} : { next }) }, dir);
       return { outcome: 'persisted' };
     });
   } catch {

package/src/self-dev/run-supervisor.ts

@@ -6,6 +6,7 @@ import type { SelfDevJobResult } from './orchestrate.js';
 import { recordSelfDevRunSupervisorStop, selfDevRunsDir } from './run-store.js';
 import { debug } from '../debug/log.js';
 import { sweepFrozenMerges } from '../self-implement/frozen-merges.js';
+import { routeSupervisorVerdict, type SupervisorNext } from './supervisor-verdict-edges.js';
 
 export interface SupervisorRound {
   round: number;
@@ -186,6 +187,7 @@ function formatGoalPlanRevisionObservation(results: readonly SelfDevJobResult[])
 export type SupervisorJobResult = SelfDevJobResult & {
   reviewReason?: string;
   salvage?: 'launched' | 'parked';
+  next?: SupervisorNext;
 };
 
 export function decideNextRun(input: {
@@ -592,9 +594,13 @@ export async function superviseRun(opts: SuperviseRunOptions): Promise<Superviso
     } catch { /* fail-open */ }
 
     if (decision.action === 'stop') {
+      const reason = decision.stopReason ?? 'unregistered-stop';
+      const next = routeSupervisorVerdict(reason, results).next;
+      try { debug.log('self-dev.supervisor', 'verdict-edge', { runId, reason, next }); } catch { /* observation must not interrupt supervision */ }
+      results = results.map((result) => ({ ...result, next }));
       if (runId && decision.stopReason) {
         const storage = resolveSupervisorStopStorage(opts.runStore);
-        const persistence = recordSelfDevRunSupervisorStop(runId, decision.stopReason, storage.path);
+        const persistence = recordSelfDevRunSupervisorStop(runId, decision.stopReason, storage.path, next);
         const storageObservation = {
           storagePath: storage.path,
           storageSource: storage.source,

package/src/self-dev/supervisor-verdict-edges.ts

@@ -0,0 +1,46 @@
+import type { SelfDevJobResult } from './orchestrate.js';
+import type { SupervisorStopReason } from './run-supervisor.js';
+
+export type SupervisorNext = 'harvest' | 'scope-decompose' | 'self-review' | 'human-gate' | 'proposal';
+export type SupervisorVerdictEdge = { readonly meaning: string; readonly next: SupervisorNext };
+
+// 목표 규칙: 사람 관문은 결제·공개·자격·비가역 결정에만. 지금 max-rounds·provider-exhausted·step-timeout 이 human-gate 인 것은
+// 그 규칙의 예외로 «그대로» 둔 값이다(시험에 고정 — 바꾸면 보인다).
+export const SUPERVISOR_VERDICT_EDGES = {
+  converged: { meaning: 'run converged', next: 'harvest' },
+  'human-stopped': { meaning: 'human stopped the run', next: 'human-gate' },
+  'parent-signals-red': { meaning: 'parent decision signals are red', next: 'human-gate' },
+  'needs-human': { meaning: 'unresolved human or harvest decision', next: 'human-gate' },
+  'no-actionable-work': { meaning: 'no actionable work remains', next: 'self-review' },
+  'harvestable-awaiting-human': { meaning: 'implementation awaits harvest', next: 'harvest' },
+  'handed-off-to-salvage': { meaning: 'salvage already owns the work', next: 'harvest' },
+  'max-rounds': { meaning: 'round budget exhausted', next: 'human-gate' },
+  'no-progress': { meaning: 'run stalled', next: 'scope-decompose' },
+  'provider-exhausted': { meaning: 'provider quota exhausted', next: 'human-gate' },
+  'step-timeout': { meaning: 'step budget exhausted', next: 'human-gate' },
+  'decomposable-no-progress': { meaning: 'stalled with a decomposition proposal', next: 'scope-decompose' },
+  'review-unobserved': { meaning: 'review was not observed', next: 'self-review' },
+  'deliverable-unobserved': { meaning: 'deliverable was not observed', next: 'self-review' },
+  'deliverable-merged': { meaning: 'deliverable is merged', next: 'harvest' },
+} as const satisfies Record<SupervisorStopReason, SupervisorVerdictEdge>;
+
+const HUMAN_GATE_MERGE_REASONS: ReadonlySet<string> = new Set(['decision-signal-red', 'signal-incomplete', 'parent-unlanded', 'human-gate']);
+
+/** Unknown stop vocabularies are proposals, never silently treated as approved edges. */
+export function routeSupervisorVerdict(
+  reason: string,
+  results: readonly Partial<Pick<SelfDevJobResult, 'status' | 'stage' | 'merged' | 'prNumber' | 'prUrl' | 'blockReason' | 'mergeReason'>>[] = [],
+): SupervisorVerdictEdge {
+  const edge = Object.hasOwn(SUPERVISOR_VERDICT_EDGES, reason)
+    ? SUPERVISOR_VERDICT_EDGES[reason as SupervisorStopReason]
+    : undefined;
+  if (!edge) return { meaning: 'unregistered supervisor stop reason', next: 'proposal' };
+  if (reason !== 'needs-human') return edge;
+  if (results.some((result) => result.blockReason === 'parent-unlanded')) return edge;
+  // A human-gate reason on ANY result in the run keeps the whole run at the human gate.
+  if (results.some((result) => HUMAN_GATE_MERGE_REASONS.has(String(result.mergeReason)))) return edge;
+  const openPrs = results.filter((result) => result.status === 'done' && result.stage === 'pr-opened'
+    && result.merged !== true && (result.prNumber !== undefined || Boolean(result.prUrl)));
+  if (openPrs.length === 0) return edge;
+  return { meaning: 'open PR ready for harvest', next: 'harvest' };
+}

package/src/self-implement/frozen-merges.ts

@@ -2,9 +2,9 @@ import { closeSync, existsSync, mkdirSync, openSync, readFileSync, realpathSync,
 import { dlopen, FFIType } from 'bun:ffi';
 import { createHash } from 'node:crypto';
 import { dirname, join, resolve } from 'node:path';
-import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { effectiveInstanceRoot, prodInstanceRoot } from '../instance/resolve.js';
 import { debug } from '../debug/log.js';
-import { beginLandingMerge, readLandingFreeze, type LandingFreeze } from '../release-loop/landing-freeze.js';
+import { beginLandingMerge, type LandingFreeze } from '../release-loop/landing-freeze.js';
 
 /** `manual`: the owning repository could not be determined — a sweep never resumes it; a person does. */
 export interface FrozenMerge { prNumber: number; headCommit: string; repoRoot: string; manual?: true; /** Host goal document, so a resumed merge can still apply its «이 칸 완료» declaration (CL-AUTO). */ goalFile?: string }
@@ -182,8 +182,10 @@ export function admitLandingMerge(
   root = effectiveInstanceRoot(),
   hooks: { afterQueue?: () => void } = {},
   claimKey?: { prNumber: number; repoRoot: string; headCommit?: string },
+  opts: { prodFreezeRoot?: string; forceReason?: string } = {},
 ): LandingAdmission {
   let entry: FrozenMerge | null | undefined;
+  const prodFreezeRoot = opts.prodFreezeRoot ?? prodInstanceRoot();
   // A held PR is merged by exactly one runner: the claim (repository + PR) is held from admission until the lander's
   // merge has ended. Its queue entry stays until that merge is confirmed — `end(true)` removes this lander's own head;
   // a failed or interrupted merge leaves it for the next resume sweep.
@@ -201,7 +203,7 @@ export function admitLandingMerge(
     } finally { landing.end(); held?.release(); }
   };
   for (;;) {
-    const landing = beginLandingMerge(root);
+    const landing = beginLandingMerge(root, new Date(), prodFreezeRoot, opts.forceReason);
     if (!landing.frozen) {
       if (!claim && claimKey) {
         const key = { prNumber: claimKey.prNumber, repoRoot: repoIdentity(claimKey.repoRoot), headCommit: claimKey.headCommit };
@@ -222,17 +224,19 @@ export function admitLandingMerge(
     if (!entry) return { kind: 'held', freeze: landing.frozen };
     queueFrozenMerge(entry, root);
     hooks.afterQueue?.();
-    if (readLandingFreeze(root)) return { kind: 'held', freeze: landing.frozen };
-    const mine = { ...entry, repoRoot: repoIdentity(entry.repoRoot) };
-    claim = claimFrozenMerge(mine, root);
-    if (!claim) return { kind: 'taken' };
-    // A resume sweep already merged and dequeued it between our queueing and our claim: nothing left to merge.
-    let stillHeld = false;
-    try { stillHeld = readQueue(root).some((item) => sameEntry(item, mine)); }
-    catch (error) { claim.release(); throw error; }
-    if (!stillHeld) { claim.release(); return { kind: 'taken' }; }
-    ownHead = mine;
-    debug.log('harness.merge', 'freeze-lifted-while-queueing', { pr: entry.prNumber });
+    const afterQueue = beginLandingMerge(root, new Date(), prodFreezeRoot, opts.forceReason);
+    if (afterQueue.frozen) return { kind: 'held', freeze: afterQueue.frozen };
+    try {
+      const mine = { ...entry, repoRoot: repoIdentity(entry.repoRoot) };
+      claim = claimFrozenMerge(mine, root);
+      if (!claim) return { kind: 'taken' };
+      // A resume sweep already merged and dequeued it between our queueing and our claim: nothing left to merge.
+      const stillHeld = readQueue(root).some((item) => sameEntry(item, mine));
+      if (!stillHeld) { claim.release(); return { kind: 'taken' }; }
+      ownHead = mine;
+      debug.log('harness.merge', 'freeze-lifted-while-queueing', { pr: entry.prNumber });
+    } catch (error) { claim?.release(); throw error; }
+    finally { afterQueue.end(); }
   }
 }
 
@@ -259,16 +263,17 @@ export async function sweepFrozenMerges(
   },
   root = effectiveInstanceRoot(),
   alreadyMerged: (entry: FrozenMerge) => boolean | Promise<boolean> = githubMergedAt,
+  prodFreezeRoot = prodInstanceRoot(),
 ): Promise<{ pending: number; merged: number }> {
-  const frozen = readLandingFreeze(root);
-  if (frozen) return { pending: readQueue(root).length, merged: 0 };
   const pending = readQueue(root);
   let merged = 0;
   for (const entry of pending) {
-    if (readLandingFreeze(root)) break;
-    const claim = claimFrozenMerge(entry, root);
-    if (!claim) continue; // another sweep or the original lander is on it
+    const guard = beginLandingMerge(root, new Date(), prodFreezeRoot);
+    if (guard.frozen) break;
+    let claim: { release: () => void } | null = null;
     try {
+      claim = claimFrozenMerge(entry, root);
+      if (!claim) continue; // another sweep or the original lander is on it
       if (!readQueue(root).some((item) => sameEntry(item, entry))) continue; // taken back by its lander
       if (entry.manual) { debug.log('harness.merge', 'resume-manual', { pr: entry.prNumber, repoRoot: entry.repoRoot }); continue; }
       if (!(await alreadyMerged(entry))) {
@@ -289,7 +294,7 @@ export async function sweepFrozenMerges(
       });
     } catch (error) {
       debug.log('harness.merge', 'resume-failed', { pr: entry.prNumber, error: String(error) });
-    } finally { claim.release(); }
+    } finally { guard.end(); claim?.release(); }
   }
   return { pending: readQueue(root).length, merged };
 }