elanous 0.2.37 → 0.2.38

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

@@ -1,10 +1,10 @@
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, statfsSync, statSync, writeFileSync } from 'node:fs';
-import { availableParallelism, freemem, tmpdir } from 'node:os';
+import { availableParallelism, freemem, loadavg, tmpdir, totalmem } 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 { withBaselineWorktree, withBaselineWorktreeAsync } from '../self-implement/gate-baseline.js';
 import { aggregateGateTestShards, type GateShardAttempt, type GateShardAggregate } from './shard-aggregate.js';
 import { GateShardCapacityError, planFixedGateTestShards, planSelfGateSpawnSeparatedShards, type GateTestShard } from './shard-plan.js';
 import { isGateSpawnLaneFile } from './spawn-lane-files.js';
@@ -27,6 +27,15 @@ export interface ShardRunResult {
   unmeasuredByShard?: Record<string, string>;
   /** git stderr tail (redacted · ≤2KB · one line) when the baseline worktree could not be added. */
   baselineStderrTail?: string;
+  /** Effective live pool width and its host-load/memory decision, for gate artifacts and diagnosis. */
+  concurrency?: number;
+  concurrencyReason?: string;
+  /** Wall time spent in singleton RSS samples and current+baseline bundles, respectively. */
+  measurementMs?: number;
+  bundleMs?: number;
+  /** Sum of process wall times across bundles (overlaps under concurrency). */
+  currentProcessMs?: number;
+  baselineProcessMs?: number;
 }
 
 /** What a failed shard process leaves behind so «test failure vs runner error» can be told apart after the fact. */
@@ -50,9 +59,11 @@ 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 };
+  hostResources?: { cores: number; freeMemoryGiB: number; freeTmpGiB: number; load1?: number };
   /** Observation after each bundle's first current+baseline attempt; never controls retries or verdict. */
   onShardComplete?: (progress: ShardRunProgress) => void;
+  /** Maximum concurrently active shard bundles. The default is three, bounded to one through four. */
+  concurrency?: number;
 }
 
 export interface ShardRunProgress {
@@ -73,14 +84,37 @@ function hostResources(): ShardRunMode['hostResources'] | undefined {
       const availableKiB = /^MemAvailable:\s+(\d+)\s+kB/m.exec(readFileSync('/proc/meminfo', 'utf8'))?.[1];
       if (availableKiB) freeMemoryGiB = Number(availableKiB) / (1024 ** 2);
     }
+    if (process.platform === 'darwin') {
+      // macOS freemem excludes reclaimable cache; node-b reported 5 GiB free of 512 GiB while
+      // memory_pressure reported 91% available. A freemem cap would silently serialize the gate.
+      const pressure = Bun.spawnSync(['memory_pressure', '-Q'], { stdout: 'pipe', stderr: 'ignore', timeout: 2_000 });
+      const percent = /System-wide memory free percentage:\s*(\d+(?:\.\d+)?)%/.exec(Buffer.from(pressure.stdout).toString('utf8'))?.[1];
+      if (pressure.exitCode === 0 && percent !== undefined && Number(percent) >= 0 && Number(percent) <= 100) {
+        freeMemoryGiB = totalmem() / (1024 ** 3) * Number(percent) / 100;
+      }
+    }
     return {
       cores: availableParallelism(),
       freeMemoryGiB,
       freeTmpGiB: Number(tmp.bavail) * Number(tmp.bsize) / (1024 ** 3),
+      load1: loadavg()[0],
     };
   } catch { return undefined; }
 }
 
