elanous 0.2.35 → 0.2.37

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';
@@ -20,7 +21,7 @@ import { runGitCommand } from '../git-fs/runner.js';
 import { GOAL_TYPES, lintGoalFile, parseGoalId, parseGoalType, resolveGoalAuthorGrade, tracedPathReferences, type GoalAuthorGrade, type GoalAuthorGradeSelection, type GoalType } from '../self-implement/goal-author.js';
 import { templateForGoalType } from '../self-implement/graph-templates.js';
 import { appendRunLedgerEntry, listRunLedgers, loadFederatedRunLedger, loadRunLedger, queryRunScreenKey, runLedgerDir, type RunLedgerEntry, type RunLedgerMatch, type RunLedgerWriter } from '../self-implement/run-ledger.js';
-import { classifyPodExit, type PodExitClass } from '../task-orchestrator/surfaces/pod-failure-reason.js';
+import { classifyPodExit, parsePodTermination, type PodExitClass, type PodTermination } from '../task-orchestrator/surfaces/pod-failure-reason.js';
 import type { PodChildEvidence } from '../task-orchestrator/surfaces/self-implement.js';
 import { classifyPodExitStop, readRunStopRecord, recordRunStop, runStopRecorded, RUN_STOP_EVENT } from '../self-implement/run-stop.js';
 import { captureStopKnowhowCandidate } from '../self-implement/stop-autoheal.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';
@@ -419,7 +420,7 @@ function resolveLaunchSubstrate(opts: HarnessSubstrateOpts): ResolvedHarnessSubs
 }
 type PodExit = { status: number | null; signal?: string | null };
 type PodExitReason = 'signal' | 'human-stop' | 'supervisor' | 'no-launch' | 'unknown' | 'preflight-refused'
-  | 'pod-error' | 'launch-gate-blocked' | 'ENOBUFS' | 'OOMKilled';
+  | 'pod-error' | 'launch-gate-blocked' | 'dep-blocked' | 'ENOBUFS' | 'OOMKilled';
 
 function unknownPodExitTailReason(output: string): PodExitReason | undefined {
   const tail = output.slice(-16_000);
@@ -427,6 +428,7 @@ function unknownPodExitTailReason(output: string): PodExitReason | undefined {
   if (/\bENOBUFS\b/i.test(tail)) return 'ENOBUFS';
   if (/launch gate[^\r\n]*blocked|blocked[^\r\n]*launch gate/i.test(tail)) return 'launch-gate-blocked';
   if (/\bpod-error\b/i.test(tail)) return 'pod-error';
+  if (/\b(?:DEP_FAILED|DEPENDENCY_NEEDS_HUMAN|DEP_BLOCKED_REBASE_READY)\b/.test(tail)) return 'dep-blocked';
   return undefined;
 }
 /** GitHub lists at most this many files for one pull request; a list that reaches it is not provably complete. */
@@ -575,7 +577,9 @@ export function recordClassifiedHarnessPodExit(runId: string | undefined, reason
   context: { entrance?: string; seat?: string; output?: string } = {}): void {
   if (!runId) return;
   try {
-    const childEvidence = reason === 'preflight-refused' ? undefined : latestPodChildEvidence(loadRunLedger(runId));
+    const ledger = reason === 'preflight-refused' ? undefined : loadRunLedger(runId);
+    const childEvidence = latestPodChildEvidence(ledger);
+    const podTermination = latestPodTermination(ledger);
     const signal = status > 128
       ? Object.entries(osConstants.signals).find(([, number]) => number === status - 128)?.[0] ?? null : null;
     const cwd = process.cwd();
@@ -586,17 +590,42 @@ export function recordClassifiedHarnessPodExit(runId: string | undefined, reason
       cwd: `${basename(dirname(cwd))}/${basename(cwd)}`, hostname: hostname().split('.')[0]!, pid: process.pid,
       ...(context.output ? { lastLines: incidentLastLines(context.output) } : {}),
       ...(childEvidence ? { childEvidence } : {}),
+      ...(podTermination ? { podTermination } : {}),
     }, effectiveInstanceRoot());
   } catch { /* incident writes cannot change Pod output or exit */ }
 }
 
