elanous 0.2.20 → 0.2.22

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

@@ -1,13 +1,14 @@
 import { execFile } from 'node:child_process';
 import { createHash, randomUUID } from 'node:crypto';
-import { appendFileSync, chmodSync, existsSync, mkdirSync, readFileSync, readdirSync } from 'node:fs';
+import { appendFileSync, chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, statSync } from 'node:fs';
 import { Database } from 'bun:sqlite';
-import { dirname, join, resolve } from 'node:path';
+import { dirname, isAbsolute, join, relative, resolve, sep } 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 { openSurfaceEventsDb, recordEvent, surfaceEventsDbPath } from '../domains/surface-events.js';
 import { judgeNeighbor } from '../loops/neighbors.js';
+import { checkLoopNeighbors, emitLoopHeartbeat, SEAT_NEIGHBORS } from '../loops/neighbor-runtime.js';
 import { addHarnessQueue, harnessQueueIdForKey, harnessQueueOutcome, listHarnessQueue } from '../harness/harness-queue.js';
 import { isRescueAllowedAction } from '../steward/rescue.js';
 import { DecisionLedger, type DecisionEntry, type DecisionOption, type Recommendation } from '../decisions/decision-ledger.js';
@@ -20,6 +21,7 @@ import { openMsgStore, type MessageEnvelope } from '../msg/msg-store.js';
 import { loadLayeredPersonaDirs, resolveRepositoryPersonaDir, resolveStatePersonaDir } from '../persona/global-registry.js';
 import { orderedPersonaTodos, personaTodoPath, readPersonaTodos, type PersonaTodo } from '../persona/persona-todo.js';
 import { PersonaRegistry } from '../persona/registry.js';
+import { registeredSeats, resolveSeat } from '../seat-address/seat-address.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';
@@ -29,7 +31,7 @@ import { readSchedules, releasedVersion } from '../release-loop/feature-store.js
 import { runOpDecide, type OpDecideCandidate } from './op-decide.js';
 
 // `kind`/`createdAt` are the V3 shadow-compare keys (내부 문서 `METHOD-v3-shadow-compare-2026-10-02` · MK 10-02 18:54).
-export type SeatItem = { source: 'request' | 'checklist' | 'hook' | 'seat-question'; kind?: 'request' | 'cell' | 'hook-task' | 'seat-question'; id: string; title: string; text: string; evidence?: string; status?: string; version?: string; seat?: string; evidenceHash?: string; asOf?: string; queuedAt?: string; createdAt?: string; from?: SeatId };
+export type SeatItem = { source: 'request' | 'checklist' | 'hook' | 'seat-question' | 'idle'; kind?: 'request' | 'cell' | 'hook-task' | 'seat-question'; id: string; title: string; text: string; evidence?: string; status?: string; version?: string; seat?: string; evidenceHash?: string; asOf?: string; queuedAt?: string; createdAt?: string; from?: SeatId; idleRung?: 1 | 2 | 3 | 4 | 5 };
 export type SeatInputs = { requests: SeatItem[]; checklist: SeatItem[]; role: string };
 // V3 ledger row: `ts` · `item.id` · `item.kind` · `item.createdAt` · `action` (door, wait or skipped-*) · `reason` (matched rule or forbidden word).
 export type SeatAction = 'decision' | 'harness' | 'wait' | 'seat-question' | 'seat-answer' | 'skipped-budget' | 'skipped-empty';