+/** A conservative snapshot taken before sampling. Explicit 1 preserves the old serial child order. */
+export function resolveShardConcurrency(configured: number | undefined, resources: ShardRunMode['hostResources'], budgetGiB: number): { count: number; reason: string } {
+  if (!resources || !Number.isFinite(resources.cores) || resources.cores < 1) return { count: Math.max(1, Math.min(4, configured ?? 3)), reason: configured === undefined ? 'default; host load unavailable' : 'configured; host load unavailable' };
+  const loadRatio = Number.isFinite(resources.load1) ? resources.load1! / resources.cores : null;
+  const target = configured ?? (loadRatio !== null && loadRatio >= 0.8 ? 2
+    : loadRatio !== null && loadRatio <= 0.35 && resources.cores >= 8 ? 4 : 3);
+  const cpuCap = Math.max(1, Math.floor(resources.cores));
+  const memoryCap = Number.isFinite(resources.freeMemoryGiB) && Number.isFinite(budgetGiB) && budgetGiB > 0
+    ? Math.max(1, Math.floor(resources.freeMemoryGiB / budgetGiB)) : 4;
+  const count = Math.max(1, Math.min(4, target, cpuCap, memoryCap));
+  return { count, reason: `${configured === undefined ? 'adaptive' : `configured ${configured}`} · host load/cores ${loadRatio === null ? '?' : loadRatio.toFixed(2)} · free ${resources.freeMemoryGiB.toFixed(1)} GiB · shard budget ${budgetGiB} GiB` };
+}
+
 /** 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 {
@@ -104,6 +138,7 @@ export type ShardProcess = (cwd: string, files: readonly string[]) => {
   /** Present only when the process failed (exit≠0 · signal · no JUnit) — observation only, never part of the verdict. */
   failure?: ShardFailureOutput;
 };
+export type AsyncShardProcess = (cwd: string, files: readonly string[]) => Promise<ReturnType<ShardProcess>>;
 
 export const SHARD_FAILURE_TAIL_BYTES = 64 * 1024;
 
@@ -113,6 +148,29 @@ function outputTail(bytes: Uint8Array | undefined): string {
   return redactSecretText(Buffer.from(tail).toString('utf8'));
 }
 