-function latestPodChildEvidence(entries: readonly RunLedgerEntry[] | null | undefined): PodChildEvidence | undefined {
+/**
+ * The current attempt's `pod-child-evidence` rows (same job · childRunId as the last `pod-child-run`), oldest first.
+ * Also fenced by position: only rows written after that start count, so a reused job/childRunId pair cannot
+ * hand an earlier attempt's row (childEvidence or podTermination) to a later one.
+ */
+function currentPodChildEvidenceRows(entries: readonly RunLedgerEntry[] | null | undefined): { job: string; rows: Record<string, unknown>[] } | undefined {
   // The current attempt's start is the fence. An earlier Pod's terminal facts cannot
   // classify a later attempt when that attempt has no JSON or its ledger write failed.
-  const current = entries?.filter((entry) => entry.event === 'pod-child-run').at(-1)?.data;
+  let startIndex = -1;
+  entries?.forEach((entry, index) => { if (entry.event === 'pod-child-run') startIndex = index; });
+  const current = startIndex >= 0 ? entries![startIndex]!.data : undefined;
   if (typeof current?.job !== 'string' || typeof current.childRunId !== 'string') return undefined;
-  const data = entries?.filter((entry) => entry.event === 'pod-child-evidence'
-    && entry.data?.job === current.job && entry.data?.childRunId === current.childRunId).at(-1)?.data;
+  const rows = (entries ?? []).filter((entry, index) => index > startIndex && entry.event === 'pod-child-evidence'
+    && entry.data?.job === current.job && entry.data?.childRunId === current.childRunId).map((entry) => entry.data);
+  return { job: current.job, rows };
+}
+
+/** JOB-FAILURE-TERMINATION-CAPTURE — the current attempt's latest well-formed capture of its own Job (a later
+ *  evidence row of the same attempt without one does not drop it); another Job's or round's never crosses over. */
+function latestPodTermination(entries: readonly RunLedgerEntry[] | null | undefined): PodTermination | undefined {
+  const current = currentPodChildEvidenceRows(entries);
+  if (!current) return undefined;
+  for (const row of current.rows.slice().reverse()) {
+    const parsed = parsePodTermination(row.podTermination, current.job);
+    if (parsed) return parsed;
+  }
+  return undefined;
+}
+
+function latestPodChildEvidence(entries: readonly RunLedgerEntry[] | null | undefined): PodChildEvidence | undefined {
+  const data = currentPodChildEvidenceRows(entries)?.rows.at(-1);
   const evidence = data?.childEvidence;
   if (!evidence || typeof evidence !== 'object' || Array.isArray(evidence)) return undefined;
   const row = evidence as Record<string, unknown>;
@@ -604,6 +633,8 @@ function latestPodChildEvidence(entries: readonly RunLedgerEntry[] | null | unde
   if (('scopeEscape' in row && row.scopeEscape !== true)
     || ('goalCauseObserved' in row && row.goalCauseObserved !== true)
     || ('classification' in row && typeof row.classification !== 'string')
+    || ('newScope' in row && !Array.isArray(row.newScope))
+    || ('scopeStopReasons' in row && !Array.isArray(row.scopeStopReasons))
     || ('abandonedClassification' in row && !object(row.abandonedClassification))
     || ('accountAvailability' in row && !object(row.accountAvailability))) return undefined;
   return row as PodChildEvidence;
@@ -783,6 +814,14 @@ export function recordHarnessPodStop(
     if (ledger?.some((entry) => entry.event === RUN_STOP_EVENT)) return false;
     const childEvidence = latestPodChildEvidence(ledger);
     const scopeEscape = childEvidence?.scopeEscape === true;
+    // SCOPE-ESCAPE-AS-REFINE — out-of-scope edits without a stop reason are «new scope», not a scope-escape stop.
+    if (childEvidence?.newScope?.length || childEvidence?.scopeStopReasons?.length) {
+      try {
+        debug.log('harness.pod', scopeEscape ? 'scope-escape-stop' : 'scope-new-scope', { runId, scopeEscape,
+          ...(childEvidence.newScope ? { newScope: childEvidence.newScope } : {}),
+          ...(childEvidence.scopeStopReasons ? { scopeStopReasons: childEvidence.scopeStopReasons } : {}) });
+      } catch { /* observation cannot change the stop record */ }
+    }
     if (classified.reason === 'preflight-refused') {
       (deps.record ?? recordRunStop)({
         runId, site: 'preflight', class: 'launch-failed',
@@ -2495,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.
@@ -2510,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[]>>();
@@ -2605,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;
@@ -2694,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),
         };
@@ -2711,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),
@@ -2722,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;
@@ -2766,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));
@@ -2825,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'),
@@ -2847,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;
@@ -2995,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;
@@ -3006,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; } })();
@@ -3017,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) {
@@ -3028,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})`
@@ -3538,7 +3722,13 @@ export function installHarnessCliCommand(program: Command, deps: HarnessCliComma
   if (say) {
     registerHarnessAskSayOptions(harnessCmd.command('say <sentence...>').description('문장을 받아 구동한다'))
       .addOption(new Option('--author-grade <grade>', 'say 저작 등급 (full|lite)').choices(['full', 'lite']))
+      .option('--move-id <id>', 'NEXTMOVE-GENERAL-RELAUNCH-MOVEID — 이 발사를 고른 TA next-move 결정의 수 id(관측 조인 칸 · 발사 동작은 바꾸지 않는다)')
       .action(async (sentence: string[], opts: HarnessAskSayChildLlmOptions & HarnessDryRunOpts) => {
+        const moveId = (opts as { moveId?: unknown }).moveId;
+        // 발사 쪽 영수증 — TA 일반 재발사가 실은 수 id 를 받았다는 한 줄(관측만 · fail-soft · 옵션은 아래로 내려가지 않는다).
+        if (typeof moveId === 'string' && moveId) {
+          try { debug.log('harness', 'move-id-received', { entrance: 'cli-harness-say', moveId }); } catch { /* fail-soft */ }
+        }
         const repair = opts as HarnessSubstrateOpts;
         if (repair.repairCommitOnly !== undefined && (repair.substrate !== 'pod' || !/^pr:[1-9]\d*$/.test(repair.source ?? '')
           || !/^[0-9a-f]{40}$/.test(repair.repairCommitOnly) || repair.autoMerge !== false || repair.target !== undefined)) {

package/src/harness/harness-incidents.ts

@@ -4,6 +4,7 @@ import { join } from 'node:path';
 import { redactSecretText } from '../debug/log.js';
 import { refuseProductionLedgerWriteInTest } from './ledger-write-guard.js';
 import type { PodChildEvidence } from '../task-orchestrator/surfaces/self-implement.js';
+import { parsePodTermination, type PodTermination } from '../task-orchestrator/surfaces/pod-failure-reason.js';
 
 export interface RunExit {
   runId: string;
@@ -18,6 +19,14 @@ export interface RunExit {
   pid?: number;
   lastLines?: string[];
   childEvidence?: PodChildEvidence;
+  /** JOB-FAILURE-TERMINATION-CAPTURE — the current attempt's Job/Pod termination facts, captured before GC. */
+  podTermination?: PodTermination;
+  /** INCIDENT-REASON-FROM-LASTLINES — 기록된 reason 이 unknown 이라 lastLines 로 다시 분류했으면 원래 값. */
+  recordedReason?: string;
+  /** reason 을 어디서 얻었나 — 'lastLines' 면 위 분류 규칙으로 정했다(기록 원문은 recordedReason). */
+  reasonSource?: 'lastLines';
+  /** lastLines 에 ux-sim 장치 조각 경로가 보였다 — 장치 먼저 조각의 실패를 따로 셀 수 있게. */
+  slice?: 'device';
 }
 
 export interface IncidentBurst {
@@ -44,6 +53,40 @@ function kstDate(at: number): string {
   return new Date(at + KST_OFFSET_MS).toISOString().slice(0, 10);
 }
 
+// ── INCIDENT-REASON-FROM-LASTLINES (0.2.36 · 10-22 · OP 대응 피처) ───────────────────────────────
+// 기록된 reason 이 «unknown» 인데 마지막 출력 줄에 사유가 그대로 있는 사고가 다수(10-22 경보) — 읽는 쪽에서
+// 결정론으로 다시 분류한다. 우선순위 = 더 구체적인 종료 사유 먼저. 아무것도 안 맞으면 unknown 그대로(추측 0).
+const LAST_LINE_REASONS: ReadonlyArray<[RegExp, string]> = [
+  // 근본 원인 먼저 — 뒤 조각의 DEPENDENCY_NEEDS_HUMAN 은 앞 조각 실패의 «증상»이라 맨 뒤 쪽.
+  [/goal-elaboration needs-human:\s*goal-elaboration-ungrounded-path\b/, 'goal-elaboration-ungrounded-path'],
+  [/goal-elaboration needs-human:\s*goal-elaboration-protected-path\b/, 'goal-elaboration-protected-path'],
+  [/goal-elaboration needs-human:\s*goal-elaboration-scope-conflict\b/, 'goal-elaboration-scope-conflict'],
+  [/goal-elaboration needs-human:\s*goal-elaboration-fixed-layer-conflict\b/, 'goal-elaboration-fixed-layer-conflict'],
+  [/pod-deadline-exceeded|DeadlineExceeded/, 'pod-deadline-exceeded'],
+  [/GOAL_DONE_BOUNDARY_MISSING/, 'goal-done-boundary-missing'],
+  [/BackoffLimitExceeded/, 'pod-backoff-limit'],
+  [/childError=no-resul/, 'pod-child-no-result'],
+  [/pod-job-failed/, 'pod-job-failed'],
+  [/DEPENDENCY_NEEDS_HUMAN/, 'dependency-needs-human'],
+  [/\[needs-human\]|needs-human/, 'needs-human'],
+];
+const DEVICE_SLICE_PATH = /src\/ux-sim\/[\w.-]*-device(?:\.test)?\.ts|DEVICE-FIRST/;
+
+/** lastLines 에서 종료 사유를 꺼낸다 — 안 맞으면 null(unknown 유지). */
+export function classifyIncidentReasonFromLastLines(lines: readonly string[] | undefined): string | null {
+  if (!lines?.length) return null;
+  const text = lines.join('\n');
+  for (const [pattern, reason] of LAST_LINE_REASONS) if (pattern.test(text)) return reason;
+  return null;
+}
+
+function refinedReasonFields(reason: string, lines: readonly string[] | undefined): Pick<RunExit, 'reason' | 'recordedReason' | 'reasonSource' | 'slice'> {
+  const slice = lines?.some((line) => DEVICE_SLICE_PATH.test(line)) ? { slice: 'device' as const } : {};
+  if (reason !== 'unknown') return { reason, ...slice };
+  const refined = classifyIncidentReasonFromLastLines(lines);
+  return refined ? { reason: refined, recordedReason: reason, reasonSource: 'lastLines', ...slice } : { reason, ...slice };
+}
+
 /** Read only recorded exits. Missing ledgers are not evidence that no runs failed. */
 export function readRunExits(root: string): RunExit[] {
   const dir = join(root, 'incidents');
@@ -71,7 +114,8 @@ export function readRunExits(root: string): RunExit[] {
         || !(row.status === null || typeof row.status === 'number')
         || !(row.signal === null || typeof row.signal === 'string')) continue;
       seen.add(row.runId);
-      rows.push({ runId: row.runId, reason: row.reason, status: row.status, signal: row.signal, at: row.at,
+      const lines = Array.isArray(row.lastLines) && row.lastLines.every((line) => typeof line === 'string') ? row.lastLines : undefined;
+      rows.push({ runId: row.runId, ...refinedReasonFields(row.reason, lines), status: row.status, signal: row.signal, at: row.at,
         ...(typeof row.entrance === 'string' ? { entrance: row.entrance } : {}),
         ...(typeof row.seat === 'string' ? { seat: row.seat } : {}),
         ...(typeof row.cwd === 'string' ? { cwd: row.cwd } : {}),
@@ -81,12 +125,19 @@ export function readRunExits(root: string): RunExit[] {
           ? { lastLines: row.lastLines } : {}),
         ...(row.childEvidence && typeof row.childEvidence === 'object' && !Array.isArray(row.childEvidence)
           ? { childEvidence: row.childEvidence } : {}),
+        ...podTerminationField(row.podTermination),
       });
     }
   }
   return rows.sort((a, b) => Date.parse(a.at) - Date.parse(b.at) || a.runId.localeCompare(b.runId));
 }
 
+function podTerminationField(value: unknown): { podTermination?: PodTermination } {
+  const job = value && typeof value === 'object' && !Array.isArray(value) ? (value as Record<string, unknown>).job : undefined;
+  const parsed = typeof job === 'string' ? parsePodTermination(value, job) : undefined;
+  return parsed ? { podTermination: parsed } : {};
+}
+
 /** SQLite's process-owned write lock serializes ledger checks and appends across processes. */
 export function recordRunExit(row: RunExit, root: string): void {
   if (refuseProductionLedgerWriteInTest(root, 'incidents')) return;

package/src/harness/pod-control-send.ts

@@ -2,6 +2,14 @@ import { encodeControlMemoFrame, type ControlMemoPayload } from './control-inbox
 import type { PodFragmentRecord } from './self-send-target.js';
 import { defaultKubectl, type Kubectl } from '../task-orchestrator/surfaces/self-implement-pod.js';
 
+const POD_CONTROL_KUBECTL_TIMEOUT_MS = 120_000;
+
+export function parsePodReadWait(value: string | number): number {
+  const parsed = typeof value === 'string' && !value.trim() ? Number.NaN : Number(value);
+  if (!Number.isFinite(parsed) || parsed < 0 || parsed > 60) throw new Error('self send --read-wait는 0~60초의 유한한 값이어야 합니다');
+  return Math.floor(parsed);
+}
+
 const PUBLISH = `set -eu
 inbox="$1"
 kind="$2"
