elanous 0.2.21 → 0.2.22

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/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 }) => {

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

@@ -62,6 +62,9 @@ export interface DraftSweepOptions {
   adapters: DraftSweepAdapters;
   apply?: boolean;
   now?: Date;
+  /** Per-tick close cap; resolve it with resolveDraftSweepCloseCap. Absent or invalid ⇒ DRAFT_SWEEP_CLOSE_CAP. */
+  closeCap?: number;
+  closeCapSource?: DraftSweepCloseCapSource;
 }
 
 export interface DraftSweepEntry {
@@ -83,8 +86,11 @@ export interface DraftSweepResult {
   counts: Record<string, number>;
   /** Drafts whose run could not be observed from here (kept, or closed by the idle rule). */
   unobserved?: number;
-  /** Closes decided this tick (at most DRAFT_SWEEP_CLOSE_CAP). */
+  /** Closes decided this tick (at most `closeCap`). */
   closed?: number;
+  /** The per-tick close cap this sweep used, and where it came from. */
+  closeCap?: number;
+  closeCapSource?: DraftSweepCloseCapSource;
   /** Fresh running claims protected this tick. */
   claimed?: number;
   /** Running claims older than the idle window, including those kept by liveness. */
@@ -420,8 +426,36 @@ const approvalLabel = PR_LABELS.find((entry) => entry.axis === 'state' && entry.
 const keepLabel = PR_LABELS.find((entry) => entry.sweep.action === 'exclude')?.name;
 const releaseHoldLabel = PR_LABELS.find((entry) => entry.axis === 'addon' && entry.sweep.action === 'none')?.name;
 const PAGE_SIZE = 100;
-/** At most this many closes per tick, so a wrong rule cannot close everything at once. */
+/** At most this many closes per tick, so a wrong rule cannot close everything at once. Default for `tools.selfImplement.draftSweepCloseCap`. */
 export const DRAFT_SWEEP_CLOSE_CAP = 10;
+export const DRAFT_SWEEP_CLOSE_CAP_MIN = 1;
+export const DRAFT_SWEEP_CLOSE_CAP_MAX = 100;
+export type DraftSweepCloseCapSource = 'flag' | 'config' | 'default';
+
+export interface DraftSweepCloseCapResolution {
+  readonly closeCap: number;
+  readonly closeCapSource: DraftSweepCloseCapSource;
+  /** One line per rejected input (flag or config); each rejection falls through to the next source. */
+  readonly warnings: readonly string[];
+}
+
+function validCloseCap(value: unknown): number | undefined {
+  const parsed = typeof value === 'string' && /^\s*\d+\s*$/.test(value) ? Number(value) : value;
+  return typeof parsed === 'number' && Number.isSafeInteger(parsed)
+    && parsed >= DRAFT_SWEEP_CLOSE_CAP_MIN && parsed <= DRAFT_SWEEP_CLOSE_CAP_MAX ? parsed : undefined;
+}
+
+/** Flag over config over default; a value outside 1–100 (or not an integer) is rejected with a warning. */
+export function resolveDraftSweepCloseCap(input: { flag?: unknown; config?: unknown }): DraftSweepCloseCapResolution {
+  const warnings: string[] = [];
+  for (const [source, value, name] of [['flag', input.flag, '--close-cap'], ['config', input.config, 'tools.selfImplement.draftSweepCloseCap']] as const) {
+    if (value === undefined || value === null) continue;
+    const cap = validCloseCap(value);
+    if (cap !== undefined) return { closeCap: cap, closeCapSource: source, warnings };
+    warnings.push(`${name}=${JSON.stringify(value)} 무시 — ${DRAFT_SWEEP_CLOSE_CAP_MIN}~${DRAFT_SWEEP_CLOSE_CAP_MAX} 정수만 (기본 ${DRAFT_SWEEP_CLOSE_CAP})`);
+  }
+  return { closeCap: DRAFT_SWEEP_CLOSE_CAP, closeCapSource: 'default', warnings };
+}
 
 /** Post-merge shortcut: only the existing superseded-by decision can authorize a close. */
 export async function supersedeDraftsOnMerge(input: {
@@ -571,8 +605,11 @@ export function draftSweepDaily(
 }
 
 /** A failed inventory or liveness lookup is never treated as proof that a draft can be closed. */
-export async function runDraftSweep({ repository, adapters, apply = false, now = new Date() }: DraftSweepOptions): Promise<DraftSweepResult> {
-  const result: DraftSweepResult = { repository, apply, complete: false, entries: [], counts: {} };
+export async function runDraftSweep({ repository, adapters, apply = false, now = new Date(), closeCap: requestedCap, closeCapSource: requestedSource }: DraftSweepOptions): Promise<DraftSweepResult> {
+  const validCap = validCloseCap(requestedCap);
+  const closeCap = validCap ?? DRAFT_SWEEP_CLOSE_CAP;
+  const closeCapSource: DraftSweepCloseCapSource = validCap === undefined ? 'default' : requestedSource ?? 'flag';
+  const result: DraftSweepResult = { repository, apply, complete: false, entries: [], counts: {}, closeCap, closeCapSource };
   const record = (entry: DraftSweepEntry): void => {
     result.entries.push(entry);
     result.counts[entry.reason] = (result.counts[entry.reason] ?? 0) + 1;
@@ -591,7 +628,7 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
     const at = Date.now();
     try {
       debug.log('self-dev.draft-sweep', 'timing', { phase, ms: at - phaseStarted, count, ...(outcome ? { outcome } : {}) });
-      if (outcome) debug.log('self-dev.draft-sweep', 'timing', { phase: 'total', ms: at - started, count, outcome });
+      if (outcome) debug.log('self-dev.draft-sweep', 'timing', { phase: 'total', ms: at - started, count, outcome, closeCap, closeCapSource });
     } catch { /* fail-soft */ }
     phaseStarted = at;
   };
@@ -706,7 +743,7 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
         record({ number: draft.number, action: 'keep', reason: 'claim-expired-but-live', applied: false });
         continue;
       }
-      const action = closes >= DRAFT_SWEEP_CLOSE_CAP ? 'keep' : 'close';
+      const action = closes >= closeCap ? 'keep' : 'close';
       if (action === 'close') closes += 1;
       const entry: DraftSweepEntry = { number: draft.number, action,
         reason: action === 'close' ? runStatus === 'self-implement.result final'
@@ -737,7 +774,7 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
       finalRunResult, ageHours: runStatus ? ageHours : idleHours });
     if (!runStatus && (decision.reason === 'unobserved' || decision.reason === 'stale-unobserved')) unobserved += 1;
     if (!contradiction && decision.action === 'close') {
-      if (closes >= DRAFT_SWEEP_CLOSE_CAP) decision = { action: 'keep', reason: 'close-cap' };
+      if (closes >= closeCap) decision = { action: 'keep', reason: 'close-cap' };
       else closes += 1;
     }
     const action = contradiction ? 'report' : decision.action;
@@ -772,7 +809,7 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
     }
   }
   timing('decide', drafts.length);
-  try { debug.log('self-dev.draft-sweep', 'timing', { phase: 'total', ms: Date.now() - started, count: drafts.length }); } catch { /* fail-soft */ }
+  try { debug.log('self-dev.draft-sweep', 'timing', { phase: 'total', ms: Date.now() - started, count: drafts.length, closed: closes, closeCap, closeCapSource }); } catch { /* fail-soft */ }
   result.unobserved = unobserved;
   result.closed = closes;
   result.claimed = claimed;

package/src/self-dev/orchestrate.ts

@@ -298,6 +298,8 @@ export interface SelfDevJobResult {
   providerErrors?: { count: number; provider: string; category: 'quota' | 'credential' | 'request' | 'other' };
   /** Stable child run identity used to join its run-ledger proposal. */
   runId?: string;
+  /** Self review verdict bound to the PR head observed by the child; absent if either observation is missing. */
+  selfReview?: { verdict: 'pass' | 'fail'; head: string };
   /** Whether the child review actually ran; omitted preserves legacy producers. */
   reviewed?: boolean;
   /** Why the child did not run review; omitted preserves legacy review-unobserved handling. */
@@ -1499,6 +1501,7 @@ export function orchestrateSelfDev(opts: OrchestrateSelfDevOptions): Promise<Sel
           ...(disp?.prNumber !== undefined ? { prNumber: disp.prNumber } : {}),
           ...(disp?.merged !== undefined ? { merged: disp.merged } : {}),
           ...(disp?.checkedHeadCommit ? { checkedHeadCommit: disp.checkedHeadCommit } : {}),
+          ...(disp?.selfReview ? { selfReview: disp.selfReview } : {}),
           // ⭐ `A1` — 판정 3종을 «끝까지» 옮긴다. 여기서 빠지면 트리아지가 눈을 잃는다.
           ...(disp?.mergeReason ? { mergeReason: disp.mergeReason } : {}),
           ...(!cancelling && disp?.stopReason ? { stopReason: disp.stopReason } : {}),

package/src/self-dev/review-provider-fallback.ts

@@ -19,6 +19,89 @@
 //     쿼터 축은 과부하에 «반응하지 않는다».
 import { resolveModelAlias } from '../intelligence-map/model-alias.js';
 import type { LLMProvider } from '../llm.js';
+import { spawnSync } from 'node:child_process';
+import { claudeBackend, resolveBackendSpawn } from '../agent-mission/driver.js';
+import { checkClaudeSubscription } from '../agent-mission/claude-subscription.js';
+import { getAcpBackend, type AcpBackendSpec } from '../acp/backend-registry.js';
+import type { SubscriptionReviewerSpec } from '../user-config.js';
+
+export interface SubscriptionReviewerDeps {
+  /** Returns measured Claude subscription usage; unknown usage fails closed. */
+  usedPercent?: () => number | undefined;
+  checkSubscription?: (env: Record<string, string>) => boolean;
+  runStatus?: (command: string, args: string[], env: Record<string, string>) => { status: number | null; stdout?: string | Buffer | null };
+}
+
+/** The runner and the subscription probe share the PTY backend's billing-env scrub. */
+export function subscriptionReviewerSpawn(spec: SubscriptionReviewerSpec, env: NodeJS.ProcessEnv = process.env): {
+  command: string; args: string[]; env: Record<string, string>; backendSpec: AcpBackendSpec;
+} {
+  const executor = spec.executor ?? 'cct';
+  const { env: cleanEnv } = resolveBackendSpawn(claudeBackend, env);
+  const command = executor === 'cct' ? 'teamclaude' : 'claude';
+  const args = executor === 'cct'
+    ? ['run', '--auto-fallback', '--', '--dangerously-skip-permissions']
+    : ['--dangerously-skip-permissions'];
+  return { command, args, env: cleanEnv,
+    backendSpec: { ...getAcpBackend('claude'), command, args } };
+}
+
+/** Guard the ACP review before spawning. An unmeasured quota never authorizes subscription use. */
+export function subscriptionReviewerAvailability(
+  spec: SubscriptionReviewerSpec,
+  cap: number,
+  env: NodeJS.ProcessEnv = process.env,
+  deps: SubscriptionReviewerDeps = {},
+): { spawn?: ReturnType<typeof subscriptionReviewerSpawn>; reason?: string } {
+  const spawn = subscriptionReviewerSpawn(spec, env);
+  const executor = spec.executor ?? 'cct';
+  const runStatus = deps.runStatus ?? ((command: string, args: string[], cleanEnv: Record<string, string>) =>
+    spawnSync(command, args, { env: { ...cleanEnv, NODE_ENV: process.env.NODE_ENV }, encoding: 'utf8', timeout: 5_000 }));
+  const usedPercent = deps.usedPercent ?? (() => {
+    const result = runStatus('teamclaude', ['status'], spawn.env);
+    if (result.status !== 0) return undefined;
+    // Only a named usage percentage is accepted; a random percentage in status is not quota evidence.
+    const match = String(result.stdout).match(/(?:usage|used)\s*[:=]?\s*(\d+(?:\.\d+)?)\s*%/i);
+    return match ? Number(match[1]) : undefined;
+  });
+  try {
+    const subscribed = deps.checkSubscription ?? ((cleanEnv: Record<string, string>) => {
+      if (executor === 'cc') return checkClaudeSubscription({ env: cleanEnv }).ok;
+      const status = runStatus('teamclaude', ['status'], cleanEnv);
+      return status.status === 0 && /(?:subscription|claude\.ai|claude\s+(?:max|pro))/i.test(String(status.stdout))
+        && !/(?:logged\s*out|not\s+logged\s+in|api[_ -]?key|not\s+authenticated)/i.test(String(status.stdout));
+    });
+    if (!subscribed(spawn.env)) return { reason: `${executor} subscription check failed` };
+    const used = usedPercent();
+    if (!Number.isFinite(cap) || cap < 0 || cap > 100 || used === undefined
+      || !Number.isFinite(used) || used < 0 || used >= cap) return { reason: `Claude subscription usage unavailable or at harness cap (${cap}%)` };
+    return { spawn };
+  } catch {
+    return { reason: `${executor} subscription check failed` };
+  }
+}
+
+/** Keep a single notice attached to the actual default review result. */
+export async function runSubscriptionReviewer(
+  spec: SubscriptionReviewerSpec | undefined,
+  cap: number,
+  prompt: string,
+  defaultReview: (prompt: string) => Promise<string>,
+  acpReview: (prompt: string, spawn: ReturnType<typeof subscriptionReviewerSpawn>) => Promise<string>,
+  env: NodeJS.ProcessEnv = process.env,
+  deps: SubscriptionReviewerDeps = {},
+): Promise<string> {
+  if (!spec) return defaultReview(prompt);
+  const availability = subscriptionReviewerAvailability(spec, cap, env, deps);
+  if (availability.spawn) {
+    try {
+      const text = await acpReview(prompt, availability.spawn);
+      if (text.trim()) return text;
+    } catch { /* ACP failure is not a completed review. */ }
+  }
+  const reason = availability.reason ?? 'ACP review failed';
+  return `${await defaultReview(prompt)}\n[reviewer fallback: ${reason}; default reviewer used]`;
+}
 
 export type ReviewFailureReason =
   | 'overloaded'

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

@@ -623,7 +623,11 @@ export async function superviseRun(opts: SuperviseRunOptions): Promise<Superviso
       if (decision.stopReason && opts.taskAgentShadow !== false) {
         // TASK-AGENT-SHADOW — 판단부를 그림자로 부른다(실행 0). 어떤 오류도 런의 결말을 바꾸지 않는다.
         try {
-          await (opts.taskAgentShadow ?? recordTaskAgentShadowMove)({ runId, stopReason: decision.stopReason, results });
+          const pr = results.find((result) => typeof result.prNumber === 'number' && result.prNumber > 0)?.prNumber;
+          const reviewed = results.filter((result) => result.prNumber === pr && result.selfReview && result.merged !== true);
+          const selfReview = pr && reviewed.length === 1 ? reviewed[0]!.selfReview : undefined;
+          await (opts.taskAgentShadow ?? recordTaskAgentShadowMove)({ runId, stopReason: decision.stopReason, results,
+            ...(selfReview ? { selfReview } : {}), cycleId: `${runId ?? 'unknown'}:${decision.round}` });
         } catch (error) {
           try { debug.log('task-agent', 'shadow-move-failed', { runId, stopReason: decision.stopReason, error: String(error) }); } catch { /* fail-open */ }
         }

package/src/self-implement/harness-policy-gates.ts

@@ -5,16 +5,17 @@ import { runMockModuleRestoreGate } from '../../scripts/ci-mock-module-restore-g
 import { runModelHardcodeGate } from '../../scripts/ci-model-hardcode-gate.js';
 import { runDaemonPortGate } from '../../scripts/ci-daemon-port-gate.js';
 import { runPublicExportLeakGate } from '../../scripts/ci-public-export-leak-gate.js';
+import { runPublicExportImportGate } from '../../scripts/ci-public-export-import-gate.js';
 
-type GateName = 'isolation-gate' | 'mock-module-restore-gate' | 'model-hardcode-gate' | 'daemon-port-gate' | 'public-export-leak';
+type GateName = 'isolation-gate' | 'mock-module-restore-gate' | 'model-hardcode-gate' | 'daemon-port-gate' | 'public-export-leak' | 'public-export-import';
 type GateOutput = { args: string[]; cwd: string; log: (line: string) => void; error: (line: string) => void };
-type GateRunner = (out: GateOutput) => number;
+type GateRunner = (out: GateOutput) => number | Promise<number>;
 
-export function runHarnessPolicyGates(input: {
+export async function runHarnessPolicyGates(input: {
   cwd: string;
   changedFiles: readonly string[];
   gates?: Partial<Record<GateName, GateRunner>>;
-}): { passed: boolean; failures: Array<{ gate: GateName; lines: string[] }>; skipped?: string } {
+}): Promise<{ passed: boolean; failures: Array<{ gate: GateName; lines: string[] }>; skipped?: string }> {
   try {
     if (!statSync(join(input.cwd, 'scripts')).isDirectory()) {
       return { passed: true, failures: [], skipped: 'no-scripts' };
@@ -30,12 +31,13 @@ export function runHarnessPolicyGates(input: {
     ['daemon-port-gate', input.gates?.['daemon-port-gate'] ?? ((out) => runDaemonPortGate({ log: out.log, error: out.error, cwd: out.cwd, args: [] }))],
     // LEAK1 — the same pre-export check as pr land; an unmeasured result is a nonzero failure, not a pass.
     ['public-export-leak', input.gates?.['public-export-leak'] ?? runPublicExportLeakGate],
+    ['public-export-import', input.gates?.['public-export-import'] ?? runPublicExportImportGate],
   ];
   const failures: Array<{ gate: GateName; lines: string[] }> = [];
   for (const [gate, run] of runners) {
     const lines: string[] = [];
     try {
-      const status = run({ cwd: input.cwd, args: ['--changed-files', ...input.changedFiles], log: (line) => lines.push(line), error: (line) => lines.push(line) });
+      const status = await run({ cwd: input.cwd, args: ['--changed-files', ...input.changedFiles], log: (line) => lines.push(line), error: (line) => lines.push(line) });
       if (status !== 0) failures.push({ gate, lines: [...lines, `✗ ${gate}: violation detected`] });
     } catch (error) {
       failures.push({ gate, lines: [...lines, `⚠ ${gate}: 게이트가 «못 쟀다» — ${error instanceof Error ? error.message : String(error)}`] });

package/src/self-implement/host-regate.ts

@@ -8,7 +8,7 @@ import { publicExposureFiles, runExposeGate } from './expose-gate.js';
 import { admitLandingMerge } from './frozen-merges.js';
 import { releaseGitDiffPaths, releasePathHold, releasePathHoldShouldPost, releasePathHoldComment, releasePathHoldCommentsArgs, RELEASE_PATH_LABEL } from '../self-dev/release-path-guard.js';
 import { detectTestInterference, parseFailureCount, runBunTest } from '../../scripts/detect-test-interference.js';
-import { runTestInterferenceGate } from '../../scripts/ci-test-interference-gate.js';
+import { MAX_INSPECTED_TEST_FILES, runTestInterferenceGate } from '../../scripts/ci-test-interference-gate.js';
 
 /**
  * The PWA's static build type-checks every `src/**` file it imports, under Next's stricter
@@ -22,9 +22,10 @@ export function needsPwaBuild(files: readonly string[]): boolean {
 
 export interface HostRegateInput { prNumber: number; headCommit: string; repoRoot: string; goalFile?: string; verifyOnly?: boolean; /** Called by a resume sweep that already holds this PR's claim. */ resumed?: true }
 export interface HostRegateResult { passed: boolean; failures: Array<{ step: string; detail: string }>; os: string; status?: 'passed' | 'failed' | 'unmeasured' | 'frozen'; /** verifyOnly: 실제로 얹어 잰 base 끝 */ baseCommit?: string }
+export type InterferenceVerdict = { passed: boolean; detail?: string; unmeasured?: boolean; /** neighbour tests left out so the selection fits the inspection cap */ neighborsTrimmed?: number };
 export type HostRegateDeps = {
   command?: (bin: string, args: readonly string[], cwd: string, env?: NodeJS.ProcessEnv) => { status: number | null; stdout: string; stderr: string };
-  interference?: (files: readonly string[], cwd: string) => Promise<{ passed: boolean; detail?: string; unmeasured?: boolean }>;
+  interference?: (files: readonly string[], cwd: string) => Promise<InterferenceVerdict>;
   makeTemp?: () => string;
   removeTemp?: (path: string) => void;
   acquire?: (repoRoot: string) => Promise<() => void>;
@@ -46,17 +47,28 @@ const defaultCommand: NonNullable<HostRegateDeps['command']> = (bin, args, cwd,
 };
 
 /** The informational pr-land gate always returns zero; enforce its measured report and the combined test result instead. */
-async function defaultInterference(files: readonly string[], cwd: string, opts: { neighbors?: boolean } = {}): Promise<{ passed: boolean; detail?: string; unmeasured?: boolean }> {
-  const tests = files.filter((file) => /\.test\.tsx?$/.test(file));
-  const neighbors = new Set<string>(tests);
-  // verifyOnly(승인 탭)는 «이 PR 이 바꾼 시험»만 잰다 — 이웃 시험을 넣으면 간섭 관문의 상한(8)에 잘려 영영 «측정 불가»가 되고,
-  //   이웃의 기존 실패가 이 PR 을 막는다(2026-09-28 #21239 실측: scripts/lib 이웃 9 → 상한 8 · nl-routing-measurement 기존 1 fail).
+export async function defaultInterference(files: readonly string[], cwd: string, opts: { neighbors?: boolean; detect?: typeof detectTestInterference } = {}): Promise<InterferenceVerdict> {
+  const tests = [...new Set(files.filter((file) => /\.test\.tsx?$/.test(file)))].sort();
+  const changed = new Set(tests);
+  const neighbors = new Set<string>();
+  // verifyOnly(승인 탭)는 «이 PR 이 바꾼 시험»만 잰다 — 이웃의 기존 실패가 이 PR 을 막지 않게
+  //   (2026-09-28 #21239 실측: scripts/lib 이웃 9 · nl-routing-measurement 기존 1 fail).
   if (opts.neighbors !== false) for (const file of tests) {
     for (const sibling of readdirSync(join(cwd, dirname(file)))) {
-      if (/\.test\.tsx?$/.test(sibling)) neighbors.add(join(dirname(file), sibling));
+      const path = join(dirname(file), sibling);
+      if (/\.test\.tsx?$/.test(sibling) && !changed.has(path)) neighbors.add(path);
     }
   }
-  const selected = [...neighbors].sort();
+  // 이웃이 간섭 관문의 상한(MAX_INSPECTED_TEST_FILES)을 넘기면 그 관문이 잘라 «영영 측정 불가»가 된다
+  //   (2026-10-08 #25180·#25187 실측: src/self-implement 시험 175 · src/seat-loop 11). 바뀐 시험은 전부 두고 남는 칸만 이웃으로 채운다.
+  //   바뀐 시험만으로 상한을 넘으면 정직하게 «측정 불가»로 남는다.
+  const sortedNeighbors = [...neighbors].sort();
+  const room = Math.max(0, MAX_INSPECTED_TEST_FILES - tests.length);
+  const kept = tests.length > MAX_INSPECTED_TEST_FILES ? sortedNeighbors : sortedNeighbors.slice(0, room);
+  const neighborsTrimmed = sortedNeighbors.length - kept.length;
+  const trimmed = neighborsTrimmed > 0 ? { neighborsTrimmed } : {};
+  const trimNote = neighborsTrimmed > 0 ? ` · neighbours trimmed ${neighborsTrimmed} to fit inspection cap ${MAX_INSPECTED_TEST_FILES}` : '';
+  const selected = [...tests, ...kept].sort();
   if (!selected.length) return { passed: true };
   // 간섭 관문은 시험 파일이 둘 이상일 때만 잰다 — 하나면 간섭이라는 말이 없으니 그 파일을 한 번 돌려 실패 수로 본다.
   if (selected.length === 1) {
@@ -69,13 +81,13 @@ async function defaultInterference(files: readonly string[], cwd: string, opts:
   let report: Awaited<ReturnType<typeof detectTestInterference>> | undefined;
   await runTestInterferenceGate({
     args: ['--changed-files', ...selected], log: () => {},
-    detect: async (paths) => (report = await detectTestInterference(paths, (batch) => runBunTest(batch, undefined, cwd))),
+    detect: async (paths) => (report = await (opts.detect ?? detectTestInterference)(paths, (batch) => runBunTest(batch, undefined, cwd))),
   });
-  if (!report || report.status === 'unmeasurable' || selected.length > report.order.length) return { passed: false, unmeasured: true, detail: 'test interference measurement unavailable or truncated' };
+  if (!report || report.status === 'unmeasurable' || selected.length > report.order.length) return { passed: false, unmeasured: true, ...trimmed, detail: `test interference measurement unavailable or truncated (selected ${selected.length}, changed tests ${tests.length}, cap ${MAX_INSPECTED_TEST_FILES})${trimNote}` };
   if (report.isolatedFailures !== 0 || report.combinedFailures !== 0 || report.status === 'interference') {
-    return { passed: false, detail: `isolated=${report.isolatedFailures}, combined=${report.combinedFailures}, interference=${report.status}` };
+    return { passed: false, ...trimmed, detail: `isolated=${report.isolatedFailures}, combined=${report.combinedFailures}, interference=${report.status}${trimNote}` };
   }
-  return { passed: true };
+  return { passed: true, ...trimmed, ...(trimNote ? { detail: trimNote.slice(3) } : {}) };
 }
 
 const SLOT_WAIT_MS = 30 * 60_000;
@@ -133,9 +145,10 @@ export async function runHostRegate(input: HostRegateInput, deps: HostRegateDeps
   let endLanding: ((merged?: boolean) => void) | undefined;
   let landed = false;
   let verifiedBase: string | undefined;
+  let interferenceNote: Record<string, unknown> = {};
   const result = (event: 'passed' | 'failed' | 'unmeasured', step?: string, detail?: string): HostRegateResult => {
     if (step) failures.push({ step, detail: detail ?? 'unknown' });
-    log(event, { pr: input.prNumber, files, os: process.platform, ...(step ? { failedStep: step } : {}) });
+    log(event, { pr: input.prNumber, files, os: process.platform, ...interferenceNote, ...(step ? { failedStep: step, detail: (detail ?? 'unknown').slice(0, 300) } : {}) });
     return { passed: event === 'passed', failures, os: process.platform, ...(input.verifyOnly ? { status: event, ...(verifiedBase ? { baseCommit: verifiedBase } : {}) } : {}) };
   };
   const run = (bin: string, args: readonly string[], cwd: string, env?: NodeJS.ProcessEnv): string => {
@@ -211,6 +224,7 @@ export async function runHostRegate(input: HostRegateInput, deps: HostRegateDeps
     } catch (e) { return result('unmeasured', 'worktree', String(e)); }
     try {
       const interference = await (deps.interference ?? ((f: readonly string[], c: string) => defaultInterference(f, c, { neighbors: !input.verifyOnly })))(files, worktree);
+      if (interference.neighborsTrimmed) interferenceNote = { neighborsTrimmed: interference.neighborsTrimmed, interferenceDetail: (interference.detail ?? '').slice(0, 300) };
       if (!interference.passed) return result(interference.unmeasured ? 'unmeasured' : 'failed', 'test-interference', interference.detail);
     } catch (e) { return result('unmeasured', 'test-interference', String(e)); }
     // Landing can also be initiated by the host after the child gate; judge the checked PR here too.