elanous 0.2.29 → 0.2.31

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

@@ -1,11 +1,13 @@
-import { existsSync, mkdtempSync, readFileSync, rmSync, statSync } from 'node:fs';
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { debug, redactSecretText } from '../debug/log.js';
 import { prepareDeterministicChildEnvironment } from '../../scripts/lib/deterministic-env.js';
+import { withGateTestEnv } from '../../scripts/lib/gate-test-env.js';
 import { withBaselineWorktree } from '../self-implement/gate-baseline.js';
 import { aggregateGateTestShards, type GateShardAttempt, type GateShardAggregate } from './shard-aggregate.js';
-import { planGateTestShards, type GateTestShard } from './shard-plan.js';
+import { planFixedGateTestShards, planSelfGateSpawnSeparatedShards, type GateTestShard } from './shard-plan.js';
+import { isGateSpawnLaneFile } from './spawn-lane-files.js';
 
 export interface ShardRunResult {
   aggregate: GateShardAggregate;
@@ -13,6 +15,33 @@ export interface ShardRunResult {
   attempts: GateShardAttempt[];
   reason?: string;
   measurementFailures?: number;
+  /** Present only for opt-in `--fixed-shard-distribution` (no RSS pre-measurement). Absent = the measured planner. */
+  distribution?: 'fixed';
+  /** OP FU (MK #8178 shard-9) — raw evidence of every failed shard process (exit≠0 · signal · no JUnit). Observation only:
+   *  the aggregate never reads it. Absent = no shard process reported failure output. */
+  failureEvidence?: ShardFailureEvidence[];
+}
+
+/** What a failed shard process leaves behind so «test failure vs runner error» can be told apart after the fact. */
+export interface ShardFailureOutput {
+  durationMs: number;
+  /** Last 64KB of the child's stdout/stderr (redacted). */
+  stdoutTail: string;
+  stderrTail: string;
+}
+
+export interface ShardFailureEvidence extends ShardFailureOutput {
+  shardId: string;
+  side: 'current' | 'baseline';
+  attempt: number;
+  files: string[];
+  exitCode: number | null;
+  signal: string | null;
+}
+
+export interface ShardRunMode {
+  /** OP FU — sorted round-robin into `count` shards, zero pre-measurement runs. Default off: the measured planner. */
+  fixedDistribution?: boolean;
 }
 
 export type ShardProcess = (cwd: string, files: readonly string[]) => {
@@ -23,8 +52,37 @@ export type ShardProcess = (cwd: string, files: readonly string[]) => {
   seconds?: number;
   /** Bounded, redacted process output for an abnormal exit before JUnit exists. */
   diagnostic?: string;
+  /** Present only when the process failed (exit≠0 · signal · no JUnit) — observation only, never part of the verdict. */
+  failure?: ShardFailureOutput;
 };
 
+export const SHARD_FAILURE_TAIL_BYTES = 64 * 1024;
+
+function outputTail(bytes: Uint8Array | undefined): string {
+  if (!bytes?.length) return '';
+  const tail = bytes.length > SHARD_FAILURE_TAIL_BYTES ? bytes.subarray(bytes.length - SHARD_FAILURE_TAIL_BYTES) : bytes;
+  return redactSecretText(Buffer.from(tail).toString('utf8'));
+}
+
+/** `<shardId>.failure.json` per failed shard (shard ids are already `shard-<n>`). Top level = the latest current-side
+ *  failure (else the latest baseline one); `failures` keeps every failed side/attempt. Returns the written paths. */
+export function writeShardFailureEvidence(dir: string, evidence: readonly ShardFailureEvidence[]): string[] {
+  if (!evidence.length) return [];
+  mkdirSync(dir, { recursive: true });
+  const byShard = new Map<string, ShardFailureEvidence[]>();
+  for (const item of evidence) byShard.set(item.shardId, [...(byShard.get(item.shardId) ?? []), item]);
+  const written: string[] = [];
+  for (const [shardId, failures] of byShard) {
+    const primary = [...failures].reverse().find((item) => item.side === 'current') ?? failures[failures.length - 1]!;
+    const path = join(dir, `${shardId.replace(/[^A-Za-z0-9._-]/g, '_')}.failure.json`);
+    const { side, attempt, ...fields } = primary;
+    writeFileSync(path, `${JSON.stringify({ ...fields, side, attempt, failures }, null, 2)}\n`);
+    debug.log('self-dev.shard', 'failure-evidence', { shardId, path, failures: failures.length, exitCode: primary.exitCode, signal: primary.signal });
+    written.push(path);
+  }
+  return written;
+}
+
 const DIAGNOSTIC_STREAM_LIMIT = 240;
 
 function boundedDiagnostic(stdout: Uint8Array, stderr: Uint8Array): string | undefined {
@@ -56,8 +114,17 @@ export function runShardedGateTests(
   run: ShardProcess = runBunShard,
   baselineWorktree: typeof withBaselineWorktree = withBaselineWorktree,
   budgetGiB = 8,
+  mode: ShardRunMode = {},
 ): ShardRunResult {
   if (!Number.isSafeInteger(count) || count < 1) throw new Error('invalid --shards count');
+  if (mode.fixedDistribution) {
+    // Opt-in: no per-file pre-measurement at all — the shard runs themselves (JUnit · rc · signal · baseline) decide.
+    let fixed: GateTestShard[];
+    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' };
+  }
   const rss = new Map<string, number>();
   const seconds = new Map<string, number>();
   const failedMeasurements: string[] = [];
@@ -90,11 +157,27 @@ export function runShardedGateTests(
   const measurementFailures = failedMeasurements.length || undefined;
   let shards: GateTestShard[];
   try {
-    shards = planGateTestShards(files, rss, seconds, budgetGiB, count);
+    shards = planSelfGateSpawnSeparatedShards(files, rss, seconds, budgetGiB, count);
   } catch (error) {
     return { aggregate: { status: 'unmeasured', retryShardIds: [] }, shards: [], attempts: [], reason: String(error), ...(measurementFailures ? { measurementFailures } : {}) };
   }
+  return { ...runPlannedShards(cwd, shards, baseRef, run, baselineWorktree), ...(measurementFailures ? { measurementFailures } : {}) };
+}
+
+/** Shared by the measured and the fixed planner: current + baseline per shard, one retry round, one aggregate. */
+function runPlannedShards(
+  cwd: string,
+  shards: GateTestShard[],
+  baseRef: string,
+  run: ShardProcess,
+  baselineWorktree: typeof withBaselineWorktree,
+): ShardRunResult {
   const attempts: GateShardAttempt[] = [];
+  const failureEvidence: ShardFailureEvidence[] = [];
+  const keepFailure = (shardId: string, side: ShardFailureEvidence['side'], attempt: number, files: readonly string[], result: ReturnType<ShardProcess>) => {
+    if (!result.failure) return;
+    failureEvidence.push({ shardId, side, attempt, files: [...files], exitCode: result.exitCode, signal: result.signal ?? null, ...result.failure });
+  };
   const baseline = baselineWorktree(cwd, baseRef, (dir) => {
     // LIGHT-RC-MEASURE ① — bun silently skips a path that is not in the baseline tree (exit 0), so a shard holding a
     // new test file could never yield a complete baseline JUnit. Run the baseline side on the files the base has; an
@@ -114,6 +197,8 @@ export function runShardedGateTests(
         }
         const current = runSafely(cwd, shard.files);
         const base = baselineFiles.length ? runSafely(dir, baselineFiles) : { exitCode: 0 };
+        keepFailure(shard.id, 'current', round, shard.files, current);
+        keepFailure(shard.id, 'baseline', round, baselineFiles, base);
         attempts.push({
           shardId: shard.id, attempt: round,
           currentJUnit: current.junit, baselineJUnit: base.junit,
@@ -128,22 +213,38 @@ export function runShardedGateTests(
     }
     return aggregateGateTestShards(shards, attempts);
   });
-  if ('retryShardIds' in baseline) return { aggregate: baseline, shards, attempts, ...(measurementFailures ? { measurementFailures } : {}) };
-  return { aggregate: { status: 'unmeasured', retryShardIds: shards.map((shard) => shard.id) }, shards, attempts, reason: baseline.log, ...(measurementFailures ? { measurementFailures } : {}) };
+  const evidence = failureEvidence.length ? { failureEvidence } : {};
+  if ('retryShardIds' in baseline) return { aggregate: baseline, shards, attempts, ...evidence };
+  return { aggregate: { status: 'unmeasured', retryShardIds: shards.map((shard) => shard.id) }, shards, attempts, reason: baseline.log, ...evidence };
+}
+
+export function selfGateShardTimeoutMs(files: readonly string[]): number {
+  const spawnFiles = files.filter(isGateSpawnLaneFile);
+  if (spawnFiles.length && spawnFiles.length !== files.length) throw new Error('self gate spawn lane mixed with regular tests');
+  return spawnFiles.length ? 120_000 : 300_000;
 }
 
 export function runBunShard(cwd: string, files: readonly string[]): ReturnType<ShardProcess> {
+  return runBunShardWithSpawn(cwd, files, Bun.spawnSync);
+}
+
+/** Child launch seam for verifying the actual command and process timeout. */
+export function runBunShardWithSpawn(cwd: string, files: readonly string[], spawn: typeof Bun.spawnSync): ReturnType<ShardProcess> {
+  const timeout = selfGateShardTimeoutMs(files);
+  const spawnLane = timeout === 120_000;
   const dir = mkdtempSync(join(tmpdir(), 'elanous-shard-junit-'));
   const report = join(dir, 'result.xml');
-  const isolated = prepareDeterministicChildEnvironment('elanous-shard-test-env-');
+  const isolated = prepareDeterministicChildEnvironment('elanous-shard-test-env-', { env: withGateTestEnv(process.env) });
   try {
     const measured = files.length === 1;
-    const args = ['test', '--reporter=junit', `--reporter-outfile=${report}`, ...files];
+    const args = ['test', ...(spawnLane ? ['--timeout=120000'] : []), '--reporter=junit', `--reporter-outfile=${report}`, ...files];
     const started = performance.now();
-    const result = Bun.spawnSync(['bun', ...args], {
-      cwd, env: isolated.env, stdout: 'pipe', stderr: 'pipe', timeout: 300_000,
+    const result = spawn(['bun', ...args], {
+      cwd, env: isolated.env, stdout: 'pipe', stderr: 'pipe', timeout,
     });
+    const durationMs = performance.now() - started;
     const junit = existsSync(report) ? readFileSync(report, 'utf8') : undefined;
+    const failed = result.exitCode !== 0 || !!result.signalCode || junit === undefined;
     return {
       exitCode: result.exitCode,
       signal: result.signalCode ? String(result.signalCode) : undefined,
@@ -151,7 +252,8 @@ export function runBunShard(cwd: string, files: readonly string[]): ReturnType<S
       ...(junit === undefined && (result.exitCode !== 0 || result.signalCode)
         ? { diagnostic: boundedDiagnostic(result.stdout, result.stderr) } : {}),
       rssMb: measured ? result.resourceUsage.maxRSS / (1024 * 1024) : undefined,
-      seconds: measured ? (performance.now() - started) / 1000 : undefined,
+      seconds: measured ? durationMs / 1000 : undefined,
+      ...(failed ? { failure: { durationMs: Math.round(durationMs), stdoutTail: outputTail(result.stdout), stderrTail: outputTail(result.stderr) } } : {}),
     };
   } finally {
     isolated.cleanup();

package/src/self-dev/spawn-lane-files.ts

@@ -0,0 +1,19 @@
+/** Real child/PTY test files. This list is shared by release and self gates. */
+export const GATE_SPAWN_LANE_FILES = [
+  'scripts/lib/tui-runshell-group-e2e.test.ts',
+  'scripts/lib/tui-streaming-e2e.test.ts',
+  'src/agent-mission/doc-guided-install.test.ts',
+  'src/dashboard/first-screen-band-wiring.test.ts',
+  'src/git-fs/spawn-discipline.test.ts',
+  'src/self-implement/run-ledger.test.ts',
+  'src/video-pipeline/recipes/reframe.test.ts',
+  'test/ch5730-watch-delivery.test.ts',
+  'test/cli-dev-command.test.ts',
+  'test/preview-terminal.test.ts',
+] as const;
+
+const SPAWN_FILES: ReadonlySet<string> = new Set(GATE_SPAWN_LANE_FILES);
+
+export function isGateSpawnLaneFile(file: string): boolean {
+  return SPAWN_FILES.has(file);
+}

package/src/self-implement/app-api-budget.ts

@@ -1,6 +1,7 @@
 import { execFile as execFileCb } from 'node:child_process';
 import { promisify } from 'node:util';
 import { debug } from '../debug/log.js';
+import { runGithubRemoteCall } from '../github/remote-call.js';
 import { releaseGitDiffPaths, releasePrFilePaths } from '../self-dev/release-path-guard.js';
 
 const defaultExecFile = promisify(execFileCb);
@@ -33,6 +34,25 @@ const GH_APP_CALLERS = {
 
 export type GhAppCaller = keyof typeof GH_APP_CALLERS;
 
+/** Fixed routes keep `--body`, `-f body=…`, labels, and tokens out of both log categories. */
+const GH_APP_ROUTES: Record<GhAppCaller, string> = {
+  'post-pr-comment-history': 'repos/{owner}/{repo}/issues/:number/comments',
+  'post-pr-comment': 'pr/:number/comment',
+  'find-pr-comment': 'repos/{owner}/{repo}/issues/:number/comments',
+  'edit-pr-comment': 'repos/{owner}/{repo}/issues/comments/:id',
+  'add-pr-label-list': 'label/list',
+  'add-pr-label-create': 'label/create',
+  'add-pr-label': 'pr/:number/edit',
+  'read-pr-files': 'repos/{owner}/{repo}/pulls/:number/files',
+};
+
+function observedGhMethod(args: readonly string[]): string | undefined {
+  if (args[0] !== 'api') return undefined; // gh pr/label may choose REST or GraphQL internally
+  const at = args.indexOf('--method');
+  const value = at >= 0 ? args[at + 1] : undefined;
+  return value && /^(GET|POST|PUT|PATCH|DELETE)$/.test(value) ? value : undefined;
+}
+
 export const APP_API_RATE_LIMIT_RETRY_CAP_MS = 15 * 60_000;
 
 export class AppApiRateLimitError extends Error {
@@ -83,14 +103,32 @@ export async function waitForAppApiRateLimitReset(
 export async function runGhApp(
   caller: GhAppCaller,
   args: readonly string[],
-  opts: { cwd: string; encoding: 'utf8'; timeout: number; maxBuffer?: number; env: NodeJS.ProcessEnv },
+  opts: { cwd: string; encoding: 'utf8'; timeout: number; maxBuffer?: number; env: NodeJS.ProcessEnv; retry?: number },
 ): Promise<{ stdout: string; stderr: string }> {
+  const { retry, ...execOpts } = opts;
   let stdout = '';
   let stderr = '';
   let status: number | undefined;
   let error: unknown;
   try {
-    const result = await execFileImpl('gh', args, opts);
+    const result = await runGithubRemoteCall({
+      kind: args[0] === 'api' ? 'rest' : 'gh-command',
+      caller: GH_APP_CALLERS[caller],
+      route: GH_APP_ROUTES[caller],
+      method: observedGhMethod(args),
+      host: 'unmeasured', // gh may select the repo host even when GH_HOST is set
+      runId: opts.env.ELANOUS_RUN_ID,
+      retry,
+    }, () => execFileImpl('gh', args, execOpts), {
+      status: ({ failed, error: callError }) => {
+        if (!failed) return undefined; // gh exit 0 is not an observed HTTP 200
+        const raw = (callError as { stderr?: unknown })?.stderr;
+        const failureStderr = typeof raw === 'string' ? raw : '';
+        const header = ghHeader(failureStderr, 'HTTP') ?? ghHeader(failureStderr, 'status');
+        const code = header ? Number.parseInt(header, 10) : NaN;
+        return Number.isFinite(code) ? code : undefined;
+      },
+    });
     stdout = result.stdout;
     stderr = result.stderr ?? '';
     status = 200;
@@ -102,12 +140,14 @@ export async function runGhApp(
     status = ghStatusCode(stderr, caught);
   }
   const remaining = ghHeader(stderr, 'X-RateLimit-Remaining');
-  debug.log('github.app-api', 'call', {
-    caller: GH_APP_CALLERS[caller],
-    endpoint: args.filter((arg) => !arg.startsWith('-')).at(-1) ?? 'gh',
-    status: status ?? 0,
-    remaining: remaining ?? '',
-  });
+  try {
+    debug.log('github.app-api', 'call', {
+      caller: GH_APP_CALLERS[caller],
+      endpoint: GH_APP_ROUTES[caller],
+      status: status ?? 0,
+      remaining: remaining ?? '',
+    });
+  } catch { /* observation cannot replace the gh result or its original error */ }
   if (error) {
     const text = `${stderr}\n${error instanceof Error ? error.message : String(error)}`;
     if (isAppApiRateLimitFailure(status, text, remaining)) {
@@ -138,7 +178,7 @@ export async function readPrFilesWithRateLimitFallback(input: {
     `repos/{owner}/{repo}/pulls/${input.number}/files`,
   ];
   const ghOpts = { cwd: input.cwd, encoding: 'utf8' as const, timeout: GIT_TIMEOUT, maxBuffer: 64 * 1024 * 1024, env };
-  const fromApi = async () => releasePrFilePaths(JSON.parse((await runGhApp('read-pr-files', endpoint, ghOpts)).stdout));
+  const fromApi = async (retry: number) => releasePrFilePaths(JSON.parse((await runGhApp('read-pr-files', endpoint, { ...ghOpts, retry })).stdout));
   const fromGit = async (): Promise<string[]> => {
     const base = input.base ?? 'origin/main';
     const { stdout } = await execFileImpl('git', ['diff', '--find-renames', '--name-status', '-z', `${base}...HEAD`], {
@@ -147,7 +187,7 @@ export async function readPrFilesWithRateLimitFallback(input: {
     return releaseGitDiffPaths(stdout);
   };
   try {
-    return await fromApi();
+    return await fromApi(0);
   } catch (error) {
     if (!(error instanceof AppApiRateLimitError)) throw error;
     try {
@@ -156,7 +196,7 @@ export async function readPrFilesWithRateLimitFallback(input: {
       const waited = await waitForAppApiRateLimitReset(error.resetAtMs, input.now?.() ?? Date.now(), input.sleep);
       if (!waited) throw error;
       try {
-        return await fromApi();
+        return await fromApi(1);
       } catch (retryError) {
         if (retryError instanceof AppApiRateLimitError) throw retryError;
         throw gitError;

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

@@ -8,6 +8,7 @@
 //   셸 검사는 `zsh -n`/`bash -n`(구문만·미실행). JSON/TOML 은 인-프로세스 파싱(외부 프로세스 불필요).
 
 import { spawnSync } from 'node:child_process';
+import { SPAWN_SYNC_MAX_BUFFER } from '../util/spawn-sync-output.js';
 import { readFileSync } from 'node:fs';
 import { basename } from 'node:path';
 
@@ -32,7 +33,7 @@ export function runConfigSyntaxGate(filePath: string): ConfigGateResult {
   const isBash = /(^|\.)(bashrc|bash_profile|bash_login|profile|bash_aliases)$/.test(name) || name.endsWith('.bash') || name.endsWith('.sh');
   if (isZsh || isBash) {
     const shell = isZsh ? 'zsh' : 'bash';
-    const r = spawnSync(shell, ['-n', filePath], { encoding: 'utf8', timeout: SHELL_TIMEOUT_MS });
+    const r = spawnSync(shell, ['-n', filePath], { encoding: 'utf8', timeout: SHELL_TIMEOUT_MS, maxBuffer: SPAWN_SYNC_MAX_BUFFER });
     // 셸 미설치(status=null·ENOENT) → 검사 불가로 skip(차단 아님·HITL diff 로 검증).
     if (r.error || r.status === null) return { passed: true, checked: false, label: `${shell} -n (미설치)`, log: String(r.error?.message ?? 'shell 없음') };
     return { passed: r.status === 0, checked: true, label: `${shell} -n`, log: `${r.stdout ?? ''}${r.stderr ?? ''}`.slice(-2000) };

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

@@ -1,4 +1,5 @@
 import { spawnSync } from 'node:child_process';
+import { SPAWN_SYNC_MAX_BUFFER } from '../util/spawn-sync-output.js';
 import { debug } from '../debug/log.js';
 
 type ExposeMode = 'warn' | 'strict';
@@ -15,7 +16,7 @@ export function runExposeGate(
   changed: readonly string[],
   mode: ExposeMode,
   run: (command: string, args: string[], cwd: string) => ProcessResult = (command, args, dir) => {
-    const result = spawnSync(command, args, { cwd: dir, encoding: 'utf8', timeout: 300_000 });
+    const result = spawnSync(command, args, { cwd: dir, encoding: 'utf8', timeout: 300_000, maxBuffer: SPAWN_SYNC_MAX_BUFFER });
     return { status: result.status, stdout: result.stdout ?? '', stderr: result.stderr ?? '', error: result.error };
   },
 ): ExposeResult {