@@ -9,9 +17,24 @@ IFS= read -r line
 mkdir -p "\${inbox}.ready"
 if [ "$kind" = memo ]; then
   temp=$(mktemp "\${inbox}.ready/.write-XXXXXXXX")
-  trap 'rm -f "$temp"' EXIT
+  record=''
+  cleanup_memo() {
+    rm -f "$temp"
+    if [ -n "$record" ]; then rm -f "$record.ack-request" "$record.ack"; fi
+  }
+  trap 'cleanup_memo' EXIT
+  trap 'exit 129' HUP
+  trap 'exit 130' INT
+  trap 'exit 143' TERM
   printf 'memo:%s\\n' "$line" > "$temp"
-  mv "$temp" "\${inbox}.ready/record-$(printf '%016x' "$(date +%s%3N)")-$(cat /proc/sys/kernel/random/uuid)"
+  record="\${inbox}.ready/record-$(printf '%016x' "$(date +%s%3N)")-$(cat /proc/sys/kernel/random/uuid)"
+  : > "$record.ack-request"
+  mv "$temp" "$record"
+  printf 'ELANOUS_POD_MEMO_PUBLISHED %s\\n' "\${record##*/}"
+  count=0
+  while [ ! -e "$record.ack" ] && [ "$count" -lt "$3" ]; do sleep 1; count=$((count + 1)); done
+  if [ -e "$record.ack" ]; then printf 'ELANOUS_POD_MEMO_READ %s\\n' "\${record##*/}"
+  else printf 'ELANOUS_POD_MEMO_UNVERIFIED %s\\n' "\${record##*/}"; fi
 else
   temp=$(mktemp "\${inbox}.ready/.write-XXXXXXXX")
   trap 'rm -f "$temp"' EXIT
