elanous 0.2.29 → 0.2.32

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

@@ -1,3 +1,5 @@
+import { isGateSpawnLaneFile } from './spawn-lane-files.js';
+
 export interface GateTestShard {
   id: string;
   files: string[];
@@ -5,6 +7,35 @@ export interface GateTestShard {
   plannedSeconds: number;
 }
 
+/** A requested shard count cannot hold the measured files; more shards may make the same plan valid. */
+export class GateShardCapacityError extends Error {
+  constructor(message: string) { super(message); this.name = 'Error'; }
+}
+
+/** Keep real child/PTY tests out of ordinary self-gate shards, within the caller's shard budget. */
+export function planSelfGateSpawnSeparatedShards(
+  files: readonly string[],
+  rssMb: ReadonlyMap<string, number>,
+  seconds: ReadonlyMap<string, number>,
+  budgetGiB: number,
+  shardCount: number,
+): GateTestShard[] {
+  const unique = [...new Set(files)];
+  const spawn = unique.filter(isGateSpawnLaneFile);
+  const regular = unique.filter((file) => !isGateSpawnLaneFile(file));
+  if (!spawn.length || !regular.length) return planGateTestShards(unique, rssMb, seconds, budgetGiB, shardCount);
+  if (shardCount < 2) throw new GateShardCapacityError('self gate spawn lane needs at least two shards when regular and spawn tests coexist');
+  // Three spawn bundles are the normal lane width, not a memory ceiling. A 5 GiB spawn file cannot share an 8 GiB
+  // bundle with another such file; retain lane isolation while allowing the measured plan to grow past three.
+  const neededSpawn = planGateTestShards(spawn, rssMb, seconds, budgetGiB).length;
+  const spawnCount = Math.min(spawn.length, shardCount - 1, Math.max(3, neededSpawn));
+  const planned = [
+    ...planGateTestShards(regular, rssMb, seconds, budgetGiB, shardCount - spawnCount),
+    ...planGateTestShards(spawn, rssMb, seconds, budgetGiB, spawnCount),
+  ];
+  return planned.map((shard, index) => ({ ...shard, id: `shard-${index + 1}` }));
+}
+
 /** RSS values are the per-file rss_mb observations; the budget is in GiB (1 GiB = 1024 MB here). */
 export function planGateTestShards(
   files: readonly string[],
@@ -42,7 +73,7 @@ export function planGateTestShards(
     if (!shard) {
       const totalRssMb = sorted.reduce((sum, candidate) => sum + rssMb.get(candidate)!, 0);
       const largestRssMb = rssMb.get(sorted[0]!)!;
-      throw new Error(`test files exceed ${shardCount} shard memory budgets (files=${unique.length} · totalRssMb=${Math.round(totalRssMb)} · largestRssMb=${Math.round(largestRssMb)} · budgetMb=${capacity} · neededShards≥${Math.ceil(totalRssMb / capacity)})`);
+      throw new GateShardCapacityError(`test files exceed ${shardCount} shard memory budgets (files=${unique.length} · totalRssMb=${Math.round(totalRssMb)} · largestRssMb=${Math.round(largestRssMb)} · budgetMb=${capacity} · neededShards≥${Math.ceil(totalRssMb / capacity)})`);
     }
     shard.files.push(file);
     shard.plannedRssMb += rss;
@@ -50,3 +81,27 @@ export function planGateTestShards(
   }
   return shards;
 }
+
+/** OP FU (LAND-TRAIN-LIVE side) — opt-in `--fixed-shard-distribution`: no RSS/seconds measurement. Files are deduplicated,
+ *  sorted by code point (input-order independent) and dealt round-robin into at most `shardCount` shards; real child/PTY
+ *  tests keep their own lane exactly like the measured planner. Not a memory-safety guarantee — an over-budget shard
+ *  surfaces as its own run result (signal/exit/incomplete JUnit ⇒ unmeasured), never as a pass. No empty shards. */
+export function planFixedGateTestShards(files: readonly string[], shardCount: number): GateTestShard[] {
+  if (!Number.isSafeInteger(shardCount) || shardCount < 1) throw new Error('invalid shard count');
+  const sorted = [...new Set(files)].sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+  const deal = (subset: readonly string[], count: number): string[][] => {
+    const buckets: string[][] = Array.from({ length: Math.min(count, subset.length) }, () => []);
+    subset.forEach((file, index) => buckets[index % buckets.length]!.push(file));
+    return buckets;
+  };
+  const spawn = sorted.filter(isGateSpawnLaneFile);
+  const regular = sorted.filter((file) => !isGateSpawnLaneFile(file));
+  let groups: string[][];
+  if (!spawn.length || !regular.length) groups = deal(sorted, shardCount);
+  else {
+    if (shardCount < 2) throw new Error('self gate spawn lane needs at least two shards when regular and spawn tests coexist');
+    const spawnCount = Math.min(3, spawn.length, shardCount - 1);
+    groups = [...deal(regular, shardCount - spawnCount), ...deal(spawn, spawnCount)];
+  }
+  return groups.map((group, index) => ({ id: `shard-${index + 1}`, files: group, plannedRssMb: 0, plannedSeconds: 0 }));
+}

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

@@ -1,11 +1,13 @@
-import { existsSync, mkdtempSync, readFileSync, rmSync, statSync } from 'node:fs';
-import { tmpdir } from 'node:os';
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, statfsSync, statSync, writeFileSync } from 'node:fs';
+import { availableParallelism, freemem, 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 { GateShardCapacityError, planFixedGateTestShards, planSelfGateSpawnSeparatedShards, type GateTestShard } from './shard-plan.js';
+import { isGateSpawnLaneFile } from './spawn-lane-files.js';
 
 export interface ShardRunResult {
   aggregate: GateShardAggregate;
@@ -13,6 +15,70 @@ export interface ShardRunResult {
   attempts: GateShardAttempt[];
   reason?: string;
   measurementFailures?: number;
+  /** The measured RSS plan needed more bundles than the requested count. */
+  expandedFrom?: number;
+  /** A fixed plan selected explicitly, or after the measured plan exceeds host expansion capacity. */
+  distribution?: 'fixed' | 'fixed-cap-fallback';
+  fallbackReason?: string;
+  /** 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[];
+  /** Latest failed attempt's reason for each incomplete shard; copied into the gate artifact summary. */
+  unmeasuredByShard?: Record<string, string>;
+}
+
+/** 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;
+  /** Measured on the executing host; override only for deterministic planning tests. */
+  hostResources?: { cores: number; freeMemoryGiB: number; freeTmpGiB: number };
+}
+
+function hostResources(): ShardRunMode['hostResources'] | undefined {
+  try {
+    const tmp = statfsSync(tmpdir());
+    // Linux page cache is reclaimable. `freemem()` alone saw only ~10 GiB on a WSL host
+    // with 24 GiB MemAvailable and would incorrectly cap a two-shard plan at one.
+    let freeMemoryGiB = freemem() / (1024 ** 3);
+    if (process.platform === 'linux') {
+      const availableKiB = /^MemAvailable:\s+(\d+)\s+kB/m.exec(readFileSync('/proc/meminfo', 'utf8'))?.[1];
+      if (availableKiB) freeMemoryGiB = Number(availableKiB) / (1024 ** 2);
+    }
+    return {
+      cores: availableParallelism(),
+      freeMemoryGiB,
+      freeTmpGiB: Number(tmp.bavail) * Number(tmp.bsize) / (1024 ** 3),
+    };
+  } catch { return undefined; }
+}
+
+/** One expansion slot needs one CPU, one shard memory budget, and 1 GiB of free tmp space.
+ *  Explicitly requested shards remain the caller's choice; this only limits automatic growth. */
+export function maxAutomaticShardCount(requested: number, budgetGiB: number, resources: ShardRunMode['hostResources']): number {
+  if (!resources || !Number.isFinite(budgetGiB) || budgetGiB <= 0) return requested;
+  const limit = Math.min(
+    Math.floor(resources.cores),
+    Math.floor(resources.freeMemoryGiB / budgetGiB),
+    Math.floor(resources.freeTmpGiB),
+  );
+  return Math.max(requested, Number.isFinite(limit) ? limit : requested);
 }
 
 export type ShardProcess = (cwd: string, files: readonly string[]) => {
@@ -23,8 +89,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 +151,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[] = [];
@@ -88,13 +192,61 @@ export function runShardedGateTests(
     }
   }
   const measurementFailures = failedMeasurements.length || undefined;
-  let shards: GateTestShard[];
+  const fixedAtHostCap = (maxCount: number, reason: string): ShardRunResult => {
+    try {
+      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',
+        fallbackReason: reason, ...(measurementFailures ? { measurementFailures } : {}) };
+    } catch (error) {
+      return { aggregate: { status: 'unmeasured', retryShardIds: [] }, shards: [], attempts: [],
+        reason: `host-cap fixed fallback failed: ${String(error)}; measured plan: ${reason}`,
+        ...(measurementFailures ? { measurementFailures } : {}) };
+    }
+  };
+  let shards: GateTestShard[] | undefined;
+  let plannedCount = count;
   try {
-    shards = planGateTestShards(files, rss, seconds, budgetGiB, count);
+    const fileCount = new Set(files).size;
+    const totalRss = [...rss.values()].reduce((sum, value) => sum + value, 0);
+    const lowerBound = Number.isFinite(budgetGiB) && budgetGiB > 0 ? Math.ceil(totalRss / (budgetGiB * 1024)) : count;
+    plannedCount = Math.max(count, Math.min(fileCount, lowerBound));
+    // The requested count may exceed the number of files. Only expansion is bounded by file count.
+    const maxCount = Math.max(count, Math.min(fileCount, maxAutomaticShardCount(count, budgetGiB, mode.hostResources ?? hostResources())));
+    if (plannedCount > maxCount) return fixedAtHostCap(maxCount, `host shard expansion cap ${maxCount} < needed ${plannedCount} (requested ${count}, measured RSS sum ${Math.round(totalRss)} MiB, budget ${budgetGiB} GiB)`);
+    for (; plannedCount <= maxCount; plannedCount++) {
+      try { shards = planSelfGateSpawnSeparatedShards(files, rss, seconds, budgetGiB, plannedCount); break; }
+      catch (error) {
+        if (!(error instanceof GateShardCapacityError)) throw error;
+        if (plannedCount === maxCount) return fixedAtHostCap(maxCount, `host shard expansion cap ${maxCount} < needed ≥${maxCount + 1} (requested ${count}, ${error.message})`);
+      }
+    }
   } catch (error) {
     return { aggregate: { status: 'unmeasured', retryShardIds: [] }, shards: [], attempts: [], reason: String(error), ...(measurementFailures ? { measurementFailures } : {}) };
   }
+  if (!shards) return { aggregate: { status: 'unmeasured', retryShardIds: [] }, shards: [], attempts: [], reason: 'shard planning produced no result' };
+  if (plannedCount > count) debug.log('self-dev.shard', 'plan-expanded', {
+    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 } : {}) };
+}
+
+/** 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 +266,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 +282,62 @@ 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,
+    ...(baseline.retryShardIds.length ? { unmeasuredByShard: incompleteShardReasons(baseline.retryShardIds, attempts) } : {}),
+  };
+  const retryShardIds = shards.map((shard) => shard.id);
+  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)}`])),
+  };
+}
+
+function incompleteShardReasons(shardIds: readonly string[], attempts: readonly GateShardAttempt[]): Record<string, string> {
+  return Object.fromEntries(shardIds.map((id) => {
+    const latest = attempts.filter((attempt) => attempt.shardId === id).at(-1);
+    if (!latest) return [id, 'no shard attempt recorded'];
+    const side = (name: string, rc: number | null, signal: string | null | undefined, junit: string | undefined, diagnostic: string | undefined): string => {
+      const safeDiagnostic = diagnostic ? redactSecretText(diagnostic).replace(/[\r\n\t\x00-\x1f\x7f]+/g, ' ').slice(0, 500) : undefined;
+      return `${name}: exit ${rc ?? 'unavailable'}, signal ${signal ?? 'none'}, JUnit ${junit === undefined ? 'missing' : 'present'}`
+        + (safeDiagnostic ? `; ${safeDiagnostic}` : '');
+    };
+    const statuses = [
+      side('current', latest.currentExitCode, latest.currentSignal, latest.currentJUnit, latest.currentDiagnostic),
+      ...(latest.baselineFiles?.length === 0 ? [] : [side('baseline', latest.baselineExitCode, latest.baselineSignal, latest.baselineJUnit, latest.baselineDiagnostic)]),
+    ];
+    return [id, `${statuses.join(' · ')} · aggregate rejected (incomplete, malformed JUnit, or exit/JUnit mismatch)`];
+  }));
+}
+
+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 +345,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/elanous-tui-spawn.ts

@@ -13,6 +13,10 @@ import { selfDevRunsDir } from '../self-dev/run-store.js';
 import { syncTestConfig } from '../cli/config-test-sync.js';
 import { debug } from '../debug/log.js';
 
+/** = `PREAMBLE_SYNC_BLOCK_ENV`(dashboard/turn-preamble.ts). 그 모듈을 끌어오지 않으려 이름만 둔다 —
+ *  같은 값인지는 elanous-tui-spawn-identity.test.ts 가 잡는다. */
+export const PREAMBLE_SYNC_BLOCK_ENV = 'ELANOUS_TEST_PREAMBLE_SYNC_BLOCK_MS';
+
 export interface ElanousTuiSpawnOptions {
   readonly repoRoot: string;
   readonly cwd: string;
@@ -138,6 +142,13 @@ export function elanousTuiSpawnOptions(opts: ElanousTuiSpawnOptions): StartOpts
   }
   const { runId } = resolveRunIdentity({ explicit: opts.runId, inherited: opts.space.runId });
   const debugLevel = process.env.ELANOUS_DEBUG_LEVEL;