+/** Drain a child pipe without retaining its entire output. Diagnostics need the opening context and failure tail. */
+async function boundedChildOutput(stream: ReadableStream<Uint8Array>, abort: AbortSignal): Promise<Uint8Array> {
+  const reader = stream.getReader();
+  const cancel = () => { void reader.cancel('child output drain timed out').catch(() => {}); };
+  abort.addEventListener('abort', cancel, { once: true });
+  const headLimit = 1024;
+  let head = new Uint8Array(0);
+  let tail = new Uint8Array(0);
+  let total = 0;
+  try {
+    for (;;) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      total += value.byteLength;
+      if (head.byteLength < headLimit) head = Buffer.concat([head, value.subarray(0, headLimit - head.byteLength)]);
+      tail = value.byteLength >= SHARD_FAILURE_TAIL_BYTES
+        ? value.slice(-SHARD_FAILURE_TAIL_BYTES)
+        : Buffer.concat([tail, value]).subarray(-SHARD_FAILURE_TAIL_BYTES);
+    }
+  } finally { abort.removeEventListener('abort', cancel); reader.releaseLock(); }
+  return total <= SHARD_FAILURE_TAIL_BYTES ? tail : Buffer.concat([head, tail]);
+}
+
 /** `<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[] {
@@ -321,6 +379,146 @@ function runPlannedShards(
   };
 }
 
+/** Runs planned bundles concurrently while retaining plan order in attempts and aggregate evidence. */
+export async function runShardedGateTestsAsync(
+  cwd: string,
+  files: readonly string[],
+  baseRef: string,
+  count = 2,
+  run: AsyncShardProcess = runBunShardAsync,
+  baselineWorktree: typeof withBaselineWorktreeAsync = withBaselineWorktreeAsync,
+  budgetGiB = 8,
+  mode: ShardRunMode = {},
+  measure: AsyncShardProcess = run,
+): Promise<ShardRunResult> {
+  if (mode.concurrency !== undefined && (!Number.isSafeInteger(mode.concurrency) || mode.concurrency < 1 || mode.concurrency > 4)) throw new Error('invalid shard concurrency (expected 1–4)');
+  const resources = mode.hostResources ?? hostResources();
+  const selectedConcurrency = resolveShardConcurrency(mode.concurrency, resources, budgetGiB);
+  const concurrency = selectedConcurrency.count;
+  debug.log('self-dev.shard', 'concurrency', { concurrency, reason: selectedConcurrency.reason });
+  const measurementStartedAt = performance.now();
+  const samples = new Map<string, ReturnType<ShardProcess>>();
+  if (!mode.fixedDistribution) {
+    const unique = [...new Set(files)];
+    let nextSample = 0;
+    const sampleWorker = async () => {
+      for (;;) {
+        const index = nextSample++;
+        if (index >= unique.length) return;
+        const file = unique[index]!;
+        try { samples.set(file, await measure(cwd, [file])); }
+        catch (error) {
+          debug.log('self-dev.shard', 'rss-measurement-failed', { file, error: redactSecretText(String(error)).slice(0, 500) });
+          samples.set(file, { exitCode: null });
+        }
+      }
+    };
+    await Promise.all(Array.from({ length: Math.min(concurrency, unique.length) }, () => sampleWorker()));
+  }
+  const measurementMs = Math.round(performance.now() - measurementStartedAt);
+  // Reuse the established measured/fixed planner and its host-cap fallback. The callback supplies a
+  // planning-only aggregate, so this phase never launches a shard or creates a baseline worktree.
+  const planningOnlyBaseline = (() => ({ status: 'passed' as const, retryShardIds: [] })) as unknown as typeof withBaselineWorktree;
+  const planned = runShardedGateTests(cwd, files, baseRef, count, (_cwd, selected) => samples.get(selected[0]!) ?? { exitCode: null },
+    planningOnlyBaseline, budgetGiB, { ...mode, ...(resources ? { hostResources: resources } : {}) });
+  if (planned.reason) return { ...planned, concurrency, concurrencyReason: selectedConcurrency.reason, measurementMs, bundleMs: 0 };
+  const shards = planned.shards;
+  const attempts: GateShardAttempt[] = [];
+  const failureEvidence: ShardFailureEvidence[] = [];
+  const bundlesStartedAt = performance.now();
+  let currentProcessMs = 0;
+  let baselineProcessMs = 0;
+  const baseline = await baselineWorktree(cwd, baseRef, async (dir) => {
+    const treeReadable = (() => { try { return statSync(dir).isDirectory(); } catch { return false; } })();
+    // Baseline membership is invariant for both rounds. Cache it before launching children.
+    const atBase = new Map(shards.map((shard) => [shard.id,
+      treeReadable ? shard.files.filter((file) => !absentAtBaseline(join(dir, file))) : [...shard.files]]));
+    const baselinePassCache = new Map<string, ReturnType<ShardProcess>>();
+    const totalFiles = new Set(shards.flatMap((shard) => shard.files)).size;
+    let completedShards = 0;
+    let completedFiles = 0;
+    let pending = shards;
+    for (let round = 1; round <= 2 && pending.length; round++) {
+      const roundAttempts = new Array<GateShardAttempt>(pending.length);
+      const roundEvidence = new Array<ShardFailureEvidence[]>(pending.length);
+      let next = 0;
+      const runSafely = async (location: string, selected: readonly string[]): Promise<ReturnType<ShardProcess>> => {
+        try { return await run(location, selected); }
+        catch (error) {
+          debug.log('self-dev.shard', 'bundle-runner-failed', { location, files: selected,
+            error: redactSecretText(String(error)).slice(0, 500) });
+          return { exitCode: null };
+        }
+      };
+      const worker = async () => {
+        for (;;) {
+          const index = next++;
+          if (index >= pending.length) return;
+          const shard = pending[index]!;
+          const baselineFiles = atBase.get(shard.id)!;
+          if (baselineFiles.length < shard.files.length) {
+            debug.log('self-dev.shard', 'baseline-files-absent', { shardId: shard.id, round,
+              absent: shard.files.filter((file) => !baselineFiles.includes(file)) });
+          }
+          const currentStartedAt = performance.now();
+          const current = await runSafely(cwd, shard.files);
+          currentProcessMs += performance.now() - currentStartedAt;
+          const cached = concurrency > 1 && round > 1 ? baselinePassCache.get(shard.id) : undefined;
+          if (cached) debug.log('self-dev.shard', 'baseline-cache-hit', { shardId: shard.id, round });
+          const baselineStartedAt = performance.now();
+          const base = cached ?? (baselineFiles.length ? await runSafely(dir, baselineFiles) : { exitCode: 0 });
+          baselineProcessMs += performance.now() - baselineStartedAt;
+          if (concurrency > 1 && baselineFiles.length && base.exitCode === 0 && !base.signal && base.junit) baselinePassCache.set(shard.id, base);
+          roundAttempts[index] = {
+            shardId: shard.id, attempt: round, currentJUnit: current.junit, baselineJUnit: base.junit,
+            currentExitCode: current.exitCode, baselineExitCode: base.exitCode,
+            currentSignal: current.signal, baselineSignal: base.signal,
+            currentDiagnostic: current.diagnostic, baselineDiagnostic: base.diagnostic,
+            baselineFiles, currentRoot: cwd, baselineRoot: dir,
+          };
+          roundEvidence[index] = [];
+          for (const [side, result, selected] of [
+            ['current', current, shard.files], ['baseline', base, baselineFiles],
+          ] as const) {
+            if (result.failure) roundEvidence[index]!.push({ shardId: shard.id, side, attempt: round,
+              files: [...selected], exitCode: result.exitCode, signal: result.signal ?? null, ...result.failure });
+          }
+          if (round === 1 && mode.onShardComplete) {
+            completedShards++;
+            completedFiles += shard.files.length;
+            try { mode.onShardComplete({ shardId: shard.id, completedShards, totalShards: shards.length,
+              completedFiles, totalFiles }); } catch { /* observation only */ }
+          }
+        }
+      };
+      await Promise.all(Array.from({ length: Math.min(concurrency, pending.length) }, () => worker()));
+      attempts.push(...roundAttempts);
+      for (const evidence of roundEvidence) failureEvidence.push(...evidence);
+      const retry = new Set(aggregateGateTestShards(shards, attempts).retryShardIds);
+      pending = shards.filter((shard) => retry.has(shard.id));
+    }
+    return aggregateGateTestShards(shards, attempts);
+  });
+  const evidence = failureEvidence.length ? { failureEvidence } : {};
+  const bundleMs = Math.round(performance.now() - bundlesStartedAt);
+  if ('retryShardIds' in baseline) return {
+    ...planned, aggregate: baseline, attempts, ...evidence, concurrency, concurrencyReason: selectedConcurrency.reason, measurementMs, bundleMs,
+    currentProcessMs: Math.round(currentProcessMs), baselineProcessMs: Math.round(baselineProcessMs),
+    ...(baseline.retryShardIds.length ? { unmeasuredByShard: incompleteShardReasons(baseline.retryShardIds, attempts) } : {}),
+  };
+  const retryShardIds = shards.map((shard) => shard.id);
+  const stderrTail = baseline.gitStderrTail;
+  const stderrPart = stderrTail ? ` · git stderr: ${stderrTail}` : '';
+  return {
+    ...planned, aggregate: { status: 'unmeasured', retryShardIds }, attempts, concurrency, concurrencyReason: selectedConcurrency.reason, measurementMs, bundleMs,
+    currentProcessMs: Math.round(currentProcessMs), baselineProcessMs: Math.round(baselineProcessMs),
+    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)}${stderrPart}`])),
+    ...(stderrTail ? { baselineStderrTail: stderrTail } : {}),
+  };
+}
+
 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);
@@ -381,6 +579,65 @@ export function runBunShardWithSpawn(cwd: string, files: readonly string[], spaw
   }
 }
 
+/** Nonblocking child runner; each bundle still owns its own deterministic environment and JUnit path. */
+export async function runBunShardAsync(cwd: string, files: readonly string[], drainTimeoutMs = 5_000): Promise<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-', { env: withGateTestEnv(process.env) });
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  let drainTimer: ReturnType<typeof setTimeout> | undefined;
+  const drainAbort = new AbortController();
+  try {
+    const args = ['test', ...(spawnLane ? ['--timeout=120000'] : []), '--reporter=junit', `--reporter-outfile=${report}`, ...files];
+    const started = performance.now();
+    const child = Bun.spawn(['bun', ...args], { cwd, env: isolated.env, stdout: 'pipe', stderr: 'pipe' });
+    let timedOut = false;
+    let drainTimedOut = false;
+    timer = setTimeout(() => { timedOut = true; child.kill('SIGKILL'); }, timeout);
+    const stdoutOutput = boundedChildOutput(child.stdout, drainAbort.signal);
+    const stderrOutput = boundedChildOutput(child.stderr, drainAbort.signal);
+    const exited = child.exited.then((code) => {
+      // Pipe draining can continue after process exit; a late timer must not relabel a clean exit as SIGKILL.
+      if (timer) clearTimeout(timer);
+      timer = undefined;
+      drainTimer = setTimeout(() => {
+        drainTimedOut = true;
+        debug.log('self-dev.shard', 'output-drain-timeout', { cwd, files, drainTimeoutMs });
+        drainAbort.abort();
+      }, drainTimeoutMs);
+      return code;
+    });
+    const [exitCode, stdoutBuffer, stderrBuffer] = await Promise.all([
+      exited,
+      stdoutOutput,
+      stderrOutput,
+    ]);
+    if (drainTimer) clearTimeout(drainTimer);
+    drainTimer = undefined;
+    const stdout = stdoutBuffer;
+    const stderr = stderrBuffer;
+    const durationMs = performance.now() - started;
+    const usage = child.resourceUsage();
+    const junit = existsSync(report) ? readFileSync(report, 'utf8') : undefined;
+    const signal = drainTimedOut ? 'DRAIN_TIMEOUT' : timedOut ? 'SIGKILL' : child.signalCode ? String(child.signalCode) : undefined;
+    const failed = exitCode !== 0 || !!signal || junit === undefined;
+    return {
+      exitCode, signal, junit,
+      ...(files.length === 1 ? { rssMb: usage ? usage.maxRSS / (1024 * 1024) : undefined, seconds: durationMs / 1000 } : {}),
+      ...(junit === undefined && (exitCode !== 0 || signal) ? { diagnostic: boundedDiagnostic(stdout, stderr) } : {}),
+      ...(failed ? { failure: { durationMs: Math.round(durationMs), stdoutTail: outputTail(stdout), stderrTail: outputTail(stderr) } } : {}),
+    };
+  } finally {
+    if (timer) clearTimeout(timer);
+    if (drainTimer) clearTimeout(drainTimer);
+    drainAbort.abort();
+    isolated.cleanup();
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
 /** GATE-REMOTE-SHARD-PLAN — identity of one remote shard. files/introducedFiles are optional: a caller that only relays
  *  identity (CLI wiring) passes none, while a planner-produced shard carries its file-level attribution. */
 export interface RemoteShardSpec {

package/src/self-implement/comment-only-source.ts

@@ -0,0 +1,54 @@
+import ts from 'typescript';
+
+/** Exclude importer expansion only when non-comment bytes and comment boundaries
+ * are identical. The TypeScript parser finds comments within JSDoc that a bare
+ * scanner can misread because their prose contains backticks. */
+export function isCommentOnlySourceChange(before: string, after: string, path: string): boolean {
+  if (before === after || !/\.(?:[cm]?[jt]sx?)$/.test(path)) return false;
+  const kind = /\.(?:[cm]?[jt]sx)$/.test(path) ? ts.ScriptKind.TSX
+    : /\.(?:[cm]?js)$/.test(path) ? ts.ScriptKind.JS : ts.ScriptKind.TS;
+  const collect = (source: string): { masked: string; comments: string[] } | null => {
+    const file = ts.createSourceFile(path, source, ts.ScriptTarget.Latest, true, kind);
+    if (file.parseDiagnostics.length) return null;
+    const ranges = new Map<number, ts.CommentRange>();
+    const add = (found: ts.CommentRange[] | undefined) => {
+      for (const range of found ?? []) ranges.set(range.pos, range);
+    };
+    const visit = (node: ts.Node) => {
+      add(ts.getLeadingCommentRanges(source, node.getFullStart()));
+      add(ts.getTrailingCommentRanges(source, node.getEnd()));
+      ts.forEachChild(node, visit);
+    };
+    visit(file);
+    const comments: string[] = [];
+    let masked = '';
+    let end = 0;
+    for (const range of [...ranges.values()].sort((left, right) => left.pos - right.pos)) {
+      if (range.pos < end) return null;
+      const comment = source.slice(range.pos, range.end);
+      comments.push(comment);
+      masked += source.slice(end, range.pos) + `\u0000C${range.kind}:${comment.match(/\r\n|\r|\n/g)?.join('') ?? ''}\u0000`;
+      end = range.end;
+    }
+    return { masked: masked + source.slice(end), comments };
+  };
+  const old = collect(before);
+  const current = collect(after);
+  if (!old || !current || old.masked !== current.masked || old.comments.length !== current.comments.length) return false;
+  const directive = /^(?:\/\/\/|\/\/[#@])|@|(?:eslint|istanbul|coverage|#__PURE__|__NO_SIDE_EFFECTS__)/i;
+  // Any unquoted @ may be a TypeScript/JSDoc tag, including newly introduced ones.
+  // A backticked example username such as `@example_bot` is prose, not a tag.
+  const semanticText = (comment: string) => comment.trim().replace(/`[^`\r\n]*`/g, '');
+  let changed = false;
+  for (let index = 0; index < old.comments.length; index++) {
+    const prior = old.comments[index]!;
+    const next = current.comments[index]!;
+    if (prior === next) continue;
+    changed = true;
+    // Ordinary inline block comments and line comments stay in the importer set.
+    // This exemption is intentionally limited to JSDoc prose edits.
+    if (!prior.startsWith('/**') || !next.startsWith('/**')) return false;
+    if (directive.test(semanticText(prior)) || directive.test(semanticText(next))) return false;
+  }
+  return changed;
+}

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