@@ -25,13 +48,18 @@ else
 fi`;
 
 /** Publish a control-inbox record inside the child container, not on the host. */
-export function sendPodControl(record: PodFragmentRecord, message: { stop: true } | { memo: ControlMemoPayload }, kubectl: Kubectl = defaultKubectl): void {
+export function sendPodControl(record: PodFragmentRecord, message: { stop: true } | { memo: ControlMemoPayload }, kubectl: Kubectl = defaultKubectl,
+  readWaitSeconds = 0): { memoRecord?: string; read?: boolean } {
   const stop = 'stop' in message;
   const input = stop ? 'stop\n' : `${encodeControlMemoFrame(message.memo)}\n`;
   const result = kubectl([
     ...(record.context ? ['--context', record.context] : []), '-n', record.namespace,
     'exec', '-i', `job/${record.job}`, '-c', 'child', '--',
-    'sh', '-c', PUBLISH, 'pod-control', record.inboxDir, stop ? 'stop' : 'memo',
-  ], input);
+    'sh', '-c', PUBLISH, 'pod-control', record.inboxDir, stop ? 'stop' : 'memo', String(parsePodReadWait(readWaitSeconds)),
+  ], input, POD_CONTROL_KUBECTL_TIMEOUT_MS);
   if (result.status !== 0) throw new Error(`Pod ${record.job} control send 실패: ${result.stderr.trim() || 'kubectl exec failed'}`);
+  if (stop) return {};
+  const published = /^ELANOUS_POD_MEMO_PUBLISHED (record-[0-9a-f-]+)$/m.exec(result.stdout)?.[1];
+  if (!published) return {};
+  return { memoRecord: published, read: result.stdout.includes(`ELANOUS_POD_MEMO_READ ${published}`) };
 }