+  // ⭐ PTY 는 기동 때 잡은 로그인 셸 env 위에 «여기 적은 키만» 얹는다(registry `buildPtyEnv`) —
+  //    부모에 건 시험 seam env 는 적어 주지 않으면 자식에 안 닿는다(run-fbe85b7c · 자식 env 실측).
+  //    격리 자식에만 넘긴다. 자식도 운영 우주면 무시한다(`preambleSyncBlockMs`).
+  const preambleSyncBlock = isolated ? process.env[PREAMBLE_SYNC_BLOCK_ENV]?.trim() : undefined;
+  if (preambleSyncBlock) {
+    debug.log('self-implement.elanous-tui-spawn', 'test-seam-env', { name: PREAMBLE_SYNC_BLOCK_ENV, value: preambleSyncBlock });
+  }
   const controller = opts.controller ?? deriveChildController(process.env, process.pid);
   const channels = 'pty,inbox';
   debug.log('self-implement.elanous-tui-spawn', 'controller', { controller, channels });
@@ -149,6 +160,8 @@ export function elanousTuiSpawnOptions(opts: ElanousTuiSpawnOptions): StartOpts
     ],
     accessMode: 'auto',
     transitionPolicy: 'open',
+    // 안 넘길 때는 로그인 셸 캡처본에 그 변수가 있어도 지운다 — 비격리 자식에 seam 이 새지 않게.
+    ...(preambleSyncBlock ? {} : { unsetEnv: [PREAMBLE_SYNC_BLOCK_ENV] }),
     // ⭐ 대표 2026-08-02 — 자식 화면 기본 **160×40**. 가상 PTY라 사람 터미널과 무관하고,
     //    좁으면 렌더 블록이 화면을 넘어 **관측이 잘린다**(그 실측이 `--cols/--rows` 를 열게 했다).
     cols: opts.cols ?? 160,
@@ -164,6 +177,7 @@ export function elanousTuiSpawnOptions(opts: ElanousTuiSpawnOptions): StartOpts
       ELANOUS_CONTROL_CHANNELS: channels,
       ...observeOnlyFlagEnv(opts.observeOnly),
       ...(debugLevel === undefined ? {} : { ELANOUS_DEBUG_LEVEL: debugLevel }),
+      ...(preambleSyncBlock ? { [PREAMBLE_SYNC_BLOCK_ENV]: preambleSyncBlock } : {}),
       ...childRunContextEnv('self-build'),
       ...childNestEnv(),
       ...harnessSpaceEnv(opts.space.kind, opts.space.id, runId),

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 {