elanous 0.2.36 → 0.2.37

package/src/graph-runner/graph-cli.ts

@@ -28,6 +28,28 @@ function findGraphFile(graphId: string): string | undefined {
 
 export function registerGraphCommands(program: Command, runsDeps: { root?: string; processStartMs?: (pid: number) => number | null } = {}): void {
   const graph = program.command('graph').description('Run a declared command graph or inspect its latest run');
+  graph.command('adapt-report')
+    .description('Measure recorded graph path diversity, unit calls, adaptations and landings for one goal')
+    .requiredOption('--goal <id>', 'Goal ID to measure')
+    .option('--json', 'Print measurement as JSON')
+    .action(async (opts: { goal: string; json?: boolean }) => {
+      try {
+        const { queryGraphAdaptReport } = await import('../self-implement/run-ledger.js');
+        const report = queryGraphAdaptReport(opts.goal);
+        if (opts.json) await writeStdoutJson(JSON.stringify(report) + '\n');
+        else if (report.runCount === 0) console.log(`graph adapt-report: ${opts.goal} · 표본 0 · 제외 ${report.excludedCount} ${JSON.stringify(report.exclusionReasons)}`);
+        else {
+          const landing = (group: typeof report.adapted) => group.denominator
+            ? `${group.landed}/${group.denominator} (${(group.rate! * 100).toFixed(1)}%)` : '표본 0';
+          console.log(`graph adapt-report: ${opts.goal} · 경로 ${report.uniquePathSignatures} · 유닛 호출 ${report.unitCallCount} · 적응 ${report.adaptationCount}`);
+          console.log(`적응 착지율 ${landing(report.adapted)} · 비적응 착지율 ${landing(report.nonAdapted)}`);
+          console.log(`제외 ${report.excludedCount} ${JSON.stringify(report.exclusionReasons)}`);
+        }
+      } catch (error) {
+        console.error(`graph adapt-report: ${error instanceof Error ? error.message : String(error)}`);
+        process.exitCode = 1;
+      }
+    });
   graph.command('wizard-run <request>')
     .description('Run one request through the smart wizard graph and stop at its approval gate')
     .option('--json', 'Print run identity and transitions as JSON')
@@ -405,12 +427,14 @@ export function registerGraphCommands(program: Command, runsDeps: { root?: strin
         const state = matches[0]!;
         const detail = { ...row(state), nodes: state.nodes.map((node) => {
           const summary = lastJsonObject(node.output)?.summary;
-          return { nodeId: node.nodeId, ok: node.ok, summary: typeof summary === 'string' ? summary.slice(0, 300) : null };
+          return { nodeId: node.nodeId, ok: node.ok, exit: node.exit,
+            ...(node.reason === undefined ? {} : { reason: node.reason }),
+            summary: typeof summary === 'string' ? summary.slice(0, 300) : null };
         }), pending: state.pending ?? null, resume: state.resume ?? null };
         if (opts.json) await writeStdoutJson(JSON.stringify(detail) + '\n');
         else {
           console.log(`${detail.runId} · ${detail.graphId} · ${detail.status} · alive=${detail.alive}`);
-          for (const node of detail.nodes) console.log(`  ${node.nodeId} · ok=${node.ok} · ${node.summary ?? '-'}`);
+          for (const node of detail.nodes) console.log(`  ${node.nodeId} · ok=${node.ok} · exit=${node.exit ?? '-'} · ${node.reason ?? node.summary ?? '-'}`);
           console.log(`pending: ${JSON.stringify(detail.pending)}`);
           console.log(`resume: ${JSON.stringify(detail.resume)}`);
         }

package/src/graph-runner/graph-run-api.ts

@@ -117,7 +117,7 @@ export function runnableIssues(doc: Record<string, unknown>, allowedRecipes: Rea
   return issues;
 }
 
-export interface GraphRunNodeView { nodeId: string; ok: boolean; executed: boolean; startedAt?: string; endedAt?: string; error?: string }
+export interface GraphRunNodeView { nodeId: string; ok: boolean; exit: number | null; executed: boolean; startedAt?: string; endedAt?: string; error?: string; reason?: string }
 export interface GraphRunView {
   graphId: string; runId: string; status: GraphRunState['status'] | 'starting';
   startedAt?: string; finishedAt?: string; path: string[];
@@ -130,9 +130,10 @@ export function graphRunView(state: GraphRunState): GraphRunView {
     ...(state.startedAt ? { startedAt: state.startedAt } : {}), ...(state.finishedAt ? { finishedAt: state.finishedAt } : {}),
     path: state.path,
     nodes: state.nodes.map((node) => ({
-      nodeId: node.nodeId, ok: node.ok, executed: node.executed,
+      nodeId: node.nodeId, ok: node.ok, exit: node.exit, executed: node.executed,
       ...(node.startedAt ? { startedAt: node.startedAt } : {}), ...(node.endedAt ? { endedAt: node.endedAt } : {}),
       ...(node.error ? { error: node.error.slice(0, 300) } : {}),
+      ...(node.reason === undefined ? {} : { reason: node.reason }),
     })),
     ...(state.currentNode ? { currentNode: state.currentNode } : {}),
   };

package/src/graph-runner/runner.ts

@@ -144,7 +144,7 @@ export interface GraphRunState {
   reason?: string;
   path: string[];
   /** startedAt/endedAt (ISO) and seconds are written when the node runs; ledgers before GRAPH-NODE-TIMES (0.2.19) have none. */
-  nodes: Array<{ nodeId: string; ok: boolean; exit: number | null; executed: boolean; output?: unknown; error?: string; decidedBy?: string; decidedAt?: string;
+  nodes: Array<{ nodeId: string; ok: boolean; exit: number | null; executed: boolean; output?: unknown; error?: string; reason?: string; decidedBy?: string; decidedAt?: string;
     startedAt?: string; endedAt?: string; seconds?: number;
     waiver?: { reason: string; at: string; /** RELEASE-WAIVE-UNMEASURED — why the waived gate had no verdict. */ unmeasured?: string; original: { exit: number | null; output?: unknown; error?: string } } }>;
   /** The node now running and when it started; cleared when its record is written. */
@@ -172,6 +172,11 @@ export interface GraphRunState {
   statePath: string;
 }
 
+function failedCommandStderrTail(exitCode: number, stderr: string): string | undefined {
+  if (exitCode === 0 || !stderr.trim()) return undefined;
+  return stderr.replace(/(?:\r?\n)+$/, '').split(/\r?\n/).slice(-40).join('\n') || undefined;
+}
+
 export interface GraphClassifyInput {
   arguments: string;
   classify: ClassifyNode['classify'];
@@ -1071,6 +1076,7 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
     let ok = approval && !state.dryRun ? state.pending?.decision === 'approved' : true;
     let exit: number | null = null;
     let error: string | undefined;
+    let commandFailureReason: string | undefined;
     let output: unknown;
     const waiving = options.releaseWaiver?.nodeId === current && waivedRecord !== undefined;
     if (command && !waiving && (!approval || state.dryRun || ok) && (!state.dryRun || command.dry_run_command) && !resumingCompleted) {
@@ -1105,7 +1111,9 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
         try {
           const result = await execute(body, commandRoot ? { ...opts, cwd: commandRoot } : opts);
           code = result.exitCode;
-          return { ...result, stdout: redactCredentials(result.stdout), stderr: redactCredentials(result.stderr) };
+          const stderr = redactCredentials(result.stderr);
+          commandFailureReason = failedCommandStderrTail(result.exitCode, stderr);
+          return { ...result, stdout: redactCredentials(result.stdout), stderr };
         } finally {
           if (state.activeNode?.nodeId === current) {
             delete state.activeNode;
@@ -1296,13 +1304,14 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
       exit = completed.exit;
       output = completed.output;
       error = completed.error;
+      commandFailureReason = completed.reason;
     } else {
       // 승인 노드도 결과를 «값»으로 남긴다 — 뒤 노드가 문맥(outputs)에서 승인 여부를 확인할 수 있게(발행 노드가 승인 없이 돌지 않도록).
       if (approval && !state.dryRun && !command) {
         output = JSON.stringify({ outcome: ok ? 'approved' : 'rejected', graphId, runId, nodeId: current,
           ...(state.pending?.decidedBy === undefined ? {} : { decidedBy: state.pending.decidedBy }), decidedAt: state.pending?.decidedAt ?? null });
       }
-      state.nodes.push({ nodeId: current, ok, exit, executed: !waiving && ((!!command && (!state.dryRun || !!command.dry_run_command)) || (!!prompt && !state.dryRun) || (node.kind === 'classify' && !state.dryRun) || unitExecuted), ...((waiving || harnessLoopRoute || units.has(current) || ((command || prompt || approval || node.kind === 'classify') && (!state.dryRun || !!command?.dry_run_command))) && output !== undefined ? { output } : {}), ...(error ? { error } : {}),
+      state.nodes.push({ nodeId: current, ok, exit, executed: !waiving && ((!!command && (!state.dryRun || !!command.dry_run_command)) || (!!prompt && !state.dryRun) || (node.kind === 'classify' && !state.dryRun) || unitExecuted), ...((waiving || harnessLoopRoute || units.has(current) || ((command || prompt || approval || node.kind === 'classify') && (!state.dryRun || !!command?.dry_run_command))) && output !== undefined ? { output } : {}), ...(error ? { error } : {}), ...(commandFailureReason ? { reason: commandFailureReason } : {}),
         ...(waiving ? { waiver: { reason: options.releaseWaiver!.reason, at: nodeEndedAt, ...(options.releaseWaiver!.unmeasured === undefined ? {} : { unmeasured: options.releaseWaiver!.unmeasured }), original: { exit: waivedRecord!.exit, ...(waivedRecord!.output === undefined ? {} : { output: waivedRecord!.output }), ...(waivedRecord!.error === undefined ? {} : { error: waivedRecord!.error }) } } } : {}),
         ...(approval && state.pending ? { ...(state.pending.decidedBy === undefined ? {} : { decidedBy: state.pending.decidedBy }), decidedAt: state.pending.decidedAt } : {}),
         startedAt: nodeStartedAt, endedAt: nodeEndedAt, seconds });
@@ -1318,10 +1327,13 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
     const reported: unknown = waiving || harnessLoopRoute || units.has(current) || (prompt && !state.dryRun) || (command && (!state.dryRun || command.dry_run_command)) ? lastJsonObject(resumingCompleted ? completed?.output : output)?.outcome : undefined;
     const namedOutcome: string | undefined = typeof reported === 'string' ? reported : undefined;
     if (!options.quiet) console.error(`[graph] ${current} ${ok ? 'ok' : 'fail'} (${seconds.toFixed(2)}s)`);
-    debug.log('graph.run', 'node', { graphId, runId, nodeId: current, phase: ok ? 'ok' : 'fail', seconds, exit });
+    debug.log('graph.run', 'node', { graphId, runId, nodeId: current, phase: ok ? 'ok' : 'fail', seconds, exit,
+      ...(commandFailureReason ? { reason: commandFailureReason } : {}) });
     publishInsideEvent({ kind: 'node', graphId, runId, nodeId: current, phase: ok ? 'ok' : 'fail', seconds });
     publishInsideEvent({ kind: 'verdict', graphId, runId, nodeId: current, verdict: ok ? 'ok' : 'fail', ...(namedOutcome === undefined ? {} : { outcome: namedOutcome }) });
-    log('node-end', { graphId, runId, nodeId: current, ok, exit, ...(namedOutcome === undefined ? {} : { outcome: namedOutcome }), dryRun: state.dryRun });
+    log('node-end', { graphId, runId, nodeId: current, ok, exit,
+      ...(commandFailureReason ? { reason: commandFailureReason } : {}),
+      ...(namedOutcome === undefined ? {} : { outcome: namedOutcome }), dryRun: state.dryRun });
     if (!resumingCompleted) {
       // Recipe commands expose stdout/exit but no provider usage; never infer zero from success.
       observeModelInputTokens({ scope: 'harness-node', nodeKind: node.kind, runId, nodeId: current });

package/src/graph-wizard/generate.ts

@@ -93,14 +93,36 @@ export function listKnownGraphUnits(dir = defaultGraphsDir()): KnownGraphUnit[]
   }).sort((a, b) => a.call.localeCompare(b.call));
 }
 
+/** 호출 경계로 올리는 조작 growth 요약 — 어느 from 노드에서 무엇을 끼우려 했나. */
+export interface GraphVariantGrowthTrace {
+  readonly from: string;
+  readonly outcome: string;
+  readonly nodeId: string;
+  readonly returnTo?: string;
+}
+
+/**
+ * 설계자 한 턴의 결말 — mode·reason 은 호출 경계가 관측으로 기록하는 필드다(composed 는 'composed',
+ * fallback-standard 는 그 사유 문자열 그대로). growth 는 설계자가 조작한 from 노드를 그대로 올린다.
+ */
 export type GraphVariantDesignResult =
-  | { readonly status: 'composed'; readonly plan: GraphVariantPlan; readonly variant: Extract<GraphVariantResult, { ok: true }> }
-  | { readonly status: 'fallback-standard'; readonly template: GraphTemplateSpec; readonly reason: string };
+  | { readonly mode: 'variant'; readonly status: 'composed'; readonly reason: 'composed'; readonly plan: GraphVariantPlan; readonly variant: Extract<GraphVariantResult, { ok: true }>; readonly growth?: GraphVariantGrowthTrace }
+  | { readonly mode: 'variant'; readonly status: 'fallback-standard'; readonly template: GraphTemplateSpec; readonly reason: string; readonly growth?: GraphVariantGrowthTrace };
 
 function isRecord(value: unknown): value is Record<string, unknown> {
   return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
 
+/** 설계자 출력에서 조작 growth 의 좌표만 읽는다 — 모양이 틀려도 «어느 from 이었나»는 남긴다. */
+function growthTraceOf(record: Record<string, unknown> | null): GraphVariantGrowthTrace | undefined {
+  const growth = record?.growth;
+  if (!isRecord(growth) || typeof growth.from !== 'string' || typeof growth.outcome !== 'string') return undefined;
+  const node = isRecord(growth.node) ? growth.node : undefined;
+  if (typeof node?.nodeId !== 'string') return undefined;
+  return { from: growth.from, outcome: growth.outcome, nodeId: node.nodeId,
+    ...(typeof growth.returnTo === 'string' ? { returnTo: growth.returnTo } : {}) };
+}
+
 /** One L2 designer proposal. The model returns only a plan; the existing variant authority decides whether it may run. */
 export async function designGraphVariantPlan(input: {
   readonly goal: string;
@@ -127,9 +149,10 @@ export async function designGraphVariantPlan(input: {
   catch (error) {
     const reason = `designer-output: ${error instanceof Error ? error.message : String(error)}`;
     debug.log('graph.compose', 'fallback-standard', { goal: input.goal, reason });
-    return { status: 'fallback-standard', template: input.template, reason };
+    return { mode: 'variant', status: 'fallback-standard', template: input.template, reason };
   }
   const record = isRecord(raw) ? raw : null;
+  const growthTrace = growthTraceOf(record);
   const allowed = new Set(['maxVisits', 'routes', 'growth']);
   const maxVisits = record?.maxVisits;
   const routes = record?.routes;
@@ -158,17 +181,17 @@ export async function designGraphVariantPlan(input: {
   if (!valid) {
     const reason = 'designer-output: invalid GraphVariantPlan or unknown unit';
     debug.log('graph.compose', 'fallback-standard', { goal: input.goal, reason });
-    return { status: 'fallback-standard', template: input.template, reason };
+    return { mode: 'variant', status: 'fallback-standard', template: input.template, reason, ...(growthTrace ? { growth: growthTrace } : {}) };
   }
   const plan = record as GraphVariantPlan;
   const variant = createGraphVariant({ template: input.template, goal: input.goal, plan });
   if (!variant.ok) {
     const reason = `variant-rejected: ${JSON.stringify(variant.rejections)}`;
     debug.log('graph.compose', 'fallback-standard', { goal: input.goal, reason });
-    return { status: 'fallback-standard', template: input.template, reason };
+    return { mode: 'variant', status: 'fallback-standard', template: input.template, reason, ...(growthTrace ? { growth: growthTrace } : {}) };
   }
   debug.log('graph.compose', 'composed', { goal: input.goal, overlayId: variant.overlay.overlayId, patches: variant.patches.length });
-  return { status: 'composed', plan, variant };
+  return { mode: 'variant', status: 'composed', reason: 'composed', plan, variant, ...(growthTrace ? { growth: growthTrace } : {}) };
 }
 
 /** Inventory used by the editor's pack picker and the wizard's validation. */

package/src/harness/harness-cli-command.ts

@@ -6,6 +6,7 @@ import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
 import { constants as osConstants, hostname } from 'node:os';
 import { basename, dirname, join, resolve, sep } from 'node:path';
 import { HarnessCliInputError } from '../cli/cli-user-error.js';
+import { writeStdoutFully } from '../cli/stdout-flush.js';
 import { findGitDir } from '../git-fs/locate.js';
 import { LogStore, logsDbPath } from '../mss/logging/log-store.js';
 import { loadSelfDevRun } from '../self-dev/run-store.js';
@@ -30,7 +31,7 @@ import { buildRunProgressRows, isPartialRunningRuns, queryRunningRuns, renderRun
 import { launchBindingRunIds, readLaunchBinding } from './launch-registry.js';
 import { psProcessStartMs } from './harness-stop.js';
 import { DevPipelineError } from '../self-dev/dev-pipeline.js';
-import { collectDraftMetrics, collectOverlapMetrics, DRAFT_SWEEP_CONCURRENCY, mapBounded, resolveDraftSweepCloseCap, runDraftSweep, sweepFailureReason, type DraftSweepAdapters, type DraftSweepResult, type OverlapMetricAdapters, type SweepDraft, type SweepMergedPr, type SweepReviewGate } from '../self-dev/draft-sweep.js';
+import { collectDraftMetrics, collectOverlapMetrics, DRAFT_SWEEP_CONCURRENCY, mapBounded, resolveDraftSweepCloseCap, runDraftSweep, sweepFailureReason, validateDraftSweepApplyPlan, type DraftSweepAdapters, type DraftSweepResult, type OverlapMetricAdapters, type SweepDraft, type SweepMergedPr, type SweepReviewGate } from '../self-dev/draft-sweep.js';
 import { readAskPreflightRowsSince, readSalvagedRowsSince } from '../self-dev/ask-launch-io.js';
 import { replayPodTerminals, type DraftResidueReplayOptions, type PrTerminalRecord } from '../self-dev/draft-residue.js';
 import { draftClaimComment, draftReleaseComment } from '../self-dev/draft-triage-rules.js';
@@ -2533,10 +2534,35 @@ const defaultDraftSweepStopRun: DraftSweepStopRun = async (runId) => {
   return stopHarnessRun(runId, defaultHarnessStopDeps());
 };
 
-export function githubDraftSweepAdapters(execute: GhExecute = executeGh, git: DraftSweepGitExecute = runGitCommand, cwd = process.cwd(),
+export interface GithubDraftSweepAdapterOptions {
+  /** Read-only preview bounds. Reaching a bound is reported as an incomplete inventory. */
+  maxInventoryPages?: number;
+  maxDrafts?: number;
+  maxMerged?: number;
+  onInventoryProgress?: (event: { state: 'open' | 'closed'; page: number; rows: number }) => void;
+  /** Test seam: provide an isolated run-ledger inventory instead of enumerating the host's stores. */
+  runLedgerMatches?: () => readonly RunLedgerMatch[];
+  /** Test seam: provide isolated running-run observations instead of inspecting host processes and PTY stores. */
+  runningRunStatuses?: () => ReadonlyMap<string, string>;
+  /** Test seam for bounded GitHub check-run backoff. */
+  checkRunRetryDelaysMs?: readonly number[];
+  checkRunSleep?: (milliseconds: number) => Promise<void>;
+}
+
+function createGithubDraftSweepAdapters(execute: GhExecute, git: DraftSweepGitExecute, cwd: string,
   executeAsync: (args: string[]) => Promise<string> = execute === executeGh ? executeGhAsync : async (args) => execute(args),
-  stopRun: DraftSweepStopRun = defaultDraftSweepStopRun): GithubDraftSweepAdapters {
+  stopRun: DraftSweepStopRun = defaultDraftSweepStopRun, options: GithubDraftSweepAdapterOptions = {}): GithubDraftSweepAdapters {
   const ensuredSweepLabels = new Set<string>();
+  const maxInventoryPages = Number.isSafeInteger(options.maxInventoryPages) && options.maxInventoryPages! > 0
+    ? Math.min(options.maxInventoryPages!, 100) : 100;
+  const maxDrafts = Number.isSafeInteger(options.maxDrafts) && options.maxDrafts! > 0 ? options.maxDrafts : undefined;
+  const maxMerged = Number.isSafeInteger(options.maxMerged) && options.maxMerged! > 0 ? options.maxMerged : undefined;
+  let inventoryIncompleteReason: string | undefined;
+  const markInventoryIncomplete = (reason: string) => { inventoryIncompleteReason ??= reason; };
+  const checkRunRetryDelays = options.checkRunRetryDelaysMs ?? [1_000, 2_000, 4_000];
+  const sleepForCheckRunRetry = options.checkRunSleep ?? ((milliseconds: number) => new Promise<void>((resolve) => setTimeout(resolve, milliseconds)));
+  let checkRunsQueue: Promise<void> = Promise.resolve();
+  let checkRunsUnavailableReason: string | undefined;
   const inventory = async (repository: string, state: 'open' | 'closed'): Promise<GithubPull[]> => {
     // ⛔ A large repository has tens of thousands of closed PRs (2026-09-28: 21k → «exceeded pagination limit», no sweep at all).
     //    Merged twins only matter after the oldest open draft was opened, so the closed listing stops at that time.
@@ -2548,15 +2574,28 @@ export function githubDraftSweepAdapters(execute: GhExecute = executeGh, git: Dr
       if (!Number.isFinite(cutoff)) throw new Error('Incomplete GitHub PR inventory');
     }
     const all: GithubPull[] = [];
-    for (let page = 1; page <= 100; page++) {
-      const batch = githubPullsPage(repository, state, page, execute);
+    for (let page = 1; page <= maxInventoryPages; page++) {
+      let batch: GithubPull[];
+      try { batch = githubPullsPage(repository, state, page, execute); }
+      catch (error) {
+        if (maxInventoryPages < 100) {
+          markInventoryIncomplete(`${state} PR inventory stopped after ${page - 1} pages (${all.length} rows): ${sweepFailureReason(error)}`);
+          return all;
+        }
+        throw error;
+      }
       if (!Array.isArray(batch) || batch.length > 100) throw new Error('Incomplete GitHub PR inventory');
       all.push(...batch);
+      options.onInventoryProgress?.({ state, page, rows: all.length });
       if (batch.length < 100) return all;
       // An unknown update time cannot prove the rest is older — keep paging.
       const oldest = Date.parse(batch[batch.length - 1]!.updated_at ?? '');
       if (cutoff !== undefined && Number.isFinite(oldest) && oldest < cutoff) return all;
     }
+    if (maxInventoryPages < 100) {
+      markInventoryIncomplete(`${state} PR inventory capped at ${maxInventoryPages} pages (${all.length} rows observed)`);
+      return all;
+    }
     throw new Error('GitHub PR inventory exceeded pagination limit');
   };
   const open = new Map<string, Promise<GithubPull[]>>();
@@ -2643,17 +2682,57 @@ export function githubDraftSweepAdapters(execute: GhExecute = executeGh, git: Dr
     }
     throw new Error('Review inventory exceeded pagination limit');
   };
-  const checkRunsFor = async (repository: string, sha: string): Promise<Array<{ conclusion?: string | null }> | undefined> => {
+  const readCheckRuns = async (repository: string, sha: string): Promise<Array<{ conclusion?: string | null }>> => {
     const runs: Array<{ conclusion?: string | null }> = [];
     for (let page = 1; page <= 100; page++) {
-      const result = await ghJsonAsync<{ total_count?: number; check_runs?: Array<{ conclusion?: string | null }> }>(
-        ['api', `repos/${repository}/commits/${sha}/check-runs?per_page=100&page=${page}`]);
-      if (!Array.isArray(result?.check_runs) || result.check_runs.length > 100) throw new Error('Incomplete check-run inventory');
+      let result: { total_count?: number; check_runs?: Array<{ conclusion?: string | null }> } | undefined;
+      let attempt = 0;
+      while (true) {
+        try {
+          result = await ghJsonAsync<{ total_count?: number; check_runs?: Array<{ conclusion?: string | null }> }>(
+            ['api', `repos/${repository}/commits/${sha}/check-runs?per_page=100&page=${page}`]);
+          break;
+        } catch (error) {
+          const reason = sweepFailureReason(error);
+          const retryable = /(?:\b403\b|\b429\b|rate.?limit|secondary rate)/i.test(reason);
+          if (!retryable || attempt >= checkRunRetryDelays.length) {
+            const incomplete = `check-run inventory incomplete for ${repository}@${sha}: ${reason}`;
+            checkRunsUnavailableReason ??= incomplete;
+            markInventoryIncomplete(incomplete);
+            throw new Error(incomplete);
+          }
+          await sleepForCheckRunRetry(checkRunRetryDelays[attempt++]!);
+        }
+      }
+      if (!Array.isArray(result?.check_runs) || result.check_runs.length > 100 || !Number.isSafeInteger(result.total_count) || result.total_count! < 0) {
+        const incomplete = `check-run inventory incomplete for ${repository}@${sha}: malformed page ${page}`;
+        checkRunsUnavailableReason ??= incomplete;
+        markInventoryIncomplete(incomplete);
+        throw new Error(incomplete);
+      }
       runs.push(...result.check_runs);
-      if (Number.isSafeInteger(result.total_count) && runs.length >= result.total_count!) return runs;
-      if (result.check_runs.length < 100) return Number.isSafeInteger(result.total_count) && runs.length < result.total_count! ? undefined : runs;
+      if (runs.length >= result.total_count!) return runs;
+      if (result.check_runs.length < 100) {
+        const incomplete = `check-run inventory incomplete for ${repository}@${sha}: expected ${result.total_count}, received ${runs.length} (check-runs may have changed during pagination or the response may be incomplete)`;
+        checkRunsUnavailableReason ??= incomplete;
+        markInventoryIncomplete(incomplete);
+        throw new Error(incomplete);
+      }
     }
-    return undefined;
+    const incomplete = `check-run inventory incomplete for ${repository}@${sha}: pagination limit reached`;
+    checkRunsUnavailableReason ??= incomplete;
+    markInventoryIncomplete(incomplete);
+    throw new Error(incomplete);
+  };
+  const checkRunsFor = async (repository: string, sha: string): Promise<Array<{ conclusion?: string | null }>> => {
+    let release!: () => void;
+    const previous = checkRunsQueue;
+    checkRunsQueue = new Promise<void>((resolve) => { release = resolve; });
+    await previous;
+    try {
+      if (checkRunsUnavailableReason) throw new Error(checkRunsUnavailableReason);
+      return await readCheckRuns(repository, sha);
+    } finally { release(); }
   };
   const headCommitTimeFor = async (repository: string, number: number): Promise<string | undefined> => {
     let latest: string | undefined;
@@ -2732,13 +2811,16 @@ export function githubDraftSweepAdapters(execute: GhExecute = executeGh, git: Dr
   const enrichedDrafts = (repository: string): Promise<SweepDraft[]> => {
     if (!draftRows.has(repository)) draftRows.set(repository, (async () => {
       const prs = (await listed(open, repository, 'open')).filter((pr) => pr.draft);
-      await prefetchDetails(repository, prs.map((pr) => pr.number));
-      const matches = ledgerMatches ??= listRunLedgers().matches;
-      return mapBounded(prs, DRAFT_SWEEP_CONCURRENCY, async (pr): Promise<SweepDraft> => {
+      const selected = maxDrafts === undefined ? prs : prs.slice(0, maxDrafts);
+      if (selected.length < prs.length) markInventoryIncomplete(`draft inventory capped at ${maxDrafts} drafts (${prs.length} drafts listed)`);
+      await prefetchDetails(repository, selected.map((pr) => pr.number));
+      const matches = readRunLedgerMatches();
+      return mapBounded(selected, DRAFT_SWEEP_CONCURRENCY, async (pr): Promise<SweepDraft> => {
         return {
           number: pr.number, title: pr.title, branch: pr.head.ref,
           labels: pr.labels.map((item) => item.name), createdAt: pr.created_at, body: pr.body ?? undefined,
           changedFiles: await prFiles(repository, pr.number),
+          ...(pr.head.sha ? { headSha: pr.head.sha } : {}),
           ...(pr.updated_at ? { updatedAt: pr.updated_at } : {}),
           runId: currentDraftSweepRunId(matches, repository, pr.number),
         };
@@ -2749,8 +2831,10 @@ export function githubDraftSweepAdapters(execute: GhExecute = executeGh, git: Dr
   const enrichedMerged = (repository: string): Promise<SweepMergedPr[]> => {
     if (!mergedRows.has(repository)) mergedRows.set(repository, (async () => {
       const prs = (await listed(closed, repository, 'closed')).filter((pr) => pr.merged_at !== null && pr.base?.ref === 'main');
-      await prefetchDetails(repository, prs.map((pr) => pr.number));
-      return mapBounded(prs, DRAFT_SWEEP_CONCURRENCY, async (pr): Promise<SweepMergedPr> => ({
+      const selected = maxMerged === undefined ? prs : prs.slice(0, maxMerged);
+      if (selected.length < prs.length) markInventoryIncomplete(`merged PR inventory capped at ${maxMerged} records (${prs.length} records listed)`);
+      await prefetchDetails(repository, selected.map((pr) => pr.number));
+      return mapBounded(selected, DRAFT_SWEEP_CONCURRENCY, async (pr): Promise<SweepMergedPr> => ({
         number: pr.number, title: pr.title, branch: pr.head.ref, body: pr.body ?? undefined,
         mergedAt: pr.merged_at ?? undefined, changedFiles: await prFiles(repository, pr.number),
         mergeCommitMessage: await mergeCommitMessageFor(repository, pr),
@@ -2760,19 +2844,35 @@ export function githubDraftSweepAdapters(execute: GhExecute = executeGh, git: Dr
   };
   let ledgerMatches: readonly RunLedgerMatch[] | undefined;
   let running: ReadonlyMap<string, string> | undefined;
-  const runStatusFor = (draft: SweepDraft, repository: string): string | undefined => {
-    ledgerMatches ??= listRunLedgers().matches;
-    running ??= new Map(queryRunningRuns().entries.map((entry) => [entry.runId, entry.status]));
+  const readRunLedgerMatches = (): readonly RunLedgerMatch[] => {
+    ledgerMatches ??= options.runLedgerMatches?.() ?? listRunLedgers().matches;
+    return ledgerMatches;
+  };
+  const readRunningRunStatuses = (): ReadonlyMap<string, string> => {
+    running ??= options.runningRunStatuses?.() ?? new Map(queryRunningRuns().entries.map((entry) => [entry.runId, entry.status]));
+    return running;
+  };
+  const runStatusFor = (draft: Pick<SweepDraft, 'number' | 'branch' | 'runId'>, repository: string): string | undefined => {
+    const matches = readRunLedgerMatches();
+    const statuses = readRunningRunStatuses();
     if (draft.runId) {
-      const match = ledgerMatches.find((entry) => entry.runId === draft.runId);
-      return match ? draftSweepRunStatus([match], running, repository, draft.number) : undefined;
+      const match = matches.find((entry) => entry.runId === draft.runId);
+      return match ? draftSweepRunStatus([match], statuses, repository, draft.number) : undefined;
     }
-    return draftSweepRunStatus(ledgerMatches, running, repository, draft.number);
+    return draftSweepRunStatus(matches, statuses, repository, draft.number);
   };
   return {
+    inventoryStatus: async () => ({ complete: inventoryIncompleteReason === undefined, ...(inventoryIncompleteReason ? { reason: inventoryIncompleteReason } : {}) }),
     openPullRequests: (repository) => listed(open, repository, 'open'),
-    runLedgerMatches: () => (ledgerMatches ??= listRunLedgers().matches),
+    runLedgerMatches: readRunLedgerMatches,
     getPrFiles: async (repository, number) => prFiles(repository, number),
+    getDraftSnapshot: async (repository, number) => {
+      const pr = await ghJsonAsync<GithubPull>(['api', `repos/${repository}/pulls/${number}`]);
+      if (!pr || pr.number !== number || !Array.isArray(pr.labels) || !pr.head?.sha || !pr.updated_at
+        || (pr.state !== 'open' && pr.state !== 'closed')) return undefined;
+      return { number: pr.number, state: pr.state, draft: pr.draft, headSha: pr.head.sha,
+        branch: pr.head.ref, updatedAt: pr.updated_at, labels: pr.labels.map((item) => item.name) };
+    },
     getPr: async (repository, number) => {
       const pr = ghJson<GithubPull>(['api', `repos/${repository}/pulls/${number}`], execute);
       if (!pr || pr.number !== number || typeof pr.head?.ref !== 'string' || !Array.isArray(pr.labels)) return undefined;
@@ -2804,8 +2904,8 @@ export function githubDraftSweepAdapters(execute: GhExecute = executeGh, git: Dr
     getRunStatus: async (draft, repository) => runStatusFor(draft, repository),
     getLatestFileChanges: async (draft, repository) => latestFileChangesFor(draft, repository),
     hasFinalRunResult: async (draft, repository) => {
-      ledgerMatches ??= listRunLedgers().matches;
-      const ownedRuns = new Set(ledgerMatches.filter((match) => {
+      const matches = readRunLedgerMatches();
+      const ownedRuns = new Set(matches.filter((match) => {
         const prEvents = match.entries.filter((entry) => entry.event === 'pr-opened' && entry.data.number === draft.number);
         return prEvents.length > 0 && prEvents.every((entry) => ledgerPrRepository(entry.data, draft.number) === repository);
       }).map((match) => match.runId));
@@ -2863,7 +2963,7 @@ export function githubDraftSweepAdapters(execute: GhExecute = executeGh, git: Dr
     getActiveClaimRunId: async (repository, number) => activeClaimRunIdFromBodies(await claimCommentsFor(repository, number)),
     getLastClaimReleaseAt: async (repository, number) => lastClaimReleaseAtFromBodies(await claimCommentsFor(repository, number)),
     listTaskCards: async () => Object.values(readTaskAgentState<{ tasks?: Record<string, TaskCard> }>(taskAgentStatePath()).tasks ?? {}),
-    listPrTerminals: async () => listRunLedgers().matches.flatMap((match) => match.entries.filter((entry) => entry.event === 'pr-terminal')
+    listPrTerminals: async () => readRunLedgerMatches().flatMap((match) => match.entries.filter((entry) => entry.event === 'pr-terminal')
       .map((entry) => entry.data as unknown as PrTerminalRecord)),
     commentDraft: async (repository, number, body) => { execute(['pr', 'comment', String(number), '--repo', repository, '--body', body]); },
     listIssueComments: async (repository, number) => issueCommentsFor(repository, number, 'same-cell'),
@@ -2885,6 +2985,18 @@ export function githubDraftSweepAdapters(execute: GhExecute = executeGh, git: Dr
   };
 }
 
+export function githubDraftSweepAdapters(execute: GhExecute = executeGh, git: DraftSweepGitExecute = runGitCommand,
+  cwd = process.cwd(), executeAsync?: (args: string[]) => Promise<string>, stopRun?: DraftSweepStopRun,
+  options: GithubDraftSweepAdapterOptions = {}): GithubDraftSweepAdapters {
+  return createGithubDraftSweepAdapters(execute, git, cwd, executeAsync, stopRun, options);
+}
+
+export function githubDraftSweepPreviewAdapters(options: GithubDraftSweepAdapterOptions,
+  execute: GhExecute = executeGh, git: DraftSweepGitExecute = runGitCommand, cwd = process.cwd(),
+  executeAsync?: (args: string[]) => Promise<string>, stopRun?: DraftSweepStopRun): GithubDraftSweepAdapters {
+  return createGithubDraftSweepAdapters(execute, git, cwd, executeAsync, stopRun, options);
+}
+
 export interface HarnessDraftSweepDeps {
   /** DRAFT-LINEAGE-ONE-1 test seam for the real adapter's run stop; omitted ⇒ `harness stop`. */
   readonly stopRun?: DraftSweepStopRun;
@@ -3033,7 +3145,12 @@ function installHarnessDraftSweepCommand(harnessCmd: Command, deps: HarnessDraft
     .option('--json', '판정 결과를 JSON 으로 출력')
     .option('--repo <owner/name>', '조회할 GitHub 저장소')
     .option('--close-cap <n>', '이번 틱 최대 종료 수 (1~100 · config tools.selfImplement.draftSweepCloseCap 보다 우선 · 기본 10)')
-    .action(async (opts: { apply?: boolean; json?: boolean; repo?: string; closeCap?: string }) => {
+    .option('--max-pages <n>', 'inventory 상한 (페이지, dry-run 기본 1 · apply 기본 100 · 1~100)')
+    .option('--max-drafts <n>', 'draft 상한 (dry-run 기본 10 · apply 기본 무제한)')
+    .option('--max-merged <n>', 'merged PR 상한 (dry-run 기본 50 · apply 기본 무제한)')
+    .option('--emit-apply-plan', '완전한 dry-run 분류에서 고정 적용 계획을 JSON에 포함 (모든 PR에 head SHA와 updatedAt 필요)')
+    .option('--apply-plan-file <path>', '고정 적용 계획 JSON 파일 (apply 전용)')
+    .action(async (opts: { apply?: boolean; json?: boolean; repo?: string; closeCap?: string; maxPages?: string; maxDrafts?: string; maxMerged?: string; emitApplyPlan?: boolean; applyPlanFile?: string }) => {
       try {
         const write = deps.write ?? console.log;
         const execute = deps.execute ?? executeGh;
@@ -3044,8 +3161,26 @@ function installHarnessDraftSweepCommand(harnessCmd: Command, deps: HarnessDraft
         if (!DRAFT_SWEEP_REPOSITORY.test(repository) || repository.includes('..')) {
           throw new HarnessCliInputError(`invalid --repo (expected owner/name): ${repository}`);
         }
+        const readLimit = (value: string | undefined, fallback: number, name: string, max: number): number => {
+          const limit = value === undefined ? fallback : Number(value);
+          if (!Number.isSafeInteger(limit) || limit < 1 || limit > max) throw new HarnessCliInputError(`invalid ${name} (expected 1~${max})`);
+          return limit;
+        };
+        const applying = opts.apply === true;
+        if (opts.emitApplyPlan && (applying || !opts.json)) throw new HarnessCliInputError('--emit-apply-plan requires dry-run --json');
+        if (opts.applyPlanFile && !applying) throw new HarnessCliInputError('--apply-plan-file requires --apply');
+        const applyPlan = opts.applyPlanFile
+          ? validateDraftSweepApplyPlan(JSON.parse(readFileSync(resolve(opts.applyPlanFile), 'utf8')))
+          : undefined;
         // One adapter instance per sweep: its open listing and ledger scan are shared with the RUN-TTL step.
-        const github = deps.adapters ? undefined : githubDraftSweepAdapters(deps.execute, undefined, undefined, undefined, deps.stopRun);
+        const inventoryLimits = {
+          maxInventoryPages: readLimit(opts.maxPages, applying ? 100 : 1, '--max-pages', 100),
+          maxDrafts: opts.maxDrafts === undefined && applying ? undefined : readLimit(opts.maxDrafts, 10, '--max-drafts', 1_000),
+          maxMerged: opts.maxMerged === undefined && applying ? undefined : readLimit(opts.maxMerged, 50, '--max-merged', 1_000),
+          onInventoryProgress: ({ state, page, rows }: { state: 'open' | 'closed'; page: number; rows: number }) =>
+            console.error(`[draft-sweep] inventory state=${state} page=${page} rows=${rows}`),
+        };
+        const github = deps.adapters ? undefined : githubDraftSweepPreviewAdapters(inventoryLimits, deps.execute, undefined, undefined, undefined, deps.stopRun);
         const configCap = deps.closeCapConfig
           ? deps.closeCapConfig()
           : (() => { try { return getUserConfig().tools?.selfImplement?.draftSweepCloseCap; } catch { return undefined; } })();
@@ -3055,7 +3190,7 @@ function installHarnessDraftSweepCommand(harnessCmd: Command, deps: HarnessDraft
           try { debug.log('self-dev.draft-sweep', 'close-cap-rejected', { warning, closeCap: cap.closeCap, closeCapSource: cap.closeCapSource }); } catch { /* fail-soft */ }
         }
         let replayClosed = 0;
-        if (opts.apply && (!deps.adapters || deps.residueReplay)) {
+        if (opts.apply && !applyPlan && (!deps.adapters || deps.residueReplay)) {
           try {
             replayClosed = (await replayPodTerminals({ ...deps.residueReplay, repository, closeCap: cap.closeCap })).closed;
           } catch (error) {
@@ -3066,12 +3201,23 @@ function installHarnessDraftSweepCommand(harnessCmd: Command, deps: HarnessDraft
           }
         }
         const result: DraftSweepResult = await runDraftSweep({ repository, apply: opts.apply === true, includeTriage: opts.json === true, adapters: deps.adapters ?? github!,
-          closeCap: cap.closeCap, closeCapSource: cap.closeCapSource, alreadyClosed: replayClosed });
+          closeCap: cap.closeCap, closeCapSource: cap.closeCapSource, alreadyClosed: replayClosed,
+          includeApplyPlan: opts.emitApplyPlan === true, applyPlan });
+        const frozenPlanMaintenance = applyPlan ? { postSweep: {
+          residueReplay: 'skipped: frozen plan does not include terminal-residue PRs',
+          runTtl: 'skipped: frozen plan does not include RUN-TTL PRs',
+        } } : {};
         const reason = result.error ? sweepFailureReason(result.error) : undefined;
         const ttlStarted = Date.now();
-        const runTtl = await draftSweepRunTtl(repository, deps, github);
+        const runTtl = result.complete && !applyPlan ? await draftSweepRunTtl(repository, deps, github) : undefined;
         try { debug.log('self-dev.draft-sweep', 'timing', { phase: 'run-ttl', ms: Date.now() - ttlStarted, count: runTtl && !('error' in runTtl) ? runTtl.considered : 0 }); } catch { /* fail-soft */ }
-        if (opts.json) write(JSON.stringify({ ...(reason ? { ...result, error: reason } : result), ...(runTtl ? { runTtl } : {}) }));
+        if (opts.json) {
+          const output = JSON.stringify({ ...(reason ? { ...result, error: reason } : result), ...frozenPlanMaintenance, ...(runTtl ? { runTtl } : {}) });
+          // `src/index.ts` imports chalk, which makes Bun stdout non-blocking. Await the
+          // write callback so a large JSON result cannot be silently cut at the pipe buffer.
+          if (deps.write) write(output);
+          else await writeStdoutFully(output);
+        }
         else {
           if (runTtl) {
             write('error' in runTtl ? `run-ttl: 실패 (${runTtl.error})`

package/src/harness/review-adapter.ts

@@ -20,11 +20,13 @@ export interface GateLike {
   log?: string;
 }
 
+const isMissingAtBaseLine = (line: string): boolean => /^- (?!(?:introduced|preexisting|unknown):).+: missing-at-base\b/.test(line);
+
 /** 리뷰어에게 줄 게이트 실행 증빙. 전체 로그 대신 러너/컴파일러가 낸 판정 줄만 원문으로 보존한다. */
 export function gateEvidenceNote(gate: GateLike): string | undefined {
   if (!gate.log?.trim()) return undefined;
   const lines = gate.log.split(/\r?\n/).filter((line) =>
-    /(?:^\[gate-baseline\]|^- (?:introduced|preexisting|unknown):|^⚠️ .*책임이 아니다\.|Ran \d+ tests? across \d+ files?|\b\d+ (?:pass|fail)\b|error TS\d+|Verify-by-breaking|verify-by-breaking|원복 후|뒤집었을 때)/i.test(line),
+    isMissingAtBaseLine(line) || /(?:^\[gate-baseline\]|^\[changed-test-evidence\]|^- (?:introduced|preexisting|unknown):|^⚠️ .*책임이 아니다\.|Ran \d+ tests? across \d+ files?|\b\d+ (?:pass|fail)\b|error TS\d+|Verify-by-breaking|verify-by-breaking|원복 후|뒤집었을 때)/i.test(line),
   );
   if (!lines.length) return undefined;
 
@@ -33,19 +35,36 @@ export function gateEvidenceNote(gate: GateLike): string | undefined {
   const baselineHeads = lines.filter((line) => line.startsWith('[gate-baseline]'));
   const exonerations = lines.filter((line) => /^⚠️ .*책임이 아니다\.$/.test(line));
   const attributions = lines.filter((line) => /^- (?:introduced|preexisting|unknown):/.test(line));
+  const changedHeads = lines.filter((line) => line.startsWith('[changed-test-evidence]'));
+  const missingAtBase = lines.filter(isMissingAtBaseLine);
+  const changedEvidence = [
+    ...changedHeads.slice(0, 1),
+    ...(missingAtBase.length ? ['[changed-test-evidence] base에 없는 신규 모듈의 base RED 목격을 must-fix로 요구하지 말 것. missing-at-base는 RED 증거다.'] : []),
+    ...missingAtBase.slice(0, 4),
+    ...(missingAtBase.length > 4 ? [omission(missingAtBase.length - 4)] : []),
+    ...changedHeads.slice(1, 3),
+    ...(changedHeads.length > 3 ? [omission(changedHeads.length - 3)] : []),
+  ];
+  const prioritizedAttributions = changedEvidence.length
+    ? [...attributions.filter((line) => line.startsWith('- introduced:')),
+      ...attributions.filter((line) => !line.startsWith('- introduced:'))]
+    : attributions;
   const hasBaseline = baselineHeads.length > 0;
-  const limit = 24;
-  const rest = lines.filter((line) => !line.startsWith('[gate-baseline]') && !/^⚠️ .*책임이 아니다\.$/.test(line) && !/^- (?:introduced|preexisting|unknown):/.test(line));
+  const limit = 24; // evidence 줄 상한. 제목 한 줄을 더한 출력은 최대 25줄이다.
+  const rest = lines.filter((line) => !line.startsWith('[gate-baseline]') && !/^⚠️ .*책임이 아니다\.$/.test(line)
+    && !/^- (?:introduced|preexisting|unknown):/.test(line) && !line.startsWith('[changed-test-evidence]')
+    && !isMissingAtBaseLine(line));
   const ordered = hasBaseline
     ? [
       ...baselineHeads.slice(0, 1),
       ...exonerations.slice(0, 1),
-      ...attributions,
+      ...changedEvidence,
+      ...prioritizedAttributions,
       ...baselineHeads.slice(1),
       ...exonerations.slice(1),
       ...rest,
     ]
-    : lines;
+    : changedEvidence.length ? [...changedEvidence, ...exonerations, ...prioritizedAttributions, ...rest] : lines;
   if (!hasBaseline || ordered.length <= limit) {
     const selected = ordered.length <= limit
       ? ordered
@@ -58,7 +77,8 @@ export function gateEvidenceNote(gate: GateLike): string | undefined {
   const budgeted = [
     ...baselineHeads.slice(0, 1),
     ...exonerations.slice(0, 1),
-    ...attributions.slice(0, attributionLimit),
+    ...changedEvidence,
+    ...prioritizedAttributions.slice(0, attributionLimit),
     ...(omittedAttributions ? [omission(omittedAttributions)] : []),
     ...baselineHeads.slice(1),
     ...exonerations.slice(1),