@@ -319,6 +319,12 @@ export function recordShadowDoctorReevaluation(runId: string, dir?: string): {
   const visit = entries[visitIndex]!;
 
   const evidence = typeof visit.data.evidence === 'string' ? visit.data.evidence.trim() : '';
+  // The pack selected for this run was observed before the visit. Keep its actual slice ids;
+  // an absent or malformed observation must remain unknown, never imply an empty pack.
+  const pack = entries.slice(0, visitIndex).reverse().find((entry) => entry.event === 'knowhow-pack');
+  const packIds = Array.isArray(pack?.data?.ids) && pack.data.ids.length > 0
+    && pack.data.ids.every((id: unknown) => typeof id === 'string' && id.length > 0)
+    ? pack.data.ids as string[] : 'unknown';
   const rx = evidence ? 're-evaluate-member' as const : null;
   const outcome = evidence ? 'shadow-recorded' as const : 'needs-evidence' as const;
   const data: Record<string, unknown> = {
@@ -326,6 +332,7 @@ export function recordShadowDoctorReevaluation(runId: string, dir?: string): {
     visitIndex,
     visit: { runId, from: visit.data.from, symptom: 'admit-starved', timestamp: visit.timestamp, evidence: evidence || null },
     diagnosis: evidence ? 'admit-starved-reported' : 'evidence-unmeasured',
+    knowhowPackSliceIds: packIds,
     rx,
     cost: { estimatedTokens: 0, usedTokens: 0 },
     outcome,
@@ -337,6 +344,24 @@ export function recordShadowDoctorReevaluation(runId: string, dir?: string): {
   return { status: 'recorded', ...(rx ? { rx } : {}), outcome, visitIndex };
 }
 
+/** Guardian shadow tick: prescribe only for ledgers with an admit-starved visit. Repeated ticks are idempotent. */
+export function recordPendingShadowDoctorReevaluations(dir?: string): { recorded: number; alreadyRecorded: number } {
+  let recorded = 0;
+  let alreadyRecorded = 0;
+  for (const ledger of listRunLedgers(dir ? { dir } : {}).matches) {
+    const visits = ledger.entries.flatMap((entry, index) => entry.event === 'doctor-visit' && entry.data.symptom === 'admit-starved' ? [index] : []);
+    if (visits.length === 0) continue;
+    const prescribed = new Set(ledger.entries.flatMap(entry => entry.event === 'doctor-rx' && entry.data.shadow === true
+      && typeof entry.data.visitIndex === 'number' ? [entry.data.visitIndex] : []));
+    if (visits.every(index => prescribed.has(index))) { alreadyRecorded++; continue; }
+    const result = recordShadowDoctorReevaluation(ledger.runId, ledger.ledgerDirectory);
+    if (result.status === 'recorded') recorded++;
+    else if (result.status === 'already-recorded') alreadyRecorded++;
+  }
+  debug.log('run-doctor', 'shadow-tick', { recorded, alreadyRecorded });
+  return { recorded, alreadyRecorded };
+}
+
 /** OP 손판정 한 건 — 시각과 결과만 받는다(그 밖의 입력은 받지 않는다). */
 export interface DoctorOpJudgment {
   /** 손판정 시각(ISO). */

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

@@ -85,7 +85,7 @@ export interface GateArtifactSummary extends GateArtifactCounts {
   verdict: string | null;
   /** 판정 줄(`tests: …` / `[gate-baseline] …` / `shards: unmeasured (…)`) 그대로. */
   verdictLine?: string;
-  timeoutRechecks?: readonly { name: string; file: string; result: 'pass' | 'timeout' | 'failure' | 'unknown'; elapsedMs: number; rawResultLine: string }[];
+  timeoutRechecks?: readonly { name: string; file: string; originalDiagnostic?: string; result: 'pass' | 'timeout' | 'failure' | 'unknown'; elapsedMs: number; rawResultLine: string }[];
   exitCode: number;
   /** 정수 칸 중 하나라도 null 일 때만 — 왜 못 셌나(한 줄). */
   countsUnavailableReason?: string;
@@ -130,7 +130,7 @@ export interface GateArtifactInput {
   testFiles: readonly string[];
   verdict: string | null;
   verdictLine?: string;
-  timeoutRechecks?: readonly { name: string; file: string; result: 'pass' | 'timeout' | 'failure' | 'unknown'; elapsedMs: number; rawResultLine: string }[];
+  timeoutRechecks?: readonly { name: string; file: string; originalDiagnostic: string; result: 'pass' | 'timeout' | 'failure' | 'unknown'; elapsedMs: number; rawResultLine: string }[];
   exitCode: number;
   /** 판정 정수(못 센 칸은 null ⊕ countsUnavailableReason). 안 주면 다섯 다 null · 이유 'not recorded' — 칸은 «늘» 쓴다. */
   counts?: GateArtifactCounts;

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

@@ -9,7 +9,7 @@ import type { GitRunResult } from '../git-fs/retry.js';
 import { linkWorktreeDependencies, worktreeAddTimeoutForRepo } from '../git-fs/worktree.js';
 import { reapStaleGateWorktrees } from './gate-baseline-reap.js';
 
-export type GateFailureAttribution = 'introduced' | 'preexisting' | 'unknown' | 'precondition-unmet' | 'flaky-timeout' | 'flaky-rerun' | 'timeout-recheck-passed';
+export type GateFailureAttribution = 'introduced' | 'preexisting' | 'unknown' | 'precondition-unmet' | 'flaky-timeout' | 'flaky-rerun' | 'load-timeout';
 export type GateBaselinePresence = 'present' | 'missing' | 'unknown';
 export type TimeoutVariability = 'may-vary' | 'same' | 'unknown';
 
@@ -73,12 +73,13 @@ export interface GateBaselineReport extends GateBaselineSummary {
   baselineStatus: BaselineProcessStatus;
   log: string;
   timeoutRechecks?: TimeoutRecheckRecord[];
-  timeoutRecheckPassed?: number;
+  loadTimeout?: number;
 }
 
 export interface TimeoutRecheckRecord {
   name: string;
   file: string;
+  originalDiagnostic: string;
   result: 'pass' | 'timeout' | 'failure' | 'unknown';
   elapsedMs: number;
   rawResultLine: string;
@@ -707,7 +708,7 @@ function summarizeGateBaseline(failures: readonly GateTestFailure[]): GateBaseli
       if (failure.attribution === 'flaky-rerun') {
         return { ...withPresence, flakyRerun: withPresence.flakyRerun + 1 };
       }
-      if (failure.attribution === 'timeout-recheck-passed') {
+      if (failure.attribution === 'load-timeout') {
         return withPresence;
       }
       const withTimeoutRegression = failure.timeoutRegression === 'passed-at-base'
@@ -741,10 +742,15 @@ export function recheckTimeoutOnlyIntroducedFailures(
   report: GateBaselineReport,
   run: (cwd: string, file: string, name: string, timeoutMs: number) => { observation?: TimeoutRerunObservation; elapsedMs: number; output: string } = runTimeoutRecheck,
 ): GateBaselineReport {
+  const timeoutOnlyDiagnostic = (diagnostic: string | undefined): boolean => {
+    if (!diagnostic) return false;
+    const lines = diagnostic.split('\n').map((line) => line.trim()).filter(Boolean);
+    return lines.length === 1 && /^\^ this test timed out after \d+ms\.?$/i.test(lines[0]!);
+  };
   const eligible = report.failures.length > 0
     && report.introduced === report.failures.length
     && report.failures.every((failure) => failure.attribution === 'introduced' && !!failure.file
-      && /\bthis test timed out after \d+ms\b/i.test(failure.diagnostic ?? ''));
+      && timeoutOnlyDiagnostic(failure.diagnostic));
   if (!eligible) return report;
   const records: TimeoutRecheckRecord[] = [];
   const failures = report.failures.map((failure) => {
@@ -754,19 +760,19 @@ export function recheckTimeoutOnlyIntroducedFailures(
     const { observation, elapsedMs, output } = run(cwd, failure.file, name, 60_000);
     const result = observation ?? 'unknown';
     const record: TimeoutRecheckRecord = {
-      name: failure.name, file: failure.file, result, elapsedMs,
+      name: failure.name, file: failure.file, originalDiagnostic: failure.diagnostic ?? '', result, elapsedMs,
       rawResultLine: flattenControlChars(redactSecretText(output)).slice(-500),
     };
     records.push(record);
     debug.log('gate.baseline', 'timeout-recheck', record);
-    return result === 'pass' ? { ...failure, attribution: 'timeout-recheck-passed' as const } : failure;
+    return result === 'pass' ? { ...failure, attribution: 'load-timeout' as const } : failure;
   });
   return {
     ...report,
     ...summarizeGateBaseline(failures),
     failures,
     timeoutRechecks: records,
-    timeoutRecheckPassed: failures.filter((failure) => failure.attribution === 'timeout-recheck-passed').length,
+    loadTimeout: failures.filter((failure) => failure.attribution === 'load-timeout').length,
   };
 }
 
@@ -1077,6 +1083,35 @@ export function withBaselineWorktree<T>(cwd: string, baseRef: string, run: (base
   }
 }
 
+/** Keep the baseline checkout attached until every asynchronous shard has settled. */
+export async function withBaselineWorktreeAsync<T>(cwd: string, baseRef: string, run: (baselineDir: string) => Promise<T>): Promise<T | BaselineProcessResult> {
+  reapBeforeGateAdd(cwd);
+  const baselineDir = mkdtempSync(join(tmpdir(), 'elanous-gate-baseline-'));
+  let attached = false;
+  try {
+    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 await run(baselineDir);
+  } catch (error) {
+    return { status: 'unknown', unknownReason: 'infrastructure-failure', childResponsibility: 'none', log: `baseline setup failed: ${String(error)}` };
+  } finally {
+    removeGateWorktree(cwd, baselineDir, !attached);
+    try { rmSync(baselineDir, { recursive: true, force: true }); }
+    catch (error) { debug.log('self-implement', 'gate.baseline.cleanup', { stage: 'exception', dir: baselineDir, error: String(error) }); }
+  }
+}
+
 function linkDependencies(cwd: string, dir: string): void {
   const dependencyLinks = linkWorktreeDependencies(cwd, dir, ['node_modules']);
   debug.log('self-implement', 'gate.baseline.dependencies', { cwd, dir, dependencyLinks });
@@ -1570,7 +1605,7 @@ export function formatGateBaselineNote(report: GateBaselineReport, unrunImporter
     + `, unknown=${report.unknown}, precondition-unmet=${report.preconditionUnmet}`
     + (report.timedOut > 0 ? `, timed-out=${report.timedOut}` : '')
     + (report.flakyRerun > 0 ? `, flaky-rerun=${report.flakyRerun}` : '')
-    + ((report.timeoutRecheckPassed ?? 0) > 0 ? `, timeout-recheck-passed=${report.timeoutRecheckPassed}` : '')
+    + ((report.loadTimeout ?? 0) > 0 ? `, load-timeout=${report.loadTimeout}` : '')
     + (runId ? `, run=${runId}` : '')
     + (report.missingAtBase > 0 ? `, missing-at-base=${report.missingAtBase}` : '');
   const lines = report.failures.map((failure) => `- ${failure.attribution}: ${failure.name}`
@@ -1592,7 +1627,7 @@ export function formatGateBaselineNote(report: GateBaselineReport, unrunImporter
       ? `\n[gate-baseline] rerun not-run=${report.rerunNotRun}`
       : '';
   const timeoutRecheckLines = report.timeoutRechecks?.length
-    ? `\n[gate.baseline.timeout-recheck] ${report.timeoutRechecks.map((item) => `${item.name}: ${item.result} elapsed=${item.elapsedMs}ms · ${item.rawResultLine}`).join('\n')}`
+    ? `\n[gate.baseline.timeout-recheck] ${report.timeoutRechecks.map((item) => `${item.name}: ${item.result} elapsed=${item.elapsedMs}ms · original=${flattenControlChars(item.originalDiagnostic).slice(-500)} · ${item.rawResultLine}`).join('\n')}`
     : '';
   return `${head}\n${lines.join('\n')}\n${report.log}`
     + timedOutLine