@@ -44,7 +46,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' | 'resolved' | 'rejected-no-evidence' | 'skipped-budget' | 'skipped-empty'; item?: SeatItem; candidate?: OpCandidate | TcCandidate | OpDecideCandidate; 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 | OpDecideCandidate; 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; emptyQueueMinutes?: number };
 export type SeatLoopResult = SeatEntry | { seat: string; status: 'skipped-off'; modeDowngradeReason?: string };
 
 export function seatLoopTickLine(result: SeatLoopResult): string {
@@ -93,6 +95,8 @@ export type SeatDeps = {
   pullRequests?: () => Promise<TcPullRequest[]>;
   ledgerFiles?: (directory: string) => string[];
   lockContended?: () => void;
+  /** Override the heartbeat timer in isolated long-turn tests; production uses the seat contract's interval. */
+  heartbeatIntervalMs?: number;
   /** Supply a question only when this seat lacks evidence for the selected work item. */
   inquire?: (seat: SeatId, item: SeatItem) => Promise<SeatInquiry | null> | SeatInquiry | null;
   /** Supply the receiving seat's answer; absent evidence must not invent a reply. */
@@ -570,8 +574,8 @@ function opDecidePass(config: SeatLoopConfig, deps: SeatDeps, now: Date, path: s
       mode,
       ledger: cardLedger(stateRoot, deps, now),
       runOwner: deps.runOwner ?? ((runId) => {
-        owners ??= new Map((['OP', 'UX', 'MK', 'TC'] as const).flatMap((owner) =>
-          readSeatLedger(owner, deps, now).filter((row) => row.runId).map((row) => [row.runId!, owner] as const)));
+        owners ??= new Map(registeredSeats().filter(({ id }) => isSeatId(id)).flatMap(({ id: owner }) =>
+          readSeatLedger(owner, deps, now).filter((row) => row.runId).map((row) => [row.runId!, owner as SeatId] as const)));
         return owners.get(runId);
       }),
       routeToSeat: (to, card, reason) => {
@@ -691,9 +695,11 @@ function readTcChecklist(root: string): Array<{ version: string; id: string; tit
   if (!existsSync(path)) return [];
   const db = new Database(path, { readonly: true, strict: true });
   try {
+    const seats = registeredSeats().filter(({ id }) => isSeatId(id)).map(({ id }) => id);
+    if (!seats.length) return [];
     return db.query(`SELECT a.version, f.id, COALESCE(a.title_override, f.title) AS title, a.status, a.owner
-      FROM assignments a JOIN features f ON f.id = a.feature_id WHERE a.status IN ('yellow', 'red') AND a.owner IN ('OP', 'TC', 'MK', 'UX')
-      ORDER BY a.version, f.id`).all() as Array<{ version: string; id: string; title: string; status: string; owner: string | null }>;
+      FROM assignments a JOIN features f ON f.id = a.feature_id WHERE a.status IN ('yellow', 'red') AND a.owner IN (${seats.map(() => '?').join(', ')})
+      ORDER BY a.version, f.id`).all(...seats) as Array<{ version: string; id: string; title: string; status: string; owner: string | null }>;
   } finally { db.close(); }
 }
 
@@ -946,13 +952,48 @@ export function planAction(item: SeatItem, seat?: string): { kind: 'decision' |
   const kind = rule?.kind ?? 'harness';
   const reason = rule?.reason;
   observe('plan', { kind, reason: reason ?? '' });
-  return { kind, text: seat && kind === 'harness' ? seatTaskText(seat, item) : `${item.id} ${item.title}`, ...(reason ? { reason } : {}) };
+  const text = seat && kind === 'harness' ? seatTaskText(seat, item) : `${item.id} ${item.title}`;
+  // Observed once per plan (not per queue comparison): how many target paths the launched ask carries.
+  if (seat && kind === 'harness' && text.startsWith('대상 경로: ')) observe('target-paths', { item: item.id, count: text.split('\n', 1)[0]!.split(' · ').length });
+  return { kind, text, ...(reason ? { reason } : {}) };
+}
+
+/** A path counts only when it resolves to a regular file whose real location stays inside `root` (symlinks out are refused). */
+export function repoFileExists(root: string = repoRoot): (path: string) => boolean {
+  return (path) => {
+    try {
+      const absolute = resolve(root, path);
+      const real = relative(realpathSync(root), realpathSync(absolute));
+      return !!real && real !== '..' && !real.startsWith(`..${sep}`) && !isAbsolute(real) && statSync(absolute).isFile();
+    } catch { return false; }
+  };
+}
+
+// Repository paths already written in a checklist item's title or evidence (dedup · first-seen order · at most six).
+export function seatTargetPaths(item: SeatItem, isFile: (path: string) => boolean = repoFileExists()): string[] {
+  const paths: string[] = [];
+  const text = `${item.title}\n${item.evidence ?? ''}`;
+  const matches = text.matchAll(/(?:^|[^A-Za-z0-9_./-])((?:src|apps|scripts|test|docs|bin|graphs|packs|plugins)\/[A-Za-z0-9_./-]+)/g);
+  for (const match of matches) {
+    const path = match[1]!.replace(/[./]+$/, '');
+    if (path.split('/').includes('..')) continue;
+    const fromRoot = relative(repoRoot, resolve(repoRoot, path));
+    if (!fromRoot || fromRoot === '..' || fromRoot.startsWith(`..${sep}`) || isAbsolute(fromRoot) || !isFile(path)) continue;
+    if (!paths.includes(path)) paths.push(path);
+    if (paths.length === 6) break;
+  }
+  return paths;
 }
 
 // The launched sentence names the seat, the source and the release so same-named items stay distinct.
-export function seatTaskText(seat: string, item: SeatItem): string {
-  const where = item.source === 'checklist' ? `${item.version ?? '?'} 체크리스트 칸 ${item.id}` : item.source === 'hook' ? `웹훅 작업 카드 ${item.id}` : `자리 요청 ${item.id}`;
-  return `[${seat} 자리 · ${where} · 역할 docs/roles/${seat}.md] ${item.title.replace(/[\r\n]+/g, ' ')}`;
+// Checklist items whose title/evidence already name repository files get a leading `대상 경로:` line
+// (the label parseAskTargetPathHints reads); without paths the text is byte-identical to the old one-liner.
+export function seatTaskText(seat: string, item: SeatItem, isFile?: (path: string) => boolean): string {
+  const where = item.source === 'checklist' ? `${item.version ?? '?'} 체크리스트 칸 ${item.id}` : item.source === 'idle' ? `쉬는 시간 사다리 ${item.id} · ${item.idleRung}단계${item.version ? ` · ${item.version}` : ''}` : item.source === 'hook' ? `웹훅 작업 카드 ${item.id}` : `자리 요청 ${item.id}`;
+  const text = `[${seat} 자리 · ${where} · 역할 docs/roles/${seat}.md] ${item.title.replace(/[\r\n]+/g, ' ')}`;
+  if (item.source !== 'checklist') return text;
+  const paths = seatTargetPaths(item, isFile);
+  return paths.length ? `대상 경로: ${paths.join(' · ')}\n${text}` : text;
 }
 
 function xcheckEvent(event: string, seat: string, neighbor: string, item: string, outcome: string): void {
@@ -986,8 +1027,10 @@ function neighborLastSeen(root: string, isolated: boolean, now: Date, wanted: Re
 }
 
 function neighborSeat(id: string): string | null {
-  const match = /^(op|tc|mk|ux)-seat$/i.exec(id);
-  return match ? match[1]!.toUpperCase() : null;
+  const match = /^([A-Za-z][A-Za-z0-9_-]*)-seat$/i.exec(id);
+  if (!match) return null;
+  const resolved = resolveSeat(match[1]!)?.id;
+  return resolved && isSeatId(resolved) ? resolved : null;
 }
 
 function judgeSeatNeighbors(seat: string, config: SeatLoopConfig, deps: SeatDeps, root: string, now: Date): void {
@@ -1034,8 +1077,89 @@ function judgeSeatNeighbors(seat: string, config: SeatLoopConfig, deps: SeatDeps
   }
 }
 
+const IDLE_WORK: Record<SeatId, string> = {
+  MK: '문서 최적화: 현재 문서의 탐색·명료성·검색 유입을 실물 근거로 개선',
+  UX: '멀티 서피스: 실제 채널별 사용자 흐름을 대조하고 결함을 개선',
+  TC: '하니스 자가 치유: 실패 원장을 대조하여 재현 가능한 결함을 수리',
+  OP: '보충 저작: 판 체크리스트의 빠진 칸을 근거와 반증 기준으로 보완',
+};
+
+function idleCell(seat: string, rung: 1 | 2 | 3 | 4 | 5, id: string, title: string, now: Date, version?: string, owner?: string, evidence?: string): SeatItem {
+  return { source: 'idle', id, title, text: title, idleRung: rung, seat: owner ?? seat,
+    ...(version ? { version } : {}), ...(evidence ? { evidence } : {}), asOf: now.toISOString() };
+}
+
+function emptyQueueMinutes(ledger: readonly SeatEntry[], now: Date): number {
+  const previousIndex = [...ledger].reverse().findIndex((row) => row.emptyQueueMinutes !== undefined);
+  const workIndex = [...ledger].reverse().findIndex((row) => row.item && row.item.source !== 'idle' && row.status !== 'skipped-empty');
+  const previousPosition = previousIndex < 0 ? -1 : ledger.length - 1 - previousIndex;
+  const workPosition = workIndex < 0 ? -1 : ledger.length - 1 - workIndex;
+  const previous = ledger[previousPosition];
+  const lastWork = ledger[workPosition];
+  const previousAt = previous ? Date.parse(previous.at) : NaN;
+  const workAt = lastWork ? Date.parse(lastWork.at) : NaN;
+  const start = Number.isFinite(previousAt) && Number.isFinite(workAt) ? Math.max(previousAt, workAt)
+    : Number.isFinite(previousAt) ? previousAt : workAt;
+  if (!Number.isFinite(start)) return 0;
+  const prior = previousPosition > workPosition ? previous!.emptyQueueMinutes! : 0;
+  return prior + Math.max(0, (now.getTime() - start) / 60_000);
+}
+
+function pickIdleWork(seat: SeatId, deps: SeatDeps, ledger: readonly SeatEntry[], now: Date, root: string, shadow: boolean): SeatItem | null {
+  const releaseRoot = deps.root ?? releaseLedgerRoot();
+  const schedules = (deps.schedules ?? (() => readSchedules(releaseRoot)))()
+    .filter((row) => /^\d+\.\d+\.\d+$/.test(row.version) && Number.isFinite(Date.parse(row.cutAt)))
+    .sort((a, b) => versionOrder(a.version, b.version));
+  const shipped = releasedVersion(releaseRoot);
+  const current = schedules.find((row) => Date.parse(row.cutAt) > now.getTime() && (!shipped || versionOrder(row.version, shipped) > 0));
+  const itemsOf = deps.checklistItems ?? ((version: string) => listChecklist(version, releaseRoot).items);
+  const handled = handledKeys(ledger, shadow, root, !shadow);
+  const available = (item: SeatItem) => eligibleItem(item, ledger, handled, shadow);
+  // The normal queue handles open owned cells first; a landed yellow cell is revisited here for physical rebuttal.
+  for (const row of schedules.filter((row) => row.version === current?.version || Date.parse(row.cutAt) <= now.getTime() || (shipped && versionOrder(row.version, shipped) <= 0))) {
+    for (const cell of itemsOf(row.version).filter((cell) => cell.owner === seat && cell.status === 'yellow' && /착지|merged|병합/i.test(cell.evidence ?? '')).sort((a, b) => a.id.localeCompare(b.id))) {
+      const item = idleCell(seat, 2, cell.id, `착지 후 노랑 실물 반증: ${cell.id} · ${cell.title}`, now, row.version, seat, cell.evidence);
+      item.evidenceHash = createHash('sha256').update(cell.evidence ?? '').digest('hex');
+      if (available(item)) return item;
+    }
+  }
+  const next = schedules.find((row) => current && versionOrder(row.version, current.version) > 0);
+  if (next) {
+    const title = `${next.version} 다음 판 칸 저작: ${seat} 자리의 자율성·효율성·동시성을 높일 칸을 근거와 실물 반증부터 작성`;
+    const item = idleCell(seat, 3, `author:${seat}`, title, now, next.version);
+    if (available(item)) return item;
+  }
+  const recurring = idleCell(seat, 4, `recurring:${seat}:${seatDay(now)}`, IDLE_WORK[seat], now);
+  if (available(recurring)) return recurring;
+  const queue = (deps.queueItems ?? ((stateRoot: string) => listHarnessQueue({ root: stateRoot })))(root);
+  const candidates: Array<{ owner: SeatId; item: SeatItem; pressure: number }> = [];
+  for (const owner of ['OP', 'MK', 'UX', 'TC'] as const) {
+    if (owner === seat) continue;
+    const ownerLedger = readSeatLedger(owner, deps, now);
+    const busy = queue.filter((row) => row.seat === owner && ['queued', 'launching', 'launched'].includes(row.status)).length;
+    for (const row of schedules.filter((row) => Date.parse(row.cutAt) > now.getTime() && (!shipped || versionOrder(row.version, shipped) > 0))) {
+      for (const cell of itemsOf(row.version).filter((cell) => cell.owner === owner && cell.status === 'yellow')) {
+        const evidence = cell.evidence ?? '';
+        const runIds = [...evidence.matchAll(RUN_REFERENCE)].map(([id]) => id.toLowerCase());
+        if (runIds.length) {
+          const observed = (deps.cutoffRuns ?? ((ids: readonly string[]) => queryRunningRuns({ runIds: ids, caller: 'seat-loop.idle' })))(runIds);
+          if (observed.completeness !== 'complete' || observed.pty.unreadable.length || observed.entries.some((entry) => entry.status !== 'ended-unclosed')) continue;
+        }
+        if (ownerLedger.some((entry) => entry.item?.source === 'checklist' && entry.item.id === cell.id && entry.item.version === row.version
+          && ['queued', 'attempting', 'outcome-unknown', 'launched'].includes(entry.status))) continue;
+        if (queue.some((entry) => entry.seat === owner && ['queued', 'launching', 'launched'].includes(entry.status)
+          && entry.input.includes(`체크리스트 칸 ${cell.id} ·`))) continue;
+        const item = idleCell(seat, 5, `borrow:${owner}:${cell.id}`, `${row.version} ${cell.id} · ${cell.title} — ${seat} 지원 (주인 ${owner} 유지)`, now, row.version, owner, evidence);
+        item.evidenceHash = createHash('sha256').update(evidence).digest('hex');
+        if (available(item)) candidates.push({ owner, item, pressure: busy + itemsOf(row.version).filter((entry) => entry.owner === owner && entry.status === 'yellow').length });
+      }
+    }
+  }
+  return candidates.sort((a, b) => b.pressure - a.pressure || a.owner.localeCompare(b.owner) || a.item.id.localeCompare(b.item.id))[0]?.item ?? null;
+}
+
 export async function runSeatLoopOnce(seat: string, deps: SeatDeps = {}): Promise<SeatLoopResult> {
-  if (!/^(?:MK|OP|TC|UX)$/.test(seat)) throw new Error(`unknown seat: ${seat}`);
+  if (!isSeatId(seat) || !registeredSeats().some(({ id }) => id === seat)) throw new Error(`unknown seat: ${seat}`);
   const config = deps.config ?? getUserConfig().loops?.seat ?? { mode: 'shadow' };
   if (config.mode === 'off') {
     observe('skipped-off', { seat });
@@ -1060,6 +1184,25 @@ export async function runSeatLoopOnce(seat: string, deps: SeatDeps = {}): Promis
   } 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;
+  const loopId = seat === 'MK' ? 'cmo-seat' : `${seat.toLowerCase()}-seat`;
+  const heartbeatEveryMs = (SEAT_NEIGHBORS[seat]?.find((peer) => peer.id !== 'orchestrator')?.heartbeat.everyMinutes ?? 15) * 60_000;
+  const leaseMs = heartbeatEveryMs * 2;
+  const pulse = (health: 'healthy' | 'degraded', at: Date): void => {
+    try { emitLoopHeartbeat(stateRoot, loopId, health, at, new Date(at.getTime() + leaseMs).toISOString()); }
+    catch (error) { observe('neighbor-runtime-failed', { seat, error: String(error).slice(0, 200) }); }
+  };
+  pulse('healthy', (deps.now ?? (() => new Date()))());
+  const watchNeighbors = (at: Date): void => {
+    try { checkLoopNeighbors(stateRoot, loopId, SEAT_NEIGHBORS[seat] ?? [], at); }
+    catch (error) { observe('neighbor-runtime-failed', { seat, error: String(error).slice(0, 200) }); }
+  };
+  // A long turn keeps both duties periodic: renew our lease and watch neighbors (incidents are idempotent).
+  const heartbeatTimer = setInterval(() => {
+    const at = (deps.now ?? (() => new Date()))();
+    pulse('healthy', at);
+    watchNeighbors(at);
+  }, deps.heartbeatIntervalMs ?? heartbeatEveryMs / 2);
+  heartbeatTimer.unref();
   if (seat === 'OP') opDecidePass(config, deps, now, path, stateRoot, ledger);
   let turnError: unknown;
   try {
@@ -1259,8 +1402,14 @@ export async function runSeatLoopOnce(seat: string, deps: SeatDeps = {}): Promis
     checklist: inputs.checklist.filter((candidate) => !ledger.some((row) => row.status === 'awaiting-resolution'
       && row.item && itemKey(row.item) === itemKey(candidate) && itemSnapshot(row.item) === itemSnapshot(candidate))) }, ledger,
     { shadow: config.mode === 'shadow', liveSafe: config.mode === 'live-safe', root: stateRoot, history: deps.checklistHistory ?? checklistHistory });
-  const item = pendingQuestion ?? ordinary;
-  const append = deps.append ?? defaultAppend;
+  const ownQueueEmpty = !pendingQuestion && !ordinary;
+  const idleMinutes = ownQueueEmpty ? emptyQueueMinutes(ledger, now) : undefined;
+  // IDLE-LADDER: off unless loops.seat.idleLadder is set; 'shadow' records the idle pick only, 'live' lets live-safe/on launch it.
+  const idleShadow = config.mode === 'shadow' || config.idleLadder !== 'live';
+  const item = pendingQuestion ?? ordinary ?? (ownQueueEmpty && !lastDecisionFailure && (config.idleLadder === 'shadow' || config.idleLadder === 'live')
+    ? pickIdleWork(seat as SeatId, deps, ledger, now, stateRoot, idleShadow) : null);
+  const appendBase = deps.append ?? defaultAppend;
+  const append: typeof appendBase = (file, row) => appendBase(file, idleMinutes === undefined ? row : { ...row, emptyQueueMinutes: idleMinutes });
   const revisedProposal = item?.source === 'checklist' && ledger.some((row) => row.status === 'awaiting-resolution'
     && row.item && itemKey(row.item) === itemKey(item) && itemSnapshot(row.item) !== itemSnapshot(item));
   if (config.mode === 'live-safe' && !pendingQuestion) {
@@ -1448,11 +1597,12 @@ export async function runSeatLoopOnce(seat: string, deps: SeatDeps = {}): Promis
   }
   if (!item && config.mode === 'live-safe' && tcDowngrade) return tcDowngrade;
   const entry: SeatEntry = { seat, ts: now.toISOString(), at: now.toISOString(), status: item ? 'shadow' : 'skipped-empty',
+    ...(idleMinutes === undefined ? {} : { emptyQueueMinutes: idleMinutes }),
     ...(item ? { item, action: planned!.kind, ...(planned!.reason ? { reason: planned!.reason } : {}) } : { action: 'skipped-empty' as const }) };
-  if (config.mode === 'shadow' || !item) {
+  if (config.mode === 'shadow' || !item || (item.source === 'idle' && idleShadow)) {
     if (!item && lastDecisionFailure) return lastDecisionFailure;
     append(path, entry);
-    if (config.mode === 'shadow') observe('shadow', { seat, item, status: entry.status });
+    if (config.mode === 'shadow' || item?.source === 'idle') observe('shadow', { seat, item, status: entry.status });
     return entry;
   }
   if (planned!.kind === 'wait') {
@@ -1669,8 +1819,12 @@ export async function runSeatLoopOnce(seat: string, deps: SeatDeps = {}): Promis
     turnError = error;
     throw error;
   } finally {
+    clearInterval(heartbeatTimer);
     // A turn ends even when there is no picked item or a launch fails.
-    try { judgeSeatNeighbors(seat, config, deps, stateRoot, (deps.now ?? (() => new Date()))()); }
+    const endedAt = (deps.now ?? (() => new Date()))();
+    pulse(turnError === undefined ? 'healthy' : 'degraded', endedAt);
+    watchNeighbors(endedAt);
+    try { judgeSeatNeighbors(seat, config, deps, stateRoot, endedAt); }
     catch (error) {
       observe('neighbor-judgment-failed', { seat, error: String(error).slice(0, 200) });
       const neighbors = config.neighbors?.[seat as keyof NonNullable<SeatLoopConfig['neighbors']>] ?? [];

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

@@ -7,6 +7,10 @@ import { debug } from '../debug/log.js';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
 import { getUserConfig, type SeatLoopConfig } from '../user-config.js';
 import { collectDraftMetrics, collectOverlapMetrics, countSalvagedToday, type DraftMetrics, type OverlapMetrics } from '../self-dev/draft-sweep.js';
+import { queryRunningRuns } from '../self-implement/running-runs.js';
+import { readTaskAgentCover } from '../cli/tasks-cli.js';
+import { formatTaskAgentCover } from '../task-agent/cover.js';
+import type { TasksCliDeps } from '../cli/tasks-cli.js';
 import { seatDay, seatLedgerPath, type OpCandidate, type SeatEntry } from './seat-loop.js';
 
 export type SeatReportDeps = {
@@ -19,8 +23,10 @@ export type SeatReportDeps = {
   send?: (body: string, seat: string, pr: number) => Promise<void> | void;
   draftMetrics?: (now: Date) => Promise<DraftMetrics>;
   overlapMetrics?: (now: Date) => Promise<OverlapMetrics>;
+  coverLogs?: TasksCliDeps['coverLogs'];
   /** DRAFT-NOT-ARCHIVE salvage branches since the KST day start; null = unreadable. */
   salvagedToday?: (dayStart: Date, now: Date) => Promise<number | null>;
+  runningRuns?: (runIds: readonly string[]) => { running: number; unknown: number } | null;
 };
 export type SeatReportResult = { seat: string; date: string; body: string; posted: boolean };
 const repoRoot = resolve(import.meta.dir, '../..');
@@ -144,8 +150,30 @@ export async function seatReport(seat: string, deps: SeatReportDeps = {}): Promi
       }))(new Date(`${date}T00:00:00+09:00`), now);
     } catch { salvagedToday = null; }
     draftDetail += ` · 수확 가지 오늘 ${salvagedToday === null ? '못 잼' : salvagedToday}`;
+    try {
+      const cover = readTaskAgentCover({}, deps.coverLogs);
+      draftDetail += ` · TASK-AGENT cover ${formatTaskAgentCover(cover.rows[0]!)}${cover.unreadableStores ? ` (logs.db ${cover.unreadableStores}개 못 읽음)` : ''}`;
+    } catch {
+      draftDetail += ` · TASK-AGENT cover ${formatTaskAgentCover({ verb: 'land', byTaskAgent: null, total: null, observedActions: null, ratio: null, state: 'unreadable', liveActions: null, shadowActions: null, stewardTransition: 'unmeasured' })}`;
+    }
+  }
+  const runIds = [...new Set(entries.filter((entry) => entry.status === 'launched' && entry.runId).map((entry) => entry.runId!))];
+  let runningDetail = ' · 도는 런 0';
+  if (runIds.length) {
+    try {
+      const counts = (deps.runningRuns ?? ((ids: readonly string[]) => {
+        const observed = queryRunningRuns({ runIds: ids, caller: 'seat-report' });
+        if (observed.completeness !== 'complete') return null;
+        return {
+          running: observed.entries.filter((entry) => ids.includes(entry.runId) && entry.status === 'running').length,
+          unknown: observed.entries.filter((entry) => ids.includes(entry.runId) && (entry.status === 'probable-running' || entry.status === 'unknown')).length,
+        };
+      }))(runIds);
+      runningDetail = counts === null ? ' · 도는 런 못 잼'
+        : ` · 도는 런 ${counts.running}(불확실 ${counts.unknown})`;
+    } catch { runningDetail = ' · 도는 런 못 잼'; }
   }
-  const body = `**[${seat}]** {{TS}} → 보고 ${date}: ${detail.join(' · ') || (classified.length ? 'OP 그림자 판단' : '원장 기록 없음')}${opDetail}${draftDetail}`;
+  const body = `**[${seat}]** {{TS}} → 보고 ${date}: ${detail.join(' · ') || (classified.length ? 'OP 그림자 판단' : '원장 기록 없음')}${opDetail}${draftDetail}${runningDetail}`;
   const pr = (deps.config ?? getUserConfig().loops?.seat)?.reportPr;
   const posted = deps.post === true && pr !== undefined;
   if (posted) await (deps.send ?? ((text, id, number) => defaultSend(text, id, number, deps.repo ?? repoRoot)))(body, seat, pr);

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

@@ -852,7 +852,7 @@ export async function runAskLaunchFlow(
   if (launchPreflight === false) return { kind: 'stopped-before-authoring' };
 
   await deps.beforeAuthoring?.();
-  const authorAndPreflight = async (authorAskText: string = input.askText): Promise<{
+  const authorAndPreflight = async (authorAskText: string = input.askText, machineSuggestedTargetPaths: readonly string[] = []): Promise<{
     readonly goalFile: string;
     readonly decision: ReturnType<typeof decideAskPreflight>;
   }> => {
@@ -950,6 +950,8 @@ export async function runAskLaunchFlow(
         recentChangeWindowDays: input.recentChangeWindowDays,
         openPrsLimit: OPEN_PR_LIMIT,
         ...(askOutsidePathHints.length > 0 ? { askOutsidePathHints } : {}),
+        // AUTO-TARGET: paths injected by the candidate search (not written in the ask) — a NOT-GROUNDED goal stops on them.
+        ...(machineSuggestedTargetPaths.length > 0 ? { machineSuggestedTargetPaths } : {}),
         declaredPathsRoot: deps.cwd(),
       },
       preflightDeps,
@@ -1032,7 +1034,7 @@ export async function runAskLaunchFlow(
     }
     authored = await authorAndPreflight(selectedPaths.length > 0
       ? `대상 경로: ${selectedPaths.join(' · ')}\n${input.askText}`
-      : input.askText);
+      : input.askText, selectedPaths);
     deps.log('ask-auto-reauthor', {
       candidatePathCount: candidates.paths.length,
       firstGoalFile: first.goalFile,

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

@@ -97,7 +97,7 @@ function inspectLaunchingTree(cwd: string): LaunchingTreeProbe {
 
 /** 발사 전 검사가 쓰는 조회 구현 — ⛔ 이 «한 벌»을 모든 표면이 공유한다. */
 export async function buildAskPreflightDeps(options: BuildAskPreflightDepsOptions = {}): Promise<AskPreflightDeps & { inspectLaunchingTree(cwd: string): LaunchingTreeProbe }> {
-  const [{ tracedPathReferences, verbatimOriginalAsk }, { loadRunLedger, queryFederatedCompletedRunLedgers, queryFederatedInterruptedRunLedgers, queryFederatedUnfinishedRunLedgers }] = await Promise.all([
+  const [{ tracedPathReferences, verbatimOriginalAsk, isNotGroundedWithoutPersistentEvidence }, { loadRunLedger, queryFederatedCompletedRunLedgers, queryFederatedInterruptedRunLedgers, queryFederatedUnfinishedRunLedgers }] = await Promise.all([
     import('../self-implement/goal-author.js'),
     import('../self-implement/run-ledger.js'),
   ]);
@@ -166,6 +166,8 @@ export async function buildAskPreflightDeps(options: BuildAskPreflightDepsOption
     //   ⛔ ask 표지가 없으면 빈 배열 — 그때는 표시가 «안 붙는다»(지어내지 않는다).
     askTargetPaths: (document: string) => parseAskTargetPathHints(verbatimOriginalAsk(document) ?? ''),
     askTargetPathRejections: (document: string) => parseAskTargetPathHintsResult(verbatimOriginalAsk(document) ?? '').rejected,
+    // AUTO-TARGET: a NOT-GROUNDED goal (no persistent evidence) is a scope card — machine-suggested paths do not launch it.
+    notGroundedWithoutPersistentEvidence: isNotGroundedWithoutPersistentEvidence,
     // ⭐ 충돌 문면이 경로마다 「대상/근거」를 말하게 한다 — 판정은 «안» 바꾼다(문면만 는다).
     //   ⛔ TRACED PATHS 는 「바꿀 파일」과 「근거로 읽은 파일」을 섞는다(실측: TRACED 8 · 변경 3).
     //     ⇒ 사람이 막혔을 때 「그게 근거였네」를 «즉시» 알 수 있어야 한다.

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

@@ -45,6 +45,7 @@ import { getUserConfig, type UserConfig } from '../user-config.js';
 import { resolveChildLlmPreference, type ChildLlmPreferenceInput, type ResolvedChildLlmPreference } from '../self-implement/child-llm-preference.js';
 import { applyLaunchOverloadFailover, codexProviderNamed } from '../oauth/overload-failover-launch.js';
 import { readCachedGrokQuota } from '../oauth/codex-account-store.js';
+import { appendRunLedgerEntry } from '../self-implement/run-ledger.js';
 import { queryAbandonedDraftPrs, type AbandonedDraftPr } from '../cli/logs-abandoned-draft-prs.js';
 import { branchLineageSlug } from '../cli/pr-lineage.js';
 import { decideDraft, type DraftTriagePr } from './draft-triage-rules.js';
@@ -1494,6 +1495,20 @@ export function formatChildLlmInterpretationLine(
   return `[dev] child-llm: entered=${resolution.entered} · resolved=${resolution.resolvedId} · tier=${resolution.tier} · thinking=${resolution.supportsThinking}${tail}`;
 }
 
+/** Only the weekly Grok credits period measures the weekly cap; missing or malformed periods are unmeasured. */
+export function grokWeeklyUsedPctFromUsageJson(stdout: string): number | undefined {
+  try {
+    const parsed = JSON.parse(stdout) as { rows?: Array<{ provider?: string; credits?: { status?: string; periodType?: string | null; usedPercent?: unknown } }> };
+    if (!Array.isArray(parsed.rows)) return undefined;
+    const percents = parsed.rows
+      .filter((row) => row?.provider === 'grok' && row.credits?.status === 'ok'
+        && row.credits.periodType === 'USAGE_PERIOD_TYPE_WEEKLY')
+      .map((row) => row.credits?.usedPercent)
+      .filter((pct): pct is number => typeof pct === 'number' && Number.isFinite(pct) && pct >= 0 && pct <= 100);
+    return percents.length > 0 ? Math.max(...percents) : undefined;
+  } catch { return undefined; }
+}
+
 /** `elanous usage --json` 의 grok 행 → 잔량 판정. 한 행이라도 100% 미만이면 usable, 모두 100% 이상이면 exhausted. */
 export function grokQuotaFromUsageJson(stdout: string): 'usable' | 'exhausted' | 'unknown' {
   try {
@@ -1519,17 +1534,75 @@ export function setLaunchGrokQuotaReaderForTesting(reader: (() => 'usable' | 'ex
   launchGrokQuotaReaderForTesting = reader;
 }
 
+let launchGrokWeeklyReaderForTesting: (() => number | undefined) | undefined;
+export function setLaunchGrokWeeklyReaderForTesting(reader: (() => number | undefined) | undefined): void {
+  launchGrokWeeklyReaderForTesting = reader;
+}
+
+/**
+ * 발사 한 번에 `elanous usage --json`(약 3초) 을 «한 번만» 부른다 — 주간 사용률(재배분)과 잔량(경고)이 같은 출력을 나눈다.
+ * 한 CLI 프로세스 = 한 발사이므로 프로세스 안 60초 캐시로 충분하다(실패 null 도 캐시 — 같은 발사에서 20초 타임아웃을 두 번 물지 않게).
+ */
+let launchUsageJsonCache: { at: number; stdout: string | null } | undefined;
+const LAUNCH_USAGE_CACHE_MS = 60_000;
+export function runLaunchUsageJsonOnce(): string | null {
+  const now = Date.now();
+  if (launchUsageJsonCache && now - launchUsageJsonCache.at < LAUNCH_USAGE_CACHE_MS) return launchUsageJsonCache.stdout;
+  let stdout: string | null = null;
+  try {
+    const cli = new URL('../../bin/elanous.mjs', import.meta.url).pathname;
+    const r = spawnSync(process.execPath, [cli, ...(IN_TEST_PROCESS() || process.env.ELANOUS_TEST_MODE === '1' ? ['--test'] : []), 'usage', '--json'], { encoding: 'utf8', timeout: 20_000 });
+    stdout = r.status === 0 ? r.stdout : null;
+  } catch { stdout = null; }
+  launchUsageJsonCache = { at: now, stdout };
+  return stdout;
+}
+
+/** Launch's weekly percentage comes from the live usage period, not the coarse cached usable flag. */
+export function readGrokWeeklyUsedPctForLaunch(runUsage?: () => string | null): number | undefined {
+  if (launchGrokWeeklyReaderForTesting && !runUsage) return launchGrokWeeklyReaderForTesting();
+  try {
+    const stdout = (runUsage ?? runLaunchUsageJsonOnce)();
+    return stdout ? grokWeeklyUsedPctFromUsageJson(stdout) : undefined;
+  } catch { return undefined; }
+}
+
+export function rebalanceGrokChildForLaunch(
+  child: ChildLlmSelection,
+  cap: number,
+  used: number | undefined,
+  runId?: string,
+  deps: { write?: (line: string) => void; record?: typeof appendRunLedgerEntry } = {},
+): ChildLlmSelection {
+  if (child.provider !== 'grok') return child;
+  const measured = typeof used === 'number' && Number.isFinite(used) && used >= 0 && used <= 100;
+  const rebalanced = measured && used >= cap;
+  const selected = rebalanced
+    ? { ...child, provider: 'openai-codex', model: defaultChildLlmModel('openai-codex'), codexQuotaPolicy: 'credits' as const }
+    : child;
+  const reason = !measured ? '측정 불가' : rebalanced ? `grok 주간 사용률 ${used}% ≥ 상한 ${cap}%` : `grok 주간 사용률 ${used}% < 상한 ${cap}%`;
+  if (rebalanced || !measured) (deps.write ?? ((line) => process.stderr.write(line)))(
+    `[dev] child-llm ${child.provider} → ${selected.provider} · ${reason}\n`,
+  );
+  if (rebalanced || !measured) {
+    const data = { requestedProvider: child.provider, selectedProvider: selected.provider,
+      weeklyUsedPct: measured ? used : null, capPct: cap, reason, selection: child.source };
+    // 실제 전환과 «측정 못 해 그대로 둠» 을 다른 이벤트로 — 관측에서 둘을 섞지 않는다.
+    const event = rebalanced ? 'launch-provider-rebalanced' : 'launch-provider-weekly-unmeasured';
+    debug.log('self-implement', event, { runId: runId ?? null, ...data });
+    if (runId) (deps.record ?? appendRunLedgerEntry)({ timestamp: new Date().toISOString(), runId,
+      event, data: { runId, ...data } });
+  }
+  return selected;
+}
+
 export function readGrokQuotaForLaunch(
   deps: { readCached?: typeof readCachedGrokQuota; runUsage?: () => string | null } = {},
 ): 'usable' | 'exhausted' | 'unknown' {
   if (launchGrokQuotaReaderForTesting && !deps.readCached && !deps.runUsage) return launchGrokQuotaReaderForTesting();
   const cached = (deps.readCached ?? readCachedGrokQuota)();
   if (cached !== 'unknown') return cached;
-  const runUsage = deps.runUsage ?? (() => {
-    const cli = new URL('../../bin/elanous.mjs', import.meta.url).pathname;
-    const r = spawnSync(process.execPath, [cli, 'usage', '--json'], { encoding: 'utf8', timeout: 20_000 });
-    return r.status === 0 ? r.stdout : null;
-  });
+  const runUsage = deps.runUsage ?? runLaunchUsageJsonOnce;
   let stdout: string | null = null;
   try { stdout = runUsage(); } catch { stdout = null; }
   return stdout ? grokQuotaFromUsageJson(stdout) : 'unknown';
@@ -1851,6 +1924,7 @@ export function buildDriveAliasDevSpec(
   command: string | undefined,
   opts: DevCliOpts,
   explicitOptionNames?: readonly string[],
+  runId?: string,
 ): DevPipelineSpec {
   if (opts.elanous === true) {
     throw new DevPipelineError('drive: --elanous 는 지원하지 않음 — TUI target은 elanous dev --elanous 를 사용');
@@ -1861,7 +1935,7 @@ export function buildDriveAliasDevSpec(
   if (!opts.goal?.trim()) {
     throw new DevPipelineError('drive: --goal 필요');
   }
-  const spec = buildDevCliSpec({ text: command.trim() }, { kind: 'self' }, opts, explicitOptionNames, 'cli-drive');
+  const spec = buildDevCliSpec({ text: command.trim() }, { kind: 'self' }, opts, explicitOptionNames, 'cli-drive', undefined, undefined, runId);
   return { ...spec, completion: 'worktree-only', autoReview: false };
 }
 
@@ -1872,6 +1946,9 @@ export function buildDevCliSpec(
   explicitOptionNames?: readonly string[],
   entrance: EntranceId = 'cli-dev-ask',
   readGrokQuota: typeof readCachedGrokQuota = readGrokQuotaForLaunch,
+  readGrokWeekly: () => number | undefined = readGrokWeeklyUsedPctForLaunch,
+  runId?: string,
+  recordLaunch?: typeof appendRunLedgerEntry,
 ): DevPipelineSpec {
   if (opts.plan === true) {
     throw new DevPipelineError(`--plan 은 은퇴했고 명시적으로 거부됨 · 대응 문: ${DEV_PLAN_REPLACEMENT}`);
@@ -2016,8 +2093,13 @@ export function buildDevCliSpec(
   }
 
   if (path === 'self-mission') {
-    const builtChild = buildChildLlmSelection({ ...opts, readPreference: () => getUserConfig() });
-    const childLlm = applyLaunchOverloadFailover(builtChild, {
+    const requestedChildLlm = buildChildLlmSelection({ ...opts, readPreference: () => getUserConfig() });
+    // 주간 상한 재배분(grok → codex)을 먼저, 과부하 페일오버(codex → grok)를 그 뒤에 — 과부하는 «지금 실패 중»이라 더 강한 신호다.
+    const capped = requestedChildLlm?.provider === 'grok'
+      ? rebalanceGrokChildForLaunch(requestedChildLlm, getUserConfig().llm.grokWeeklyCapPct ?? 80, readGrokWeekly(), runId,
+        recordLaunch ? { record: recordLaunch } : {})
+      : requestedChildLlm;
+    const childLlm = applyLaunchOverloadFailover(capped, {
       provider: opts.childLlmProvider,
       model: opts.childLlmModel,
       codexPinned: childLlmCodexPinned(opts.childLlmProvider),

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

@@ -43,7 +43,8 @@ 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, defaultReviewFallbackModel, runReviewWithFallback, reviewFallbackModelsFromConfig } from './review-provider-fallback.js';
+import { buildReviewProviderAttempts, defaultReviewFallbackModel, runReviewWithFallback, reviewFallbackModelsFromConfig, runSubscriptionReviewer, type SubscriptionReviewerDeps } from './review-provider-fallback.js';
+import { loadLlmPolicy } from '../policy/llm-policy.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';
@@ -1077,6 +1078,8 @@ export async function buildDefaultSelfImplementSeams(
     toolReviewerRoll?: () => number;
     /** Tool-reviewer factory (same prompt→text shape as llmReview). Tests stub this; default is ACP. */
     makeToolReviewLLM?: () => UnmannedToolReviewLLM | Promise<UnmannedToolReviewLLM>;
+    subscriptionReviewerDeps?: SubscriptionReviewerDeps;
+    makeSubscriptionReviewLLM?: (spawn: ReturnType<typeof import('./review-provider-fallback.js').subscriptionReviewerSpawn>) => (prompt: string) => Promise<string>;
   } = {},
 ): Promise<SelfImplementSeams> {
   const { defaultSeams } = await import('../self-implement/seams.js');
@@ -1143,6 +1146,21 @@ export async function buildDefaultSelfImplementSeams(
       reviewerCanSelfRead = false;
     }
   }
+  let subscriptionReviewLLM: ((prompt: string) => Promise<string>) | undefined;
+  if (reviewerIsDefaultApiCall) {
+    const userConfig = getUserConfig();
+    const policy = loadLlmPolicy();
+    const spec = policy.policy.roles.reviewer ?? userConfig.roleLlm?.reviewer;
+    if (spec) {
+      const cap = policy.policy.caps.claude.harness;
+      subscriptionReviewLLM = (prompt) => runSubscriptionReviewer(spec, cap, prompt, defaultApiReview, async (text, spawn) => {
+        if (deps.makeSubscriptionReviewLLM) return deps.makeSubscriptionReviewLLM(spawn)(text);
+        const { makeAcpReviewLLM } = await import('../agent-substrate/acp-reviewer.js');
+        return makeAcpReviewLLM({ cwd: targetOptions?.repoRoot ?? childScope.elanousBinRoot, backend: 'claude', backendSpec: spawn.backendSpec, env: spawn.env })(text);
+      }, process.env, deps.subscriptionReviewerDeps);
+      reviewerCanSelfRead = undefined;
+    }
+  }
   const opensPr = plan.completion !== 'worktree-only';
   const target = plan.target === undefined ? undefined : revalidateHarnessTarget(plan.target);
   if (target?.status === 'outside-home') {
@@ -1159,6 +1177,7 @@ export async function buildDefaultSelfImplementSeams(
     ...(plan.self?.maxWaitSec !== undefined ? { implementMaxWaitSec: plan.self.maxWaitSec } : {}),
     ...(plan.self?.activityGraceSec !== undefined ? { implementActivityGraceSec: plan.self.activityGraceSec } : {}),
     llmReview,
+    ...(subscriptionReviewLLM ? { subscriptionReviewLLM } : {}),
     ...(reviewerCanSelfRead !== undefined ? { reviewerCanSelfRead } : {}),
     ...(deps.reviewScopeDiff ? { reviewScopeDiff: deps.reviewScopeDiff } : {}),
     onProgress: ({ stage, message }) => {