elanous 0.2.36 → 0.2.37

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

@@ -51,6 +51,16 @@ export interface ShardRunMode {
   fixedDistribution?: boolean;
   /** Measured on the executing host; override only for deterministic planning tests. */
   hostResources?: { cores: number; freeMemoryGiB: number; freeTmpGiB: number };
+  /** Observation after each bundle's first current+baseline attempt; never controls retries or verdict. */
+  onShardComplete?: (progress: ShardRunProgress) => void;
+}
+
+export interface ShardRunProgress {
+  shardId: string;
+  completedShards: number;
+  totalShards: number;
+  completedFiles: number;
+  totalFiles: number;
 }
 
 function hostResources(): ShardRunMode['hostResources'] | undefined {
@@ -162,7 +172,7 @@ export function runShardedGateTests(
     try { fixed = planFixedGateTestShards(files, count); }
     catch (error) { return { aggregate: { status: 'unmeasured', retryShardIds: [] }, shards: [], attempts: [], reason: String(error), distribution: 'fixed' }; }
     debug.log('self-dev.shard', 'fixed-distribution', { shards: fixed.length, files: fixed.reduce((sum, shard) => sum + shard.files.length, 0) });
-    return { ...runPlannedShards(cwd, fixed, baseRef, run, baselineWorktree), distribution: 'fixed' };
+    return { ...runPlannedShards(cwd, fixed, baseRef, run, baselineWorktree, mode.onShardComplete), distribution: 'fixed' };
   }
   const rss = new Map<string, number>();
   const seconds = new Map<string, number>();
@@ -199,7 +209,7 @@ export function runShardedGateTests(
       const fixed = planFixedGateTestShards(files, maxCount);
       debug.log('self-dev.shard', 'host-cap-fixed-fallback', { requested: count, cap: maxCount,
         files: new Set(files).size, reason, measurementFailures: measurementFailures ?? 0 });
-      return { ...runPlannedShards(cwd, fixed, baseRef, run, baselineWorktree), distribution: 'fixed-cap-fallback',
+      return { ...runPlannedShards(cwd, fixed, baseRef, run, baselineWorktree, mode.onShardComplete), distribution: 'fixed-cap-fallback',
         fallbackReason: reason, ...(measurementFailures ? { measurementFailures } : {}) };
     } catch (error) {
       return { aggregate: { status: 'unmeasured', retryShardIds: [] }, shards: [], attempts: [],
@@ -232,7 +242,7 @@ export function runShardedGateTests(
     requested: count, planned: shards.length, files: new Set(files).size, budgetGiB,
     measurementFailures: measurementFailures ?? 0,
   });
-  return { ...runPlannedShards(cwd, shards, baseRef, run, baselineWorktree), ...(plannedCount > count ? { expandedFrom: count } : {}), ...(measurementFailures ? { measurementFailures } : {}) };
+  return { ...runPlannedShards(cwd, shards, baseRef, run, baselineWorktree, mode.onShardComplete), ...(plannedCount > count ? { expandedFrom: count } : {}), ...(measurementFailures ? { measurementFailures } : {}) };
 }
 
 /** Shared by the measured and the fixed planner: current + baseline per shard, one retry round, one aggregate. */
@@ -242,6 +252,7 @@ function runPlannedShards(
   baseRef: string,
   run: ShardProcess,
   baselineWorktree: typeof withBaselineWorktree,
+  onShardComplete?: ShardRunMode['onShardComplete'],
 ): ShardRunResult {
   const attempts: GateShardAttempt[] = [];
   const failureEvidence: ShardFailureEvidence[] = [];
@@ -256,6 +267,8 @@ function runPlannedShards(
     const treeReadable = (() => { try { return statSync(dir).isDirectory(); } catch { return false; } })();
     const atBase = (shard: GateTestShard) => treeReadable ? shard.files.filter((file) => !absentAtBaseline(join(dir, file))) : [...shard.files];
     let pending = shards;
+    let completedFiles = 0;
+    const totalFiles = new Set(shards.flatMap((shard) => shard.files)).size;
     for (let round = 1; round <= 2 && pending.length; round++) {
       for (const shard of pending) {
         const runSafely = (location: string, selected: readonly string[]): ReturnType<ShardProcess> => {
@@ -279,6 +292,13 @@ function runPlannedShards(
           baselineFiles,
           currentRoot: cwd, baselineRoot: dir,
         });
+        if (round === 1 && onShardComplete) {
+          completedFiles += shard.files.length;
+          try {
+            onShardComplete({ shardId: shard.id, completedShards: attempts.length,
+              totalShards: shards.length, completedFiles, totalFiles });
+          } catch { /* progress is observation only */ }
+        }
       }
       const retry = new Set(aggregateGateTestShards(shards, attempts).retryShardIds);
       pending = shards.filter((shard) => retry.has(shard.id));
@@ -360,3 +380,30 @@ export function runBunShardWithSpawn(cwd: string, files: readonly string[], spaw
     rmSync(dir, { recursive: true, force: true });
   }
 }
+
+/** GATE-REMOTE-SHARD-PLAN — identity of one remote shard. files/introducedFiles are optional: a caller that only relays
+ *  identity (CLI wiring) passes none, while a planner-produced shard carries its file-level attribution. */
+export interface RemoteShardSpec {
+  orchestrationId: string;
+  shardId: string;
+  totalShards: number;
+  position: number;
+  files?: readonly string[];
+  introducedFiles?: readonly string[];
+}
+
+/** The identity slice that rides a remote gate command line — validated so a dropped flag fails loudly, not silently. */
+export function remoteShardArgArgs(shard: RemoteShardSpec, options?: { planFile?: string }): string[] {
+  if (!shard.orchestrationId.trim()) throw new Error('orchestration id must be non-empty');
+  if (!shard.shardId.trim()) throw new Error('shard id must be non-empty');
+  if (!Number.isSafeInteger(shard.totalShards) || shard.totalShards < 1) throw new Error('shard total must be a positive integer');
+  if (!Number.isSafeInteger(shard.position) || shard.position < 1) throw new Error('shard position must be a positive integer');
+  const args = ['--orchestration-id', shard.orchestrationId, '--shard-id', shard.shardId, '--shard-position', String(shard.position)];
+  if (options?.planFile !== undefined && options.planFile !== '') args.push('--shard-plan', options.planFile);
+  return args;
+}
+
+/** Full remote command for one shard — the exact argv a remote host (e.g. an node-b pod shard) would run. */
+export function remoteShardArgv(shard: RemoteShardSpec, options?: { planFile?: string }): string[] {
+  return ['bun', 'bin/elanous.mjs', '--test', 'self', 'gate', '--changed', '--shards', String(shard.totalShards), ...remoteShardArgArgs(shard, options)];
+}

package/src/self-implement/doctor-visit.ts

@@ -1,4 +1,7 @@
+import { spawnSync } from 'node:child_process';
+import { SPAWN_SYNC_MAX_BUFFER } from '../util/spawn-sync-output.js';
 import { debug } from '../debug/log.js';
+import { loadReviewRoundBrief, type ReviewRoundBrief } from './review-round-brief.js';
 import { findIncidentPrecedents, type IncidentPrecedent } from '../harness/harness-incidents.js';
 import { elanousStateRoot } from '../autopilot/state-paths.js';
 import {
@@ -16,6 +19,42 @@ export function doctorVisitIncidentRoot(): string {
   return elanousStateRoot();
 }
 
+export interface DoctorReviewPrMetadata { headRefOid: string; body: string; files: string[]; comments?: Array<{ body: string; author: string }> }
+
+/** Fetch only the metadata needed to anchor a saved review to the current PR head. */
+export function readDoctorReviewPr(pr: number): DoctorReviewPrMetadata {
+  const result = spawnSync('gh', ['pr', 'view', String(pr), '--json', 'headRefOid,body,files,author,comments'], {
+    encoding: 'utf8', timeout: 30_000, maxBuffer: SPAWN_SYNC_MAX_BUFFER, stdio: ['ignore', 'pipe', 'pipe'],
+  });
+  if (result.error || result.status !== 0) throw new Error(`PR #${pr} unavailable: ${result.error?.message ?? result.stderr?.trim() ?? 'gh failed'}`);
+  const data = JSON.parse(result.stdout) as { headRefOid?: unknown; body?: unknown; files?: unknown; author?: { login?: unknown }; comments?: unknown };
+  if (typeof data.headRefOid !== 'string' || !/^[a-f0-9]{40}$/i.test(data.headRefOid)) throw new Error('PR headRefOid is missing or invalid');
+  return {
+    headRefOid: data.headRefOid,
+    body: typeof data.body === 'string' ? data.body : '',
+    files: Array.isArray(data.files) ? data.files.flatMap((file: unknown) => {
+      if (typeof file === 'string') return [file];
+      if (file && typeof file === 'object' && typeof (file as { path?: unknown }).path === 'string') return [(file as { path: string }).path];
+      return [];
+    }) : [],
+    comments: typeof data.author?.login === 'string' && Array.isArray(data.comments) ? data.comments.flatMap((comment: unknown) => {
+      if (!comment || typeof comment !== 'object') return [];
+      const item = comment as { body?: unknown; author?: { login?: unknown } };
+      const login = item.author?.login;
+      return typeof item.body === 'string' && typeof login === 'string' && login === data.author?.login
+        ? [{ body: item.body, author: login }] : [];
+    }) : [],
+  };
+}
+
+/** Doctor's saved-review view; never records a run-ledger visit for a PR. */
+export function readDoctorReviewBrief(pr: number, read: (pr: number) => DoctorReviewPrMetadata = readDoctorReviewPr, reviewResultsDir?: string): ReviewRoundBrief {
+  if (!Number.isSafeInteger(pr) || pr <= 0) throw new Error('PR number must be a positive integer');
+  const metadata = read(pr);
+  return loadReviewRoundBrief({ pr, head: metadata.headRefOid, body: metadata.body, changedFiles: metadata.files, comments: metadata.comments?.map((comment) => comment.body),
+    ...(reviewResultsDir ? { reviewResultsDir } : {}) });
+}
+
 /** DOCTOR-VISIT 증상 닫힌 목록 — 이 밖의 값은 기록·조회 모두 거부한다. */
 export const DOCTOR_SYMPTOMS = [
   'admit-starved',
@@ -180,8 +219,52 @@ export function recordTaskAgentNeedsOwnerVisit(input: {
   return { status: outcome.result ?? 'missing-ledger' };
 }
 
+/** A parent stop that needs an owner records one shadow visit per stop, without running a prescription. */
+export function recordParentNeedsOwnerVisit(input: {
+  runId: string;
+  stopKey: string;
+  evidence: string;
+  dir?: string;
+}): { status: 'missing-ledger' | 'recorded' | 'already-recorded' } {
+  const outcome = appendRunLedgerEntryChecked(input.runId, (entries) => {
+    if (entries === null) return { append: false, result: 'missing-ledger' as const };
+    if (entries.some((entry) => entry.event === 'doctor-visit' && entry.data.from === 'parent'
+      && entry.data.symptom === 'needs-owner' && entry.data.stopKey === input.stopKey)) {
+      return { append: false, result: 'already-recorded' as const };
+    }
+    return { append: true, entry: {
+      runId: input.runId,
+      timestamp: new Date().toISOString(),
+      event: 'doctor-visit',
+      data: { from: 'parent', symptom: 'needs-owner', stopKey: input.stopKey, evidence: input.evidence },
+    } };
+  }, input.dir);
+  if (outcome.appended) {
+    debug.log('run-doctor', 'visit', { runId: input.runId, from: 'parent', symptom: 'needs-owner', stopKey: input.stopKey });
+    return { status: 'recorded' };
+  }
+  if (outcome.result === null) throw new Error(`run-ledger-write-refused: ${input.runId}`);
+  return { status: outcome.result };
+}
+
 export type ReadDoctorVisitsOptions = RunLedgerLookupOptions;
 
+/** Project logged review briefs into status without changing the run-ledger schema. Keep the latest observation per PR. */
+export function doctorReviewVisits(events: readonly { timestamp?: string; sequence?: number; runId?: string; key?: string; evidence?: string }[]): (Omit<DoctorVisit, 'runId'> & { runId?: string })[] {
+  const seenPrs = new Set<string>();
+  return [...events].sort((left, right) => {
+    const leftAt = left.timestamp ? Date.parse(left.timestamp) : 0;
+    const rightAt = right.timestamp ? Date.parse(right.timestamp) : 0;
+    return rightAt - leftAt || (right.sequence ?? 0) - (left.sequence ?? 0) || String(right.key ?? '').localeCompare(String(left.key ?? ''));
+  }).flatMap((event) => {
+    const pr = /^(\d+)(?::|$)/.exec(event.key ?? '')?.[1];
+    if (pr && seenPrs.has(pr)) return [];
+    if (pr) seenPrs.add(pr);
+    return [{ ...(event.runId ? { runId: event.runId } : {}), from: 'seat' as const, symptom: 'review-loop' as const,
+      ...(event.evidence ? { evidence: event.evidence } : {}), ...(event.timestamp ? { timestamp: event.timestamp } : {}) }];
+  });
+}
+
 /** `runId` 원장이 조회 범위 안에 있는가 — `doctor status --run` 이 없는 런을 «0건»으로 삼키지 않게 한다. */
 export function doctorVisitRunExists(runId: string, options: ReadDoctorVisitsOptions = {}): boolean {
   return lookupRunLedger(runId, options).matches.length > 0;

package/src/self-implement/gate-artifacts.ts

@@ -85,6 +85,7 @@ export interface GateArtifactSummary extends GateArtifactCounts {
   verdict: string | null;
   /** 판정 줄(`tests: …` / `[gate-baseline] …` / `shards: unmeasured (…)`) 그대로. */
   verdictLine?: string;
+  timeoutRechecks?: readonly { name: string; file: string; result: 'pass' | 'timeout' | 'failure' | 'unknown'; elapsedMs: number; rawResultLine: string }[];
   exitCode: number;
   /** 정수 칸 중 하나라도 null 일 때만 — 왜 못 셌나(한 줄). */
   countsUnavailableReason?: string;
@@ -129,6 +130,7 @@ export interface GateArtifactInput {
   testFiles: readonly string[];
   verdict: string | null;
   verdictLine?: string;
+  timeoutRechecks?: readonly { name: string; file: string; result: 'pass' | 'timeout' | 'failure' | 'unknown'; elapsedMs: number; rawResultLine: string }[];
   exitCode: number;
   /** 판정 정수(못 센 칸은 null ⊕ countsUnavailableReason). 안 주면 다섯 다 null · 이유 'not recorded' — 칸은 «늘» 쓴다. */
   counts?: GateArtifactCounts;
@@ -219,6 +221,7 @@ export function writeGateArtifacts(input: GateArtifactInput): { summaryPath: str
     shardsDetail,
     verdict: input.verdict,
     ...(input.verdictLine !== undefined ? { verdictLine: input.verdictLine } : {}),
+    ...(input.timeoutRechecks ? { timeoutRechecks: input.timeoutRechecks } : {}),
     exitCode: input.exitCode,
     introduced: counts.introduced,
     preexisting: counts.preexisting,
@@ -388,8 +391,9 @@ export function importRemoteGateArtifacts(dir: string, files: Map<string, Buffer
     writeFileSync(run.resultPath, `${JSON.stringify(result, null, 2)}\n`);
   };
   for (const shard of summary.shardsDetail) { relocate(shard?.current); relocate(shard?.baseline); }
-  // OP FU (MK #8178) — 원격 조각의 실패 증거(`<shardId>.failure.json`)도 그대로 가져온다(관측만 · summary 는 안 고친다).
-  for (const [name, bytes] of files) if (name.endsWith('.failure.json') && artifactNamePattern.test(name)) writeFileSync(join(dir, name), bytes);
+  // Optional observations stay optional for older remote commits. Neither changes the gate verdict.
+  for (const [name, bytes] of files) if ((name === 'progress.json' || name.endsWith('.failure.json'))
+    && artifactNamePattern.test(name)) writeFileSync(join(dir, name), bytes);
   summary.remoteHost = host;
   writeFileSync(summaryPath, `${JSON.stringify(summary, null, 2)}\n`);
   return { summaryPath, junitFiles };

package/src/self-implement/gate-baseline.ts

@@ -9,7 +9,7 @@ import type { GitRunResult } from '../git-fs/retry.js';
 import { linkWorktreeDependencies, worktreeAddTimeoutForRepo } from '../git-fs/worktree.js';
 import { reapStaleGateWorktrees } from './gate-baseline-reap.js';
 
-export type GateFailureAttribution = 'introduced' | 'preexisting' | 'unknown' | 'precondition-unmet' | 'flaky-timeout' | 'flaky-rerun';
+export type GateFailureAttribution = 'introduced' | 'preexisting' | 'unknown' | 'precondition-unmet' | 'flaky-timeout' | 'flaky-rerun' | 'timeout-recheck-passed';
 export type GateBaselinePresence = 'present' | 'missing' | 'unknown';
 export type TimeoutVariability = 'may-vary' | 'same' | 'unknown';
 
@@ -72,6 +72,16 @@ export interface GateBaselineReport extends GateBaselineSummary {
   files: string[];
   baselineStatus: BaselineProcessStatus;
   log: string;
+  timeoutRechecks?: TimeoutRecheckRecord[];
+  timeoutRecheckPassed?: number;
+}
+
+export interface TimeoutRecheckRecord {
+  name: string;
+  file: string;
+  result: 'pass' | 'timeout' | 'failure' | 'unknown';
+  elapsedMs: number;
+  rawResultLine: string;
 }
 
 interface GateTestCountChange {
@@ -697,6 +707,9 @@ function summarizeGateBaseline(failures: readonly GateTestFailure[]): GateBaseli
       if (failure.attribution === 'flaky-rerun') {
         return { ...withPresence, flakyRerun: withPresence.flakyRerun + 1 };
       }
+      if (failure.attribution === 'timeout-recheck-passed') {
+        return withPresence;
+      }
       const withTimeoutRegression = failure.timeoutRegression === 'passed-at-base'
         ? { ...withPresence, timeoutPassedAtBase: withPresence.timeoutPassedAtBase + 1 }
         : withPresence;
@@ -722,6 +735,51 @@ export function rerunBunSingleTest(cwd: string, file: string, testName: string,
   return classifyBunSingleTestRerun(result);
 }
 
+/** A standalone timeout-only retry is allowed only when every introduced failure is explicitly a Bun timeout. */
+export function recheckTimeoutOnlyIntroducedFailures(
+  cwd: string,
+  report: GateBaselineReport,
+  run: (cwd: string, file: string, name: string, timeoutMs: number) => { observation?: TimeoutRerunObservation; elapsedMs: number; output: string } = runTimeoutRecheck,
+): GateBaselineReport {
+  const eligible = report.failures.length > 0
+    && report.introduced === report.failures.length
+    && report.failures.every((failure) => failure.attribution === 'introduced' && !!failure.file
+      && /\bthis test timed out after \d+ms\b/i.test(failure.diagnostic ?? ''));
+  if (!eligible) return report;
+  const records: TimeoutRecheckRecord[] = [];
+  const failures = report.failures.map((failure) => {
+    if (!failure.file) return failure;
+    const prefix = `${failure.file} > `;
+    const name = failure.name.startsWith(prefix) ? failure.name.slice(prefix.length) : failure.name;
+    const { observation, elapsedMs, output } = run(cwd, failure.file, name, 60_000);
+    const result = observation ?? 'unknown';
+    const record: TimeoutRecheckRecord = {
+      name: failure.name, file: failure.file, result, elapsedMs,
+      rawResultLine: flattenControlChars(redactSecretText(output)).slice(-500),
+    };
+    records.push(record);
+    debug.log('gate.baseline', 'timeout-recheck', record);
+    return result === 'pass' ? { ...failure, attribution: 'timeout-recheck-passed' as const } : failure;
+  });
+  return {
+    ...report,
+    ...summarizeGateBaseline(failures),
+    failures,
+    timeoutRechecks: records,
+    timeoutRecheckPassed: failures.filter((failure) => failure.attribution === 'timeout-recheck-passed').length,
+  };
+}
+
+function runTimeoutRecheck(cwd: string, file: string, name: string, timeoutMs: number): { observation?: TimeoutRerunObservation; elapsedMs: number; output: string } {
+  const started = Date.now();
+  const result = runIsolatedBunTest(cwd, ['--timeout', String(timeoutMs), '--test-name-pattern', buildBunSingleTestPattern(name), file], timeoutMs + 10_000);
+  return {
+    observation: classifyBunSingleTestRerun(result),
+    elapsedMs: Date.now() - started,
+    output: `${String(result.stdout ?? '')}\n${String(result.stderr ?? '')}`,
+  };
+}
+
 /** `introduced` 재실행 상한. 초과분은 돌리지 않고 보고서에 남긴다. 부하로 건너뛰지 않는다. */
 export const INTRODUCED_RERUN_CAP = 8;
 
@@ -1512,6 +1570,7 @@ export function formatGateBaselineNote(report: GateBaselineReport, unrunImporter
     + `, unknown=${report.unknown}, precondition-unmet=${report.preconditionUnmet}`
     + (report.timedOut > 0 ? `, timed-out=${report.timedOut}` : '')
     + (report.flakyRerun > 0 ? `, flaky-rerun=${report.flakyRerun}` : '')
+    + ((report.timeoutRecheckPassed ?? 0) > 0 ? `, timeout-recheck-passed=${report.timeoutRecheckPassed}` : '')
     + (runId ? `, run=${runId}` : '')
     + (report.missingAtBase > 0 ? `, missing-at-base=${report.missingAtBase}` : '');
   const lines = report.failures.map((failure) => `- ${failure.attribution}: ${failure.name}`
@@ -1532,10 +1591,14 @@ export function formatGateBaselineNote(report: GateBaselineReport, unrunImporter
     : report.rerunNotRun > 0
       ? `\n[gate-baseline] rerun not-run=${report.rerunNotRun}`
       : '';
+  const timeoutRecheckLines = report.timeoutRechecks?.length
+    ? `\n[gate.baseline.timeout-recheck] ${report.timeoutRechecks.map((item) => `${item.name}: ${item.result} elapsed=${item.elapsedMs}ms · ${item.rawResultLine}`).join('\n')}`
+    : '';
   return `${head}\n${lines.join('\n')}\n${report.log}`
     + timedOutLine
     + mayVaryNonTimeoutLine
     + rerunLine
+    + timeoutRecheckLines
     + (report.preexisting > 0 ? '\n⚠️ preexisting 실패는 base에서도 재현됨 — 이 PR의 책임이 아니다.' : '');
 }
 

package/src/self-implement/gate-cli.ts

@@ -1,4 +1,5 @@
-import { existsSync, lstatSync, mkdtempSync, readFileSync, realpathSync } from 'node:fs';
+import { existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
 import { tmpdir } from 'node:os';
 import { spawnSync } from 'node:child_process';
 import { join } from 'node:path/posix';
@@ -12,7 +13,7 @@ import { runIosUnitTestGate } from '../../scripts/ci-ios-unit-tests.js';
 import { runPwaBuildGate } from '../../scripts/ci-pwa-build-gate.js';
 import { runMockModuleRestoreGate } from '../../scripts/ci-mock-module-restore-gate.js';
 import { parseReviewDepthFromFilesJson } from '../agent-mission/review-depth.js';
-import { buildGateBaselineReport, calculateGateTestCountChange, formatGateBaselineNote, formatGateTestCountNote, isGateTestFile, runGateBaseline, type BaselineProcessResult, type BaselineProcessStatus, type GateTestFailure } from './gate-baseline.js';
+import { buildGateBaselineReport, calculateGateTestCountChange, formatGateBaselineNote, formatGateTestCountNote, isGateTestFile, recheckTimeoutOnlyIntroducedFailures, runGateBaseline, type BaselineProcessResult, type BaselineProcessStatus, type GateTestFailure, type TimeoutRecheckRecord, type TimeoutRerunObservation } from './gate-baseline.js';
 import { resolveGateScope } from './gate-scope.js';
 import { publicExposureFiles, runExposeGate } from './expose-gate.js';
 import { getUserConfig } from '../user-config.js';
@@ -26,7 +27,8 @@ import {
   overlapWithCurrentChanges,
 } from '../cli/pr-granularity.js';
 import { listWorktrees } from '../git-fs/worktree.js';
-import { runShardedGateTests, writeShardFailureEvidence } from '../self-dev/shard-run.js';
+import { runShardedGateTests, writeShardFailureEvidence, remoteShardArgv, type ShardRunProgress } from '../self-dev/shard-run.js';
+import { planGateRemoteShards, shardPlanOrchestrationId, type GateRemoteShard } from '../self-dev/shard-plan.js';
 import { parseGateScenario, readGateScenarioFile } from './gate-scenario.js';
 import { isGateSpawnLaneFile } from '../self-dev/spawn-lane-files.js';
 import { defaultGateEnvKey, defaultRevResolver, resolveArtifactDir, writeGateArtifacts, type GateArtifactCounts, type GateArtifactsUnavailable, type RevResolver } from './gate-artifacts.js';
@@ -99,7 +101,11 @@ interface SelfGateCliDeps {
   readFile?: (path: string) => string | undefined;
   runTests?: (cwd: string, files: readonly string[]) => ProcessResult;
   runBaseline?: (cwd: string, files: readonly string[], baseRef: string) => BaselineProcessResult;
+  runTimeoutRecheck?: (cwd: string, file: string, name: string, timeoutMs: number) => { observation?: TimeoutRerunObservation; elapsedMs: number; output: string };
   runShards?: typeof runShardedGateTests;
+  /** Test seam for the live progress line. */
+  writeProgressStderr?: (line: string) => void;
+  now?: () => number;
   runIsolationGate?: (out: GateOutput) => number;
   runMockModuleRestoreGate?: (out: GateOutput) => number;
   /** 모델 이름 하드코딩 래칫(🅕 #20521) — `pr land` 만 물고 하니스 무인 병합은 안 물면 위반이 main 에 들어가 남의 착지를 막는다(🅣 2026-09-25). */
@@ -131,6 +137,7 @@ interface GateArtifactCapture {
   /** `unrun importer tests: N` 의 N — 색인 조회 실패면 null(그 이유가 importerLookupFailed). */
   unrunImporters?: number | null;
   importerLookupFailed?: string;
+  timeoutRechecks?: readonly TimeoutRecheckRecord[];
 }
 
 /** SIDE-VERIFY ③ — summary 정수 칸: 게이트가 이미 낸 `result.baseline` ⊕ `unrunImporterTotal` 을 «옮기기만» 한다.
@@ -388,7 +395,9 @@ export function observePrFileOverlap(
       return { ok: false as const, out: '', err: error instanceof Error ? error.message : String(error) };
     }
   };
-  const commits = collectBaseLandingCommits(run, cwd, { since: '0', baseRef: `${baseOid}..${baseRefName}` });
+  // The resolved base range is the complete scope; a time cutoff can hide a
+  // just-created commit when a gate shard is slow.
+  const commits = collectBaseLandingCommits(run, cwd, { since: null, baseRef: `${baseOid}..${baseRefName}` });
   if (commits === null) return { status: 'unavailable', reason: 'git log failed' };
   const overlaps = overlapWithCurrentChanges(commits, files);
   return overlaps.length > 0
@@ -588,6 +597,24 @@ export function formatUnrunImporterTests(importerTestsNotRun: NonNullable<Return
   return `unrun importer tests: ${importerTestsNotRun.total}${files}; unresolved relative specifiers: ${importerTestsNotRun.unresolvedRelativeSpecifiers}`;
 }
 
+/** gate 출력 한 줄에 실리는 미등재 spawn-lane 시험의 최대 표시 수 — 실측 드리프트(57건)를 전부 나열하면
+ *  «읽히지 않는 소음»이 된다(`formatUnrunImporterTests` 의 잘림 정책과 같은 취지). */
+const UNLISTED_SPAWN_LANE_DISPLAY_LIMIT = 10;
+
+/** ⛔⭐ 소비자 배선(무인 리뷰 must-fix) — `resolveGateScope` 이 채우는 `runtimeEdgeImpact` 를 읽는 곳이
+ *  없으면 그 측정은 어디에도 드러나지 않는다. 정책은 형제들과 같다 — ***「보고한다. 막지 않는다.」***
+ *  손으로 관리하는 `GATE_SPAWN_LANE_FILES` 가 실측에서 빠뜨린 spawn-lane 시험을 알린다. */
+export function formatUnlistedSpawnLaneTests(impact: ReturnType<typeof resolveGateScope>['runtimeEdgeImpact']): string {
+  if (!impact) return 'unlisted spawn-lane tests: (not measured — no importer index)';
+  if (!impact.measured) return 'unlisted spawn-lane tests: (not measured)';
+  const total = impact.unlistedSpawnLaneTests.length;
+  if (total === 0) return 'unlisted spawn-lane tests: 0';
+  const shown = impact.unlistedSpawnLaneTests.slice(0, UNLISTED_SPAWN_LANE_DISPLAY_LIMIT);
+  const truncated = total > shown.length ? `, showing ${shown.length}/${total}` : '';
+  return `unlisted spawn-lane tests: ${total} (${shown.join(', ')}${truncated})`
+    + '  ⚠️ GATE_SPAWN_LANE_FILES 가 빠뜨린 실측 spawn-lane 시험 — 「보고만 한다. 막지 않는다.」';
+}
+
 export function formatPartialObservationNote(unrunImporterTotal: number, note: string): string {
   if (unrunImporterTotal <= 0) return note;
   return `partial observation: ${unrunImporterTotal} unrun importer tests; ${note}`;
@@ -756,6 +783,7 @@ function emitGateArtifacts(cwd: string, artifactDir: string, result: SelfGateCli
       testFiles: capture.testFiles ?? result.testFiles,
       verdict: capture.verdict ?? null,
       ...(capture.verdictLine !== undefined ? { verdictLine: capture.verdictLine } : {}),
+      ...(capture.timeoutRechecks ? { timeoutRechecks: capture.timeoutRechecks } : {}),
       exitCode: result.exitCode,
       counts: counts.counts,
       ...(counts.reason !== undefined ? { countsUnavailableReason: counts.reason } : {}),
@@ -770,6 +798,31 @@ function emitGateArtifacts(cwd: string, artifactDir: string, result: SelfGateCli
   }
 }
 
+/** A completed bundle is observed immediately, before the synchronous runner returns. Each sink is best effort. */
+function shardProgressObserver(cwd: string, options: SelfGateCliOptions, deps: SelfGateCliDeps): (progress: ShardRunProgress) => void {
+  const now = deps.now ?? Date.now;
+  const startedAt = now();
+  return (progress) => {
+    const elapsedMs = Math.max(0, now() - startedAt);
+    const estimatedRemainingMs = progress.completedShards > 0
+      ? Math.round(elapsedMs * (progress.totalShards - progress.completedShards) / progress.completedShards) : null;
+    const snapshot = { ...progress, elapsedMs, estimatedRemainingMs };
+    const line = `gate shard progress: bundles ${progress.completedShards}/${progress.totalShards} · files ${progress.completedFiles}/${progress.totalFiles} · elapsed ${Math.round(elapsedMs / 1000)}s · remaining ~${estimatedRemainingMs === null ? '?' : Math.round(estimatedRemainingMs / 1000) + 's'}\n`;
+    try { (deps.writeProgressStderr ?? ((value) => { process.stderr.write(value); }))(line); } catch { /* observation only */ }
+    try { debug.log('gate.cli', 'shard-progress', snapshot); } catch { /* observation only */ }
+    if (!options.artifactDir?.trim()) return;
+    let temporary: string | undefined;
+    try {
+      const dir = resolveArtifactDir(options.artifactDir, cwd);
+      mkdirSync(dir, { recursive: true });
+      temporary = join(dir, `.progress.${process.pid}.${randomUUID()}.tmp`);
+      writeFileSync(temporary, `${JSON.stringify(snapshot, null, 2)}\n`);
+      renameSync(temporary, join(dir, 'progress.json'));
+    } catch { /* artifact failure must not affect the gate verdict */ }
+    finally { if (temporary) { try { rmSync(temporary, { force: true }); } catch { /* observation only */ } } }
+  };
+}
+
 function runSelfGateCliCore(cwd: string, options: SelfGateCliOptions, deps: SelfGateCliDeps, capture: GateArtifactCapture): SelfGateCliResult {
   if (options.base && options.pr) throw new Error('use either --base <ref> or --pr <number>, not both');
   if (options.shards !== undefined && (!Number.isSafeInteger(options.shards) || options.shards < 1)) throw new Error('invalid --shards count');
@@ -803,6 +856,9 @@ function runSelfGateCliCore(cwd: string, options: SelfGateCliOptions, deps: Self
     // 🚨 러너 우주 «밖» — 형제들과 같은 정책으로 «말만» 한다(`OBS-T418`).
     formatUnrunnableChangeKinds(selection.files),
     formatUnrunImporterTests(importerTestsNotRun, lookupFailed),
+    // ⛔⭐ 무인 리뷰 must-fix — 죽은 필드 배선: `resolveGateScope` 이 채운 `runtimeEdgeImpact` 을
+    //   실제로 읽어 출력하는 소비자(이 줄이 없으면 그 측정은 어디에도 드러나지 않는다).
+    formatUnlistedSpawnLaneTests(scope.runtimeEdgeImpact),
     `caller tests: ${lookupFailed ? `lookup failed (${lookupFailed})` : scope.callerTests.map(({ file, reasons }) => `${file} (${reasons.join('+')})`).join(', ') || (routeIndex?.lookupFailures.length ? 'route lookup incomplete' : '(none)')}`,
     ...(routeIndex?.lookupFailures.length ? [`⚠️ caller route base lookup failed — unmeasured: ${routeIndex.lookupFailures.map(({ source, reason }) => `${source} (${reason})`).join(', ')}`] : []),
     ...(callerTestsOverflow.length ? [`⚠️ caller test cap exceeded — not run: ${callerTestsOverflow.map(({ file, reasons }) => `${file} (${reasons.join('+')})`).join(', ')}`] : []),
@@ -854,9 +910,10 @@ function runSelfGateCliCore(cwd: string, options: SelfGateCliOptions, deps: Self
     const spawnFileCount = testFiles.filter(isGateSpawnLaneFile).length;
     const shardCount = options.shards ?? (Math.min(3, spawnFileCount) + Number(testFiles.length > spawnFileCount));
     const runShards = deps.runShards ?? runShardedGateTests;
+    const onShardComplete = shardProgressObserver(cwd, options, deps);
     const sharded = options.fixedShardDistribution
-      ? runShards(cwd, testFiles, selection.baseRef, shardCount, undefined, undefined, undefined, { fixedDistribution: true })
-      : runShards(cwd, testFiles, selection.baseRef, shardCount);
+      ? runShards(cwd, testFiles, selection.baseRef, shardCount, undefined, undefined, undefined, { fixedDistribution: true, onShardComplete })
+      : runShards(cwd, testFiles, selection.baseRef, shardCount, undefined, undefined, undefined, { onShardComplete });
     capture.sharded = sharded;
     capture.verdict = sharded.aggregate.status;
     lines.push(`shards: ${sharded.shards.length} (${sharded.shards.map((shard) => `${shard.id}=${shard.files.join(',')}`).join('; ')})${sharded.expandedFrom !== undefined ? ` · RSS 예산상 ${sharded.expandedFrom}→${sharded.shards.length} 자동 확장` : ''}${sharded.measurementFailures ? ` · 측정 실패 ${sharded.measurementFailures}` : ''}${options.fixedShardDistribution ? ' · 고정 분배(사전 측정 없음)' : ''}${sharded.distribution === 'fixed-cap-fallback' ? ` · 호스트 상한 자동 고정 분배(${sharded.fallbackReason})` : ''}`);
@@ -897,7 +954,15 @@ function runSelfGateCliCore(cwd: string, options: SelfGateCliOptions, deps: Self
       capture.unmeasuredReason = unmeasuredReason;
     }
     else if (aggregate.report) {
-      const report = aggregate.report;
+      const report = recheckTimeoutOnlyIntroducedFailures(cwd, aggregate.report, deps.runTimeoutRecheck);
+      capture.timeoutRechecks = report.timeoutRechecks;
+      const timeoutRecheckResolvedFailure = aggregate.status === 'failed'
+        && (report.timeoutRecheckPassed ?? 0) > 0
+        && report.introduced === 0 && report.unknown === 0 && report.preconditionUnmet === 0
+        && report.timedOut === 0 && report.flakyRerun === 0 && report.worktreeFailuresParsed
+        && report.baselineStatus !== 'unknown';
+      const effectiveStatus = timeoutRecheckResolvedFailure ? 'passed' : aggregate.status;
+      capture.verdict = effectiveStatus;
       logGateCliBaseline(cwd, {
         introduced: report.introduced, preexisting: report.preexisting, unknown: report.unknown,
         preconditionUnmet: report.preconditionUnmet, timedOut: report.timedOut,
@@ -914,7 +979,7 @@ function runSelfGateCliCore(cwd: string, options: SelfGateCliOptions, deps: Self
     capture.verdictLine = lines[lines.length - 1];
     const policyPassed = runPolicyGates(selection.files, cwd, lines, deps);
     return {
-      exitCode: aggregate.status !== 'passed' || !policyPassed || !androidPassed || !iosPassed || !pwaPassed || !expose.passed ? 1 : 0,
+      exitCode: capture.verdict !== 'passed' || !policyPassed || !androidPassed || !iosPassed || !pwaPassed || !expose.passed ? 1 : 0,
       lines, changedFiles: selection.files, testFiles, unverified: scope.unverified,
       documentPaths: scope.documentPaths, documentsWithoutDerivedTests: scope.documentsWithoutDerivedTests,
       alwaysIncludeMissing, importerTestsAdded, ...(shardBaseline ? { baseline: shardBaseline } : {}),
@@ -935,7 +1000,8 @@ function runSelfGateCliCore(cwd: string, options: SelfGateCliOptions, deps: Self
 
   if (worktreeLog.includes('deterministic environment setup failed')) lines.push(worktreeLog);
   const baseline = (deps.runBaseline ?? runGateBaseline)(cwd, testFiles, selection.baseRef);
-  const report = buildGateBaselineReport(worktreeLog, baseline);
+  const report = recheckTimeoutOnlyIntroducedFailures(cwd, buildGateBaselineReport(worktreeLog, baseline), deps.runTimeoutRecheck);
+  capture.timeoutRechecks = report.timeoutRechecks;
   logGateCliBaseline(cwd, {
     introduced: report.introduced,
     preexisting: report.preexisting,
@@ -958,3 +1024,21 @@ function runSelfGateCliCore(cwd: string, options: SelfGateCliOptions, deps: Self
   const exitCode = !androidPassed || !iosPassed || !pwaPassed || !policyPassed || !expose.passed || report.introduced > 0 || report.unknown > 0 || report.preconditionUnmet > 0 ? 1 : 0;
   return { exitCode, lines, changedFiles: selection.files, testFiles, unverified: scope.unverified, documentPaths: scope.documentPaths, documentsWithoutDerivedTests: scope.documentsWithoutDerivedTests, alwaysIncludeMissing, importerTestsAdded, baseline: { introduced: report.introduced, preexisting: report.preexisting, unknown: report.unknown, preconditionUnmet: report.preconditionUnmet } };
 }
+
+/** GATE-REMOTE-SHARD-PLAN — a shard plan plus the ready-to-run remote command for each shard. */
+export interface RemoteGateShardPlan {
+  orchestrationId: string;
+  shards: GateRemoteShard[];
+  commands: string[][];
+}
+
+/** Turn a changed-file list into identity-carrying shards and their remote gate commands (shard-plan → shard-run wiring). */
+export function planRemoteGateShardCommands(
+  files: readonly string[],
+  shardCount: number,
+  options?: { planFile?: string; orchestrationId?: string },
+): RemoteGateShardPlan {
+  const orchestrationId = options?.orchestrationId ?? shardPlanOrchestrationId(files);
+  const shards = planGateRemoteShards(files, shardCount, orchestrationId);
+  return { orchestrationId, shards, commands: shards.map((shard) => remoteShardArgv(shard, options)) };
+}

package/src/self-implement/gate-remote.ts

@@ -142,8 +142,9 @@ function hostSlotScriptWithSlot(cap: number, dir: string, tools: readonly SlotLo
   return [
     `GS=${quote(dir)}; mkdir -p "$GS" || infra slots`,
     `${pick}else infra lock-tool; fi`,
+    'load1() { if [ -r /proc/loadavg ]; then awk \'NR==1 {print $1}\' /proc/loadavg; elif command -v sysctl >/dev/null 2>&1; then sysctl -n vm.loadavg 2>/dev/null | awk \'{gsub(/[{}]/, ""); print $1}\'; else echo unknown; fi; }',
     `n=1; while [ $n -le ${n} ]; do $GL "$GS/slot$n" ${passSlot ? 'env GATE_REMOTE_SLOT="$n" ' : ''}sh "$W/run.sh"; s=$?; [ -f "$W/started" ] && exit $s; n=$((n+1)); done`,
-    `echo "${BUSY}=$((n-1))" >&2; exit 98`,
+    `echo "${BUSY}=$((n-1));load1=$(load1)" >&2; exit 98`,
   ];
 }
 
@@ -184,7 +185,7 @@ export const PUSH_TIMEOUT_MS = 10 * 60_000;
 
 export type RemoteRunOutcome =
   | { kind: 'ran'; rc: number; stdout: Buffer; stderr: Buffer; commit: string; host: string; ms: number }
-  | { kind: 'busy'; occupied?: number; rc?: number }
+  | { kind: 'busy'; occupied?: number; load1?: number | null; rc?: number }
   | { kind: 'infra'; reason: string; stage?: string; rc?: number | null; stderr?: string };
 
 export interface RemoteRunOptions {
@@ -349,8 +350,10 @@ export function runOnRemote(opts: RemoteRunOptions, runner: GateRemoteRunner = r
   if (!(run.rc === 0 && marker >= 0)) {
     const last = stderrText.trimEnd().split('\n').at(-1) ?? '';
     if (run.rc === 98) {
-      const busy = /^__GATE_REMOTE_BUSY(?:=(\d+))?$/.exec(last);
-      if (busy) return { kind: 'busy', rc: run.rc, ...(busy[1] !== undefined ? { occupied: Number(busy[1]) } : {}) };
+      const busy = /^__GATE_REMOTE_BUSY(?:=(\d+))?(?:;load1=(unknown|\d+(?:\.\d+)?|))?$/.exec(last);
+      if (busy) return { kind: 'busy', rc: run.rc,
+        ...(busy[1] !== undefined ? { occupied: Number(busy[1]) } : {}),
+        ...(busy[2] !== undefined ? { load1: busy[2] === '' || busy[2] === 'unknown' ? null : Number(busy[2]) } : {}) };
     }
     if (run.rc === 97 && last.startsWith(INFRA)) return { kind: 'infra', stage: last.slice(INFRA.length).trim(), rc: run.rc, stderr: stderrText, reason: `remote-${last.slice(INFRA.length).trim()}` };
   }
@@ -459,6 +462,8 @@ export interface DispatchDeps {
   env?: NodeJS.ProcessEnv;
   sleep?: (ms: number) => Promise<void>;
   now?: () => number;
+  /** Test seam for gate.remote events; production defaults to the structured debug log. */
+  log?: (event: string, data: Record<string, unknown>) => void;
   write?: { out: (data: string | Uint8Array) => void; err: (data: string | Uint8Array) => void };
 }
 
@@ -531,6 +536,9 @@ export async function dispatchHeavyCheck(opts: DispatchOptions, deps: DispatchDe
   const sleep = deps.sleep ?? ((ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms)));
   const now = deps.now ?? Date.now;
   const deadline = now() + settings.slotWaitSeconds * 1000;
+  let waitStartedAt: number | undefined;
+  const logWait = deps.log ?? ((event: string, data: Record<string, unknown>) => debug.log('gate.remote', event, data));
+  let waitedForSlot = false;
   debug.log('gate.remote', 'dispatch', { tool: opts.tool, host, reason: decision.reason });
   let outcome: RemoteRunOutcome;
   for (;;) {
@@ -540,6 +548,14 @@ export async function dispatchHeavyCheck(opts: DispatchOptions, deps: DispatchDe
       outcome = { kind: 'infra', reason: `exception: ${error instanceof Error ? error.message : String(error)}` };
     }
     if (outcome.kind !== 'busy') break;
+    waitedForSlot = true;
+    waitStartedAt ??= now();
+    const waitData = {
+      tool: opts.tool, host, reason: 'host-busy', load1: outcome.load1 ?? null, loadThreshold: settings.loadThreshold,
+      occupied: outcome.occupied ?? null, cap: hostCap, elapsedMs: Math.max(0, now() - waitStartedAt),
+    };
+    logWait('wait-reason', waitData);
+    write.err(`[gate.remote] waiting on ${host} — reason=host-busy load=${outcome.load1 ?? 'unknown'}/${settings.loadThreshold} slots=${outcome.occupied ?? 'unknown'}/${hostCap} elapsed=${Math.floor(waitData.elapsedMs / 1000)}s\n`);
     debug.log('gate.remote', 'host-busy', { tool: opts.tool, host, cap: hostCap, occupied: outcome.occupied ?? null });
     // Never start an attempt past the deadline: an expired self gate wait remains unmeasured.
     const left = deadline - now();
@@ -547,6 +563,14 @@ export async function dispatchHeavyCheck(opts: DispatchOptions, deps: DispatchDe
     await sleep(Math.min(15_000, left));
     if (now() >= deadline) break;
   }
+  if (waitedForSlot) {
+    const resolution = outcome.kind === 'ran' ? 'slot-open' : outcome.kind === 'busy' ? 'deadline-slot-still-busy'
+      : `remote-infra: ${outcome.reason}`;
+    const waitData = { tool: opts.tool, host, reason: resolution, elapsedMs: Math.max(0, now() - waitStartedAt!),
+      ...(outcome.kind === 'busy' ? { occupied: outcome.occupied ?? null, cap: hostCap } : {}) };
+    logWait('wait-ended', waitData);
+    write.err(`[gate.remote] wait ended on ${host} — reason=${resolution} elapsed=${Math.floor(waitData.elapsedMs / 1000)}s${outcome.kind === 'busy' ? ` slots=${outcome.occupied ?? 'unknown'}/${hostCap}` : ''}\n`);
+  }
   if (opts.onRemoteOutcome) {
     try { opts.onRemoteOutcome(outcome, host, deps.runner ?? realGateRemoteRunner); }
     catch (error) { debug.log('gate.remote', 'outcome-hook-failed', { tool: opts.tool, host, error: error instanceof Error ? error.message : String(error) }); }