elanous 0.2.32 → 0.2.35

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

@@ -1,3 +1,6 @@
+import { realpathSync } from 'node:fs';
+import { isAbsolute, relative, resolve, sep } from 'node:path';
+import { debug } from '../debug/log.js';
 import {
   allowsBaselineOnlyFailure,
   buildGateBaselineReport,
@@ -21,6 +24,10 @@ export interface GateShardAttempt {
   /** LIGHT-RC-MEASURE — the shard files that exist in the baseline tree, i.e. what the baseline side actually ran.
    *  Absent = every shard file (the old shape). Empty = the baseline side was not run and contributes zero cases. */
   baselineFiles?: readonly string[];
+  /** SHARD-JUNIT-ABS-PATH — the tree each side ran in. bun writes an absolute JUnit `file` once a test process.chdir()s;
+   *  such a path under this root is read as the cohort-relative file. Absent = absolute paths stay rejected (old shape). */
+  currentRoot?: string;
+  baselineRoot?: string;
 }
 
 export interface GateShardAggregate {
@@ -125,7 +132,32 @@ function textOf(element: XmlElement): string {
   return element.text + element.children.map(textOf).join('');
 }
 
-function readJUnit(xml: string, files: readonly string[]): JUnitCase[] | undefined {
+const realOrResolved = (path: string): string => {
+  try { return realpathSync(path); } catch { return resolve(path); }
+};
+
+/** SHARD-JUNIT-ABS-PATH — an absolute JUnit `file` under `root` becomes the cohort-relative path. Both sides are
+ *  realpath'd (macOS /tmp ↔ /private/tmp). A path outside the root is returned unchanged, so the cohort check rejects it. */
+function junitPathNormalizer(root: string | undefined): (file: string | undefined) => string | undefined {
+  if (!root) return (file) => file;
+  const realRoot = realOrResolved(root);
+  const seen = new Map<string, string>();
+  return (file) => {
+    if (file === undefined || !isAbsolute(file)) return file;
+    const cached = seen.get(file);
+    if (cached !== undefined) return cached;
+    const rel = relative(realRoot, realOrResolved(file));
+    const inside = rel !== '' && !rel.startsWith('..') && !isAbsolute(rel);
+    const to = inside ? rel.split(sep).join('/') : file;
+    seen.set(file, to);
+    if (inside) debug.log('gate.shard', 'junit-path-normalized', { from: file, to });
+    else debug.log('gate.shard', 'junit-path-outside-root', { from: file, root: realRoot });
+    return to;
+  };
+}
+
+function readJUnit(xml: string, files: readonly string[], treeRoot?: string): JUnitCase[] | undefined {
+  const normalize = junitPathNormalizer(treeRoot);
   const root = parseXml(xml);
   if (!root || (root.name !== 'testsuites' && root.name !== 'testsuite')) return undefined;
   const expected = new Set(files);
@@ -140,7 +172,7 @@ function readJUnit(xml: string, files: readonly string[]): JUnitCase[] | undefin
     || (/^(0|[1-9]\d*)$/.test(value) && Number(value) === actual);
   // Each suite's tests attribute covers its descendants too: compare subtree totals.
   const walkSuite = (suite: XmlElement, parentFile: string | undefined): { tests: number; failures: number; errors: number } | undefined => {
-    const file = suite.attrs.file ?? parentFile;
+    const file = normalize(suite.attrs.file) ?? parentFile;
     const declared = Number(suite.attrs.tests);
     if ((file && !expected.has(file)) || !Number.isSafeInteger(declared) || declared < 0) return undefined;
     const total = { tests: 0, failures: 0, errors: 0 };
@@ -150,7 +182,7 @@ function readJUnit(xml: string, files: readonly string[]): JUnitCase[] | undefin
         if (!sub) return undefined;
         total.tests += sub.tests; total.failures += sub.failures; total.errors += sub.errors;
       } else if (child.name === 'testcase') {
-        const caseFile = child.attrs.file ?? file;
+        const caseFile = normalize(child.attrs.file) ?? file;
         const leaf = child.attrs.name;
         if (!caseFile || !expected.has(caseFile) || !leaf || (file && file !== caseFile)) return undefined;
         total.tests++;
@@ -245,14 +277,16 @@ export function aggregateGateTestShards(shards: readonly GateTestShard[], attemp
   const retryShardIds: string[] = [];
   const current: JUnitCase[] = [];
   const baseline: JUnitCase[] = [];
+  // 기준선 JUnit 전체 testcase(통과·실패·스킵 포함). 귀속 일치 확인용이라 판정 재료인 `baseline`(스킵 제외)과 분리한다.
+  const baselineTestCases: JUnitCase[] = [];
   const skippedRegressions: JUnitCase[] = [];
   for (const shard of shards) {
     const attempt = selected.get(shard.id);
-    const head = attempt?.currentJUnit === undefined ? undefined : readJUnit(attempt.currentJUnit, shard.files);
+    const head = attempt?.currentJUnit === undefined ? undefined : readJUnit(attempt.currentJUnit, shard.files, attempt.currentRoot);
     // LIGHT-RC-MEASURE ① — the baseline side reads only the files that exist in the baseline tree; none = not run.
     const baselineFiles = attempt?.baselineFiles ?? shard.files;
     const baselineSkipped = baselineFiles.length === 0;
-    const base = baselineSkipped ? [] : attempt?.baselineJUnit === undefined ? undefined : readJUnit(attempt.baselineJUnit, baselineFiles);
+    const base = baselineSkipped ? [] : attempt?.baselineJUnit === undefined ? undefined : readJUnit(attempt.baselineJUnit, baselineFiles, attempt.baselineRoot);
     if (!attempt || attempt.currentExitCode === null || attempt.currentSignal
       || ![0, 1].includes(attempt.currentExitCode)
       || baselineFiles.some((file) => !shard.files.includes(file))
@@ -267,6 +301,7 @@ export function aggregateGateTestShards(shards: readonly GateTestShard[], attemp
     }
     current.push(...head.filter((test) => !test.skipped));
     baseline.push(...base.filter((test) => !test.skipped));
+    baselineTestCases.push(...base);
     const passedAtBase = new Set(base.filter((test) => !test.skipped && test.failure === undefined).map((test) => `${test.file}\u0000${test.name}`));
     skippedRegressions.push(...head.filter((test) => test.skipped && passedAtBase.has(`${test.file}\u0000${test.name}`)));
   }
@@ -279,6 +314,8 @@ export function aggregateGateTestShards(shards: readonly GateTestShard[], attemp
   const passedTestEvidence: GatePassedTestEvidence = {
     status: 'available',
     tests: baseline.filter((test) => test.failure === undefined).map(({ file, name }) => ({ file, name: `${file} > ${name}` })),
+    // #27844 귀속 불일치 — 비샤드 경로(runBaselineBunTest)와 같은 계약으로 기준선 전체 testcase 를 넘긴다.
+    testCases: baselineTestCases.map(({ file, name }) => ({ file, name: `${file} > ${name}` })),
   };
   const report = buildGateBaselineReport(asGateLog(current), {
     status: baselineStatus,

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

@@ -25,6 +25,8 @@ export interface ShardRunResult {
   failureEvidence?: ShardFailureEvidence[];
   /** Latest failed attempt's reason for each incomplete shard; copied into the gate artifact summary. */
   unmeasuredByShard?: Record<string, string>;
+  /** git stderr tail (redacted · ≤2KB · one line) when the baseline worktree could not be added. */
+  baselineStderrTail?: string;
 }
 
 /** What a failed shard process leaves behind so «test failure vs runner error» can be told apart after the fact. */
@@ -275,6 +277,7 @@ function runPlannedShards(
           currentSignal: current.signal, baselineSignal: base.signal,
           currentDiagnostic: current.diagnostic, baselineDiagnostic: base.diagnostic,
           baselineFiles,
+          currentRoot: cwd, baselineRoot: dir,
         });
       }
       const retry = new Set(aggregateGateTestShards(shards, attempts).retryShardIds);
@@ -288,9 +291,13 @@ function runPlannedShards(
     ...(baseline.retryShardIds.length ? { unmeasuredByShard: incompleteShardReasons(baseline.retryShardIds, attempts) } : {}),
   };
   const retryShardIds = shards.map((shard) => shard.id);
+  // The stderr tail has its own budget (≤2KB, already redacted) so the 500-char log cut cannot drop it.
+  const stderrTail = baseline.gitStderrTail;
+  const stderrPart = stderrTail ? ` · git stderr: ${stderrTail}` : '';
   return {
     aggregate: { status: 'unmeasured', retryShardIds }, shards, attempts, reason: baseline.log, ...evidence,
-    unmeasuredByShard: Object.fromEntries(retryShardIds.map((id) => [id, `baseline worktree: ${redactSecretText(baseline.log).replace(/[\r\n\t\x00-\x1f\x7f]+/g, ' ').slice(0, 500)}`])),
+    unmeasuredByShard: Object.fromEntries(retryShardIds.map((id) => [id, `baseline worktree: ${redactSecretText(baseline.log).replace(/[\r\n\t\x00-\x1f\x7f]+/g, ' ').slice(0, 500)}${stderrPart}`])),
+    ...(stderrTail ? { baselineStderrTail: stderrTail } : {}),
   };
 }
 

package/src/self-implement/blocked-draft-policy.ts

@@ -89,3 +89,23 @@ export function salvageBranchForRun(runId: string, branch: string): string {
   const leaf = branch.replace(/[^A-Za-z0-9._-]+/g, '-').replace(/^[-.]+|[-.]+$/g, '').replace(/\.\.+/g, '.').replace(/\.lock$/i, '-lock') || 'branch';
   return `salvage/${runShort}/${leaf}`;
 }
+
+/** REPAIR-BLOCKED-DRAFT-LINK-ORIGINAL — commit-only 수리 런의 base 는 합성 로컬 가지 `pr-<N>`(harness-pod-dispatch 가 넘긴다).
+ *  ⛔ origin 에 없는 가지라 그 base 로 새 draft 를 열면 반드시 실패한다. 이 꼴이면 원 PR 번호를 낸다. */
+export function syntheticRepairBasePr(base: string | undefined): number | undefined {
+  const match = /^pr-([1-9]\d*)$/.exec(base ?? '');
+  return match ? Number(match[1]) : undefined;
+}
+
+export type BlockedDraftTarget = { action: 'open-draft' } | { action: 'link-original'; originalPr: number };
+
+/** 중단 산출물을 어디에 남기나 — 합성 base `pr-<N>` 이면 새 draft 대신 «기존 PR #N 에 수확 가지 연결». */
+export function blockedDraftTargetFor(base: string | undefined): BlockedDraftTarget {
+  const originalPr = syntheticRepairBasePr(base);
+  return originalPr === undefined ? { action: 'open-draft' } : { action: 'link-original', originalPr };
+}
+
+/** 원 PR 에 다는 한 줄 — 수확 가지 이름·sha·런. (force push 없음 · 원 PR 가지는 그대로) */
+export function repairSalvageLinkComment(input: { salvageRef: string; sha?: string; runId: string; stage: string }): string {
+  return `수리 산출물 salvage ${input.salvageRef}${input.sha ? ` @ ${input.sha.slice(0, 12)}` : ''} — 런 ${input.runId} 이 ${input.stage} 로 멈춰 새 PR 대신 이 PR 에 잇는다(원 PR 가지 무변경)`;
+}

package/src/self-implement/classify-shadow.ts

@@ -1,5 +1,5 @@
-import { executeClassifyNode } from '../workflow-runtime/nodes/classify.js';
-import type { ClassifyNode, NodeExecContext, NodeOutput, WorkflowDeps } from '../workflow-runtime/types.js';
+import { runGraphClassifyNode } from '../graph-runner/runner.js';
+import type { ClassifyNode, NodeExecContext, WorkflowDeps } from '../workflow-runtime/types.js';
 import { REWORK_BUDGET_VERDICTS, type ReworkBudgetVerdict } from './run-outcome.js';
 
 export type ClassifyShadowCallLLM = WorkflowDeps['callLLM'];
@@ -36,11 +36,7 @@ export async function classifyReworkBudgetShadow(
       resolvedModel: undefined,
       toolPolicy: {},
     };
-    const deps: WorkflowDeps = {
-      callLLM,
-      runBash: async () => ({ stdout: '', stderr: '', exitCode: 0 }),
-    };
-    const result: NodeOutput = await executeClassifyNode(node, context, deps);
+    const result = await runGraphClassifyNode(node, context, callLLM, { caller: 'rework-budget-shadow' });
     const picked = isReworkBudgetVerdict(result.output) ? result.output : 'unknown';
     return {
       picked,

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

@@ -1,4 +1,6 @@
 import { debug } from '../debug/log.js';
+import { findIncidentPrecedents, type IncidentPrecedent } from '../harness/harness-incidents.js';
+import { elanousStateRoot } from '../autopilot/state-paths.js';
 import {
   appendRunLedgerEntry,
   listRunLedgers,
@@ -6,6 +8,10 @@ import {
   lookupRunLedger,
   type RunLedgerLookupOptions,
 } from './run-ledger.js';
+/** 사고 원장 루트 기본값 — 운영/시험 우주 상태 디렉터리(없으면 빈 선례 · fail-soft). */
+export function doctorVisitIncidentRoot(): string {
+  return elanousStateRoot();
+}
 
 /** DOCTOR-VISIT 증상 닫힌 목록 — 이 밖의 값은 기록·조회 모두 거부한다. */
 export const DOCTOR_SYMPTOMS = [
@@ -49,6 +55,8 @@ export interface RecordDoctorVisitInput {
   evidence?: string;
   /** 원장 디렉터리(시험 seam) — 기본 = `runLedgerDir()`. */
   dir?: string;
+  /** 사고 원장 루트(시험 seam) — 기본 = `doctorVisitIncidentRoot()`. `null` 이면 선례 연결을 건너뛴다. */
+  incidentRoot?: string | null;
 }
 
 export interface DoctorVisit {
@@ -57,6 +65,8 @@ export interface DoctorVisit {
   symptom: DoctorSymptom;
   evidence?: string;
   timestamp?: string;
+  /** 사고 선례 연결 — 같은 reason 으로 이전에 기록된 실제 exit(기록 없으면 빈 배열). */
+  incidentPrecedents?: IncidentPrecedent[];
 }
 
 /**
@@ -74,15 +84,22 @@ export function recordDoctorVisit(visit: RecordDoctorVisitInput): DoctorVisit {
     throw new Error(`없음: 런 원장이 없습니다 (runId=${visit.runId}) — 새 원장을 만들지 않습니다`);
   }
   const timestamp = new Date().toISOString();
+  // 사고 선례 연결 — 기록된 실제 exit 만(지어내기 금지). 원장이 없으면 빈 배열(fail-soft).
+  const incidentRoot = 'incidentRoot' in visit ? visit.incidentRoot ?? null : doctorVisitIncidentRoot();
+  const incidentPrecedents = incidentRoot === null
+    ? []
+    : findIncidentPrecedents({ reason: visit.symptom, at: timestamp, runId: visit.runId }, incidentRoot);
   const data: Record<string, unknown> = { from: visit.from, symptom: visit.symptom };
   if (typeof visit.evidence === 'string' && visit.evidence.length > 0) data.evidence = visit.evidence;
+  if (incidentPrecedents.length > 0) data.incidentPrecedents = incidentPrecedents;
   appendRunLedgerEntry({ timestamp, runId: visit.runId, event: 'doctor-visit', data }, visit.dir);
-  debug.log('run-doctor', 'visit', { runId: visit.runId, from: visit.from, symptom: visit.symptom });
+  debug.log('run-doctor', 'visit', { runId: visit.runId, from: visit.from, symptom: visit.symptom, incidentPrecedents: incidentPrecedents.length });
   return {
     runId: visit.runId,
     from: visit.from,
     symptom: visit.symptom,
     ...(typeof visit.evidence === 'string' && visit.evidence.length > 0 ? { evidence: visit.evidence } : {}),
+    ...(incidentPrecedents.length > 0 ? { incidentPrecedents } : {}),
     timestamp,
   };
 }

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

@@ -3,9 +3,10 @@ import { copyFileSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSy
 import { tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { prepareDeterministicChildEnvironment } from '../../scripts/lib/deterministic-env.js';
-import { debug } from '../debug/log.js';
+import { debug, redactSecretText } from '../debug/log.js';
 import { runGitCommand } from '../git-fs/runner.js';
-import { linkWorktreeDependencies } from '../git-fs/worktree.js';
+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';
@@ -212,6 +213,8 @@ export interface BaselineProcessResult {
   childResponsibility?: 'none';
   output?: string;
   log: string;
+  /** Redacted, single-line tail (≤2KB) of git's stderr when the baseline `worktree add` failed; «(비었음 · signal=… · errorCode=…)» when git wrote none — so «truthy» does NOT mean git wrote stderr. */
+  gitStderrTail?: string;
   missingAtBase?: readonly string[];
   passedTestEvidence?: GatePassedTestEvidence;
 }
@@ -787,12 +790,77 @@ function runIsolatedBunTest(cwd: string, args: string[], timeout: number): Proce
   try {
     // SIGKILL — a test that traps SIGTERM while blocked in a native wait never runs its handler, so spawnSync
     // waited forever and its drive grandchildren lived on as ppid=1 orphans (09-30 O1: 19 processes, up to 11h).
-    return spawnSync('bun', ['test', ...args], { cwd, env: isolated.env, encoding: 'utf8', timeout, killSignal: 'SIGKILL', maxBuffer: 32 * 1024 * 1024 });
+    const started = Date.now();
+    const result = spawnSync('bun', ['test', ...args], { cwd, env: isolated.env, encoding: 'utf8', timeout, killSignal: 'SIGKILL', maxBuffer: 32 * 1024 * 1024 });
+    debug.log('self-implement.gate-baseline', 'test-process-result', {
+      status: result.status, signal: result.signal, errorCode: (result.error as NodeJS.ErrnoException | undefined)?.code ?? null,
+      elapsedMs: Date.now() - started, timeoutMs: timeout, parentRssBytes: process.memoryUsage().rss,
+      cgroupMemoryCurrentBytes: cgroupMemoryBytes('memory.current'), cgroupMemoryLimitBytes: cgroupMemoryBytes('memory.max'),
+    });
+    return result;
   } finally {
     isolated.cleanup();
   }
 }
 
+function cgroupMemoryBytes(name: 'memory.current' | 'memory.max'): number | null {
+  try {
+    const raw = readFileSync(`/sys/fs/cgroup/${name}`, 'utf8').trim();
+    const value = Number(raw);
+    return Number.isSafeInteger(value) && value >= 0 ? value : null;
+  } catch { return null; }
+}
+
+export const BASELINE_GIT_STDERR_TAIL_LIMIT = 2_048;
+
+/** git's own messages only, but a token-shaped string is still masked; lines are joined so one gate.log line holds it. */
+export function baselineGitStderrTail(stderr: string): string {
+  const lines = String(stderr ?? '').replace(/\r\n?/g, '\n').split('\n').map((line) => line.trimEnd()).filter((line) => line !== '');
+  const flat = redactSecretText(lines.join(' ⏎ ')).replace(/[\u0000-\u001F\u007F]/g, '·');
+  const bytes = Buffer.from(flat, 'utf8');
+  if (bytes.length <= BASELINE_GIT_STDERR_TAIL_LIMIT) return flat;
+  // Byte cap (UTF-8): a cut inside a multi-byte character decodes to U+FFFD at the front — drop it.
+  return bytes.subarray(bytes.length - BASELINE_GIT_STDERR_TAIL_LIMIT).toString('utf8').replace(/^�+/, '');
+}
+
+export interface BaselineWorktreeAddContext {
+  dir: string;
+  baseRef: string;
+  /** Resolved commit of baseRef; absent when it could not be resolved. */
+  baseSha?: string;
+}
+
+/** A failed checkout never proves that a baseline test ran. Preserve the Git failure's signal, timeout and stderr. */
+export function classifyBaselineWorktreeAddFailure(add: GitRunResult, elapsedMs: number, timeoutMs: number, context?: BaselineWorktreeAddContext): BaselineProcessResult {
+  const reason = add.errorCode === 'ETIMEDOUT' ? 'worktree-add-timeout'
+    : add.signal ? `worktree-add-signal-${add.signal}` : 'worktree-add-failed';
+  const where = context ? `, target ${context.dir}, base ${context.baseRef}@${context.baseSha ? context.baseSha.slice(0, 12) : 'unresolved'}` : '';
+  // An empty stderr is a finding (git died without a word), not «nothing to say» — name the signal and errorCode instead.
+  const stderrTail = baselineGitStderrTail(add.stderr ?? '')
+    || `(비었음 · signal=${add.signal ?? 'none'} · errorCode=${add.errorCode ?? 'none'})`;
+  debug.log('self-implement.gate-baseline', 'worktree-add-failed', {
+    code: add.status, signal: add.signal ?? null, errorCode: add.errorCode ?? null, elapsedMs, timeoutMs,
+    stderrTail, ...(context ? { dir: context.dir, baseRef: context.baseRef, baseSha: context.baseSha ?? null } : {}),
+  });
+  return {
+    status: 'unknown', unknownReason: 'infrastructure-failure', childResponsibility: 'none',
+    log: `baseline ${reason} (code ${String(add.status)}, elapsed ${elapsedMs}ms, limit ${timeoutMs}ms${where})`,
+    output: `${add.stdout}\n${add.stderr}`,
+    gitStderrTail: stderrTail,
+  };
+}
+
+/** Only on the failure path: one extra rev-parse (5s cap · not counted in the add's elapsedMs) so the reason names the commit. */
+function worktreeAddFailureContext(cwd: string, dir: string, baseRef: string): BaselineWorktreeAddContext {
+  try {
+    const parsed = runGitCommand(cwd, ['rev-parse', '--verify', '--quiet', `${baseRef}^{commit}`], { encoding: 'utf8', timeout: 5_000 });
+    const sha = parsed.status === 0 ? (parsed.stdout ?? '').trim() : '';
+    return { dir, baseRef, ...(/^[0-9a-f]{40,64}$/.test(sha) ? { baseSha: sha } : {}) };
+  } catch {
+    return { dir, baseRef };
+  }
+}
+
 function junitReportTemporaryDirectory(): string {
   return process.env.ELANOUS_GATE_JUNIT_TMPDIR || tmpdir();
 }
@@ -920,8 +988,17 @@ export function withBaselineWorktree<T>(cwd: string, baseRef: string, run: (base
   const baselineDir = mkdtempSync(join(tmpdir(), 'elanous-gate-baseline-'));
   let attached = false;
   try {
-    const add = runGitCommand(cwd, gateWorktreeAddArgs(baselineDir, baseRef), { encoding: 'utf8', timeout: 60_000 });
-    if (add.status !== 0) return classifyBaselineProcess({ status: add.status, stdout: add.stdout, stderr: add.stderr });
+    const started = Date.now();
+    const addTimeout = worktreeAddTimeoutForRepo(cwd, undefined, baseRef);
+    const add = runGitCommand(cwd, gateWorktreeAddArgs(baselineDir, baseRef), { encoding: 'utf8', timeout: addTimeout.ms, killSignal: 'SIGKILL' });
+    const elapsedMs = Date.now() - started;
+    debug.log('self-implement.gate-baseline', 'worktree-add-result', {
+      phase: 'baseline',
+      status: add.status, signal: add.signal ?? null, errorCode: add.errorCode ?? null,
+      elapsedMs, timeoutMs: addTimeout.ms, trackedFileCount: addTimeout.trackedFileCount, timeoutSource: addTimeout.source, parentRssBytes: process.memoryUsage().rss,
+      cgroupMemoryCurrentBytes: cgroupMemoryBytes('memory.current'), cgroupMemoryLimitBytes: cgroupMemoryBytes('memory.max'),
+    });
+    if (add.status !== 0) return classifyBaselineWorktreeAddFailure(add, elapsedMs, addTimeout.ms, worktreeAddFailureContext(cwd, baselineDir, baseRef));
     attached = true;
     linkDependencies(cwd, baselineDir);
     return run(baselineDir);
@@ -953,8 +1030,17 @@ function withVerifyWorktree<T>(cwd: string, baseRef: string, run: (dir: string)
   let attached = false;
   try {
     dir = mkdtempSync(join(tmpdir(), 'elanous-gate-baseline-'));
-    const add = runGitCommand(cwd, gateWorktreeAddArgs(dir, baseRef), { encoding: 'utf8', timeout: 60_000 });
-    if (add.status !== 0) return classifyBaselineProcess({ status: add.status, stdout: add.stdout, stderr: add.stderr });
+    const started = Date.now();
+    const addTimeout = worktreeAddTimeoutForRepo(cwd, undefined, baseRef);
+    const add = runGitCommand(cwd, gateWorktreeAddArgs(dir, baseRef), { encoding: 'utf8', timeout: addTimeout.ms, killSignal: 'SIGKILL' });
+    const elapsedMs = Date.now() - started;
+    debug.log('self-implement.gate-baseline', 'worktree-add-result', {
+      phase: 'verify',
+      status: add.status, signal: add.signal ?? null, errorCode: add.errorCode ?? null,
+      elapsedMs, timeoutMs: addTimeout.ms, trackedFileCount: addTimeout.trackedFileCount, timeoutSource: addTimeout.source, parentRssBytes: process.memoryUsage().rss,
+      cgroupMemoryCurrentBytes: cgroupMemoryBytes('memory.current'), cgroupMemoryLimitBytes: cgroupMemoryBytes('memory.max'),
+    });
+    if (add.status !== 0) return classifyBaselineWorktreeAddFailure(add, elapsedMs, addTimeout.ms, worktreeAddFailureContext(cwd, dir, baseRef));
     attached = true;
     linkDependencies(cwd, dir);
     return run(dir);
@@ -979,10 +1065,7 @@ export function runGateBaseline(cwd: string, failedFiles: readonly string[], bas
   const files = [...new Set(failedFiles.filter(Boolean))];
   if (files.length === 0) return { status: 'unknown', log: 'baseline skipped: failed test files could not be identified' };
   const result = withBaselineWorktree(cwd, baseRef, (baselineDir) => {
-    const missingAtBase = files.filter((f) => {
-      const probe = runGitCommand(cwd, ['cat-file', '-e', `${baseRef}:${f}`], { encoding: 'utf8', timeout: 15_000 });
-      return probe.status === 1;
-    });
+    const missingAtBase = files.filter((f) => probeBaseTestFilePresence(cwd, baseRef, f) === 'missing');
     const timeoutMs = baselineTimeoutForFiles(files.length);
     const process = runBaselineBunTest(baselineDir, files, timeoutMs);
     const baseline = classifyBaselineProcess(process, { timeoutMs, fileCount: files.length });
@@ -1417,7 +1500,7 @@ export function buildGateBaselineReport(
     worktreeFailuresParsed,
     files: [...new Set(failures.flatMap((failure) => failure.file ? [failure.file] : []))],
     baselineStatus: baseline.status,
-    log: baseline.log,
+    log: baseline.gitStderrTail ? `${baseline.log}\nbaseline worktree-add git stderr: ${baseline.gitStderrTail}` : baseline.log,
   };
 }
 

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

@@ -893,6 +893,7 @@ function runSelfGateCliCore(cwd: string, options: SelfGateCliOptions, deps: Self
         lines.push(`shard unmeasured: ${shardId} · ${sharded.unmeasuredByShard?.[shardId] ?? sharded.reason ?? 'cause unavailable'}`);
       }
       lines.push(`shards: unmeasured (${unmeasuredReason})`);
+      if (sharded.baselineStderrTail) lines.push(`baseline worktree-add git stderr: ${sharded.baselineStderrTail}`);
       capture.unmeasuredReason = unmeasuredReason;
     }
     else if (aggregate.report) {

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

@@ -184,8 +184,8 @@ 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 }
-  | { kind: 'infra'; reason: string };
+  | { kind: 'busy'; occupied?: number; rc?: number }
+  | { kind: 'infra'; reason: string; stage?: string; rc?: number | null; stderr?: string };
 
 export interface RemoteRunOptions {
   repo: string;
@@ -331,12 +331,12 @@ export function runOnRemote(opts: RemoteRunOptions, runner: GateRemoteRunner = r
   } catch (error) { return { kind: 'infra', reason: `argv: ${error instanceof Error ? error.message : String(error)}` }; }
   const shas = [...new Set([commit, mainSha, ...extra])];
   const pushTarget = `${opts.host}:${opts.mirror.startsWith('~/') ? opts.mirror.slice(2) : opts.mirror}`;
-  // Non-interactive and time-bounded: a stuck connection or auth prompt must end in a local fallback, not a hang.
+  // Non-interactive and time-bounded: a stuck connection or auth prompt must end without hanging.
   const push = runner.local('git', ['push', '--quiet', pushTarget, ...shas.map((sha) => `${sha}:refs/elanous/gate/${sha}`)], opts.repo, {
     timeoutMs: PUSH_TIMEOUT_MS,
     env: { ...process.env, GIT_SSH_COMMAND: 'ssh -o BatchMode=yes -o ConnectTimeout=10', GIT_TERMINAL_PROMPT: '0' },
   });
-  if (push.rc !== 0 || push.error) return { kind: 'infra', reason: `push-failed rc=${push.rc}: ${(push.stderr || push.error || '').trim().split('\n').slice(-2).join(' | ')}` };
+  if (push.rc !== 0 || push.error) return { kind: 'infra', stage: 'push', rc: push.rc, stderr: push.stderr || push.error || '', reason: `push-failed rc=${push.rc}: ${(push.stderr || push.error || '').trim().split('\n').slice(-2).join(' | ')}` };
   const script = remoteScript({ mirror: opts.mirror, commit, fetchShas: shas, mainSha, argv, installPwa: opts.installPwa ?? false, stableCheckout: opts.stableCheckout, payloadFiles: opts.payloadFiles, hostCap: opts.hostCap, slotDir: opts.slotDir });
   const run = runner.ssh(opts.host, script, opts.timeoutMs ?? 120 * 60_000);
   // The script prints "\n<marker><rc>\n": everything before that leading newline is the tool's own stderr, byte for byte.
@@ -350,17 +350,17 @@ export function runOnRemote(opts: RemoteRunOptions, runner: GateRemoteRunner = r
     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', ...(busy[1] !== undefined ? { occupied: Number(busy[1]) } : {}) };
+      if (busy) return { kind: 'busy', rc: run.rc, ...(busy[1] !== undefined ? { occupied: Number(busy[1]) } : {}) };
     }
-    if (run.rc === 97 && last.startsWith(INFRA)) return { kind: 'infra', reason: `remote-${last.slice(INFRA.length).trim()}` };
+    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()}` };
   }
   // No marker, or ssh did not end cleanly after it (the script always exits 0 once the marker is written): output may be cut.
-  if (marker < 0) return { kind: 'infra', reason: `ssh rc=${run.rc}${run.error ? ` ${run.error}` : ''}: ${stderrText.trim().split('\n').slice(-2).join(' | ')}` };
-  if (run.rc !== 0 || run.error) return { kind: 'infra', reason: `ssh-incomplete rc=${run.rc}${run.error ? ` ${run.error}` : ''}` };
+  if (marker < 0) return { kind: 'infra', stage: 'ssh', rc: run.rc, stderr: stderrText, reason: `ssh rc=${run.rc}${run.error ? ` ${run.error}` : ''}: ${stderrText.trim().split('\n').slice(-2).join(' | ')}` };
+  if (run.rc !== 0 || run.error) return { kind: 'infra', stage: 'ssh-incomplete', rc: run.rc, stderr: stderrText, reason: `ssh-incomplete rc=${run.rc}${run.error ? ` ${run.error}` : ''}` };
   // The marker is the last thing the script writes: exactly "\n<marker><digits>\n". Anything else (empty, cut) is infra.
   const tail = /^\n__GATE_REMOTE_RC=(\d{1,3})\n$/.exec(stderrBytes.subarray(marker).toString('utf8'));
   const rc = tail ? Number(tail[1]) : NaN;
-  if (!(rc >= 0 && rc <= 255)) return { kind: 'infra', reason: 'rc-unparsed' };
+  if (!(rc >= 0 && rc <= 255)) return { kind: 'infra', stage: 'rc-unparsed', rc: run.rc, stderr: stderrText, reason: 'rc-unparsed' };
   // The tool's stderr is exactly what came before the marker line.
   return { kind: 'ran', rc, stdout: stdoutBytes, stderr: stderrBytes.subarray(0, marker), commit, host: opts.host, ms: Date.now() - started };
 }
@@ -437,11 +437,13 @@ export interface DispatchOptions {
   /** Set when this invocation cannot be reproduced remotely (e.g. self gate without --base): automatic placement
    *  falls back with this reason; an explicit self gate --remote reports an unmeasured check instead. */
   localOnlyReason?: string;
-  /** Self gate CLI only: explicit --remote must never be measured by a local fallback. */
+  /** Explicit or caller-required remote measurement must never become a local fallback. */
   explicitRemoteOnly?: boolean;
+  /** Keep the remote checkout and TypeScript cache per host slot across repeated checks. */
+  stableCheckout?: boolean;
   /** Self gate CLI only: name the host for both automatic and explicit remote execution. */
   reportRemoteHost?: boolean;
-  /** Self gate's state universe; omitted by other callers and injected tests. */
+  /** Release gate host reservations shared by self gate and changed typecheck. */
   reservationRoot?: string;
   runLocal: () => number | Promise<number>;
   /** Called once with the final remote outcome (never on a local decision), before its output passes through or the
@@ -467,14 +469,21 @@ async function loadSettings(): Promise<GateRemoteSettings> {
   } catch { return resolveGateRemoteSettings(undefined); }
 }
 
-/** Decide local/remote, run, and return the tool's exit code. Automatic infra failure ⇒ visible local fallback. */
+/** Decide local/remote, run, and return the tool's exit code. Self gate remote failures are never local measurements. */
 export async function dispatchHeavyCheck(opts: DispatchOptions, deps: DispatchDeps = {}): Promise<number> {
   const settings = deps.settings ?? await loadSettings();
   const env = deps.env ?? process.env;
   const write = deps.write ?? { out: (d: string | Uint8Array) => process.stdout.write(d), err: (d: string | Uint8Array) => process.stderr.write(d) };
-  const decision = decideGateDispatch({ flags: opts.flags, settings, load1: deps.load1 ?? loadavg()[0]!, env });
+  const flags = opts.tool === 'self-gate' && !opts.flags.local ? { ...opts.flags, remote: opts.flags.remote ?? true } : opts.flags;
+  const decision = decideGateDispatch({ flags, settings, load1: deps.load1 ?? loadavg()[0]!, env });
   debug.log('gate.remote', 'decision', { tool: opts.tool, mode: decision.mode, host: decision.host, reason: decision.reason, load1: decision.load1 });
   if (decision.mode === 'local') {
+    if (opts.tool === 'self-gate' && !opts.flags.local) {
+      const host = typeof flags.remote === 'string' ? flags.remote : settings.host;
+      debug.log('gate.remote', 'remote-unmeasured', { tool: opts.tool, host, reason: decision.reason, stage: 'placement', rc: null });
+      write.err(`[gate.remote] remote unmeasured on ${host} (stage=placement, rc=unknown) — ${decision.reason}\n`);
+      return 1;
+    }
     if (opts.explicitRemoteOnly && opts.flags.remote !== undefined && decision.reason !== 'flag-local') {
       write.err(`[gate.remote] remote unmeasured — ${decision.reason}\n`);
       return 1;
@@ -482,12 +491,14 @@ export async function dispatchHeavyCheck(opts: DispatchOptions, deps: DispatchDe
     return opts.runLocal();
   }
   let host = decision.host!;
-  const reservationRoot = opts.tool === 'self-gate' ? opts.reservationRoot ?? (deps.runner ? undefined : gateHostReservationRoot()) : undefined;
+  const reservationRoot = opts.tool === 'self-gate' || opts.tool === 'ci-typecheck-changed'
+    ? opts.reservationRoot ?? (deps.runner ? undefined : gateHostReservationRoot()) : undefined;
   if (reservationRoot) {
     const reservationHost = host.split('@').at(-1)!;
     const first = inspectReleaseGateHost(reservationRoot, reservationHost);
     if (first.status !== 'free') {
-      const alternate = reservationHost === 'node-b' ? 'node-c' : null;
+      // Changed typecheck has a fixed node-b placement; a release reservation makes it unmeasured.
+      const alternate = opts.tool === 'self-gate' && reservationHost === 'node-b' ? 'node-c' : null;
       const other = alternate ? inspectReleaseGateHost(reservationRoot, alternate) : null;
       if (alternate && other?.status === 'free') {
         debug.log('gate.remote', 'host-reserved-reroute', { from: host, to: alternate, reason: first.reason, status: first.status });
@@ -496,22 +507,26 @@ export async function dispatchHeavyCheck(opts: DispatchOptions, deps: DispatchDe
       } else {
         const reason = `host-reserved: ${host} (${first.reason}); alternate ${alternate ?? '(none)'} ${other?.status ?? 'unavailable'}`;
         debug.log('gate.remote', 'host-reserved-unmeasured', { host, reason });
-        write.err(`[gate.remote] remote unmeasured — ${reason}\n`);
+        write.err(opts.tool === 'self-gate'
+          ? `[gate.remote] remote unmeasured on ${host} (stage=host-reserved, rc=unknown) — ${reason}\n`
+          : `[gate.remote] remote unmeasured — ${reason}\n`);
         return 1;
       }
     }
   }
-  const fallback = (reason: string) => {
-    if (opts.explicitRemoteOnly && opts.flags.remote !== undefined) {
-      debug.log('gate.remote', 'remote-unmeasured', { tool: opts.tool, host, reason });
-      write.err(`[gate.remote] remote unmeasured on ${host} — ${reason.replace(/\s+/g, ' ').trim()}\n`);
+  const fallback = (reason: string, failure?: { stage?: string; rc?: number | null; stderr?: string }) => {
+    const selfGateInfrastructureFailure = opts.tool === 'self-gate' && failure?.stage !== 'reproducibility';
+    if (selfGateInfrastructureFailure || (opts.explicitRemoteOnly && opts.flags.remote !== undefined)) {
+      debug.log('gate.remote', 'remote-unmeasured', { tool: opts.tool, host, reason, ...(opts.tool === 'self-gate' ? { stage: failure?.stage, rc: failure?.rc, stderr: failure?.stderr } : {}) });
+      write.err(`[gate.remote] remote unmeasured on ${host}${opts.tool === 'self-gate' && failure?.stage ? ` (stage=${failure.stage}, rc=${failure.rc ?? 'unknown'})` : ''} — ${reason.replace(/\s+/g, ' ').trim()}\n`);
+      if (opts.tool === 'self-gate' && failure?.stderr) write.err(failure.stderr.endsWith('\n') ? failure.stderr : `${failure.stderr}\n`);
       return 1;
     }
     debug.log('gate.remote', 'fallback', { tool: opts.tool, host, reason });
     write.err(`[gate.remote] fallback to local — ${reason}\n`);
     return opts.runLocal();
   };
-  if (opts.localOnlyReason) return fallback(opts.localOnlyReason);
+  if (opts.localOnlyReason) return fallback(opts.localOnlyReason, { stage: 'reproducibility', rc: null });
   const hostCap = gateRemoteHostCap(settings, host);
   const sleep = deps.sleep ?? ((ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms)));
   const now = deps.now ?? Date.now;
@@ -520,13 +535,13 @@ export async function dispatchHeavyCheck(opts: DispatchOptions, deps: DispatchDe
   let outcome: RemoteRunOutcome;
   for (;;) {
     try {
-      outcome = runOnRemote({ repo: opts.repo, host, mirror: settings.mirror, argv: opts.remoteArgv, refs: opts.refs, ...(opts.commit !== undefined ? { commit: opts.commit } : {}), installPwa: opts.installPwa, payloadFiles: opts.payloadFiles, hostCap }, deps.runner);
+      outcome = runOnRemote({ repo: opts.repo, host, mirror: settings.mirror, argv: opts.remoteArgv, refs: opts.refs, ...(opts.commit !== undefined ? { commit: opts.commit } : {}), installPwa: opts.installPwa, payloadFiles: opts.payloadFiles, stableCheckout: opts.stableCheckout, hostCap }, deps.runner);
     } catch (error) {
       outcome = { kind: 'infra', reason: `exception: ${error instanceof Error ? error.message : String(error)}` };
     }
     if (outcome.kind !== 'busy') break;
     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 wait falls back only for automatic placement.
+    // Never start an attempt past the deadline: an expired self gate wait remains unmeasured.
     const left = deadline - now();
     if (left <= 0) break;
     await sleep(Math.min(15_000, left));
@@ -536,8 +551,8 @@ export async function dispatchHeavyCheck(opts: DispatchOptions, deps: DispatchDe
     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) }); }
   }
-  if (outcome.kind === 'busy') return fallback(`host-busy (occupied ${outcome.occupied ?? 'unknown'}/${hostCap}, held for ${settings.slotWaitSeconds}s)`);
-  if (outcome.kind === 'infra') return fallback(outcome.reason);
+  if (outcome.kind === 'busy') return fallback(`host-busy (occupied ${outcome.occupied ?? 'unknown'}/${hostCap}, held for ${settings.slotWaitSeconds}s)`, { stage: 'host-busy', rc: outcome.rc });
+  if (outcome.kind === 'infra') return fallback(outcome.reason, { ...outcome, stage: outcome.stage ?? 'preflight', rc: outcome.rc ?? null });
   // Parity: the tool's own stdout/stderr/rc pass through unchanged; JSON gains host · remote:true,
   // and the self gate CLI appends a host diagnostic to human-readable stderr.
   debug.log('gate.remote', 'result', { tool: opts.tool, host: outcome.host, commit: outcome.commit, rc: outcome.rc, ms: outcome.ms });