elanous 0.2.34 → 0.2.35

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

@@ -3,10 +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 type { GitRunResult } from '../git-fs/retry.js';
-import { linkWorktreeDependencies } from '../git-fs/worktree.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';
@@ -192,7 +192,6 @@ type BaselineUnknownReason = 'module-load-error' | 'infrastructure-failure' | 't
 
 const BASELINE_TIMEOUT_PER_FILE_MS = 300_000;
 const BASELINE_TIMEOUT_TOTAL_CAP_MS = 600_000;
-const BASELINE_WORKTREE_ADD_TIMEOUT_MS = 180_000;
 
 export function baselineTimeoutForFiles(fileCount: number): number {
   return Math.min(Math.max(1, fileCount) * BASELINE_TIMEOUT_PER_FILE_MS, BASELINE_TIMEOUT_TOTAL_CAP_MS);
@@ -214,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;
 }
@@ -810,17 +811,56 @@ function cgroupMemoryBytes(name: 'memory.current' | 'memory.max'): number | null
   } catch { return null; }
 }
 
-/** A failed checkout never proves that a baseline test ran. Preserve the Git failure's signal and timeout. */
-export function classifyBaselineWorktreeAddFailure(add: GitRunResult, elapsedMs: number): BaselineProcessResult {
+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 ${BASELINE_WORKTREE_ADD_TIMEOUT_MS}ms)`,
+    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();
 }
@@ -949,15 +989,16 @@ export function withBaselineWorktree<T>(cwd: string, baseRef: string, run: (base
   let attached = false;
   try {
     const started = Date.now();
-    const add = runGitCommand(cwd, gateWorktreeAddArgs(baselineDir, baseRef), { encoding: 'utf8', timeout: BASELINE_WORKTREE_ADD_TIMEOUT_MS, killSignal: 'SIGKILL' });
+    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: BASELINE_WORKTREE_ADD_TIMEOUT_MS, parentRssBytes: process.memoryUsage().rss,
+      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);
+    if (add.status !== 0) return classifyBaselineWorktreeAddFailure(add, elapsedMs, addTimeout.ms, worktreeAddFailureContext(cwd, baselineDir, baseRef));
     attached = true;
     linkDependencies(cwd, baselineDir);
     return run(baselineDir);
@@ -990,15 +1031,16 @@ function withVerifyWorktree<T>(cwd: string, baseRef: string, run: (dir: string)
   try {
     dir = mkdtempSync(join(tmpdir(), 'elanous-gate-baseline-'));
     const started = Date.now();
-    const add = runGitCommand(cwd, gateWorktreeAddArgs(dir, baseRef), { encoding: 'utf8', timeout: BASELINE_WORKTREE_ADD_TIMEOUT_MS, killSignal: 'SIGKILL' });
+    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: BASELINE_WORKTREE_ADD_TIMEOUT_MS, parentRssBytes: process.memoryUsage().rss,
+      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);
+    if (add.status !== 0) return classifyBaselineWorktreeAddFailure(add, elapsedMs, addTimeout.ms, worktreeAddFailureContext(cwd, dir, baseRef));
     attached = true;
     linkDependencies(cwd, dir);
     return run(dir);
@@ -1023,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 });
@@ -1461,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 };
 }
@@ -469,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;
@@ -500,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;
@@ -530,7 +541,7 @@ export async function dispatchHeavyCheck(opts: DispatchOptions, deps: DispatchDe
     }
     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));
@@ -540,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 });