elanous 0.2.31 → 0.2.34

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/follow-up-placement.ts

@@ -0,0 +1,79 @@
+// FLEX-COORD-FU-PLACE — 후속 골 초안(FollowUpDraftRecord)에 판 배치·우선순위를 «제안»한다.
+// FLEX-RFC §A-⑧ L-d 조율자: 후속 골 칸의 판 배치·우선순위를 정하고 작업 지시서에
+// 자율 폭·조망 예산을 싣는다. 지금 초안은 판·우선순위 없이 shadow 로만 남는다.
+// 이 모듈은 순수 계산만 한다 — 쓰기 없음(제안만). 제안을 초안 기록에 싣고 live 일 때
+// placeCell 로 실제 판에 놓는 이어주기는 다음 조각이 recordFollowUpOnMerge·
+// recordFollowUpOnBlocked(follow-up-goals.ts)에서 한다.
+
+import type { PlacementPriority } from '../release-loop/placement.js';
+
+/** 배치 제안에 필요한 초안 칸 — FollowUpDraftRecord 의 구조 부분집합이라 그대로 건넬 수 있다. */
+export interface FollowUpPlacementRecord {
+  cellId: string;
+  depth: number;
+  ending?: 'blocked';
+}
+
+/** 원래 칸(제안의 기준) — 판은 `x.y.z` 체크리스트 판, 우선순위는 배치 우선순위다. */
+export interface FollowUpParentCell {
+  version: string;
+  priority: PlacementPriority;
+}
+
+/** 배치 제안 — 초안 기록에 실렸다가 live 배치(placeCell)의 입력이 된다. */
+export interface FollowUpPlacementProposal {
+  cellId: string;
+  version: string;
+  priority: PlacementPriority;
+  reason: string;
+  autonomyWidth: number;
+  groundingBudget: number;
+}
+
+/** 깊이 1 후속의 자율 폭(단계). 링크가 깊어질수록 1씩 좁히고 1 미만으로는 내려가지 않는다. */
+export const FOLLOW_UP_AUTONOMY_WIDTH_BASE = 3;
+/** 깊이 1 후속의 조망(그라운딩) 예산(근거 수). 깊이마다 절반씩 좁히고 2 미만으로는 내려가지 않는다. */
+export const FOLLOW_UP_GROUNDING_BUDGET_BASE = 8;
+
+const PRIORITY_STEPS: readonly PlacementPriority[] = ['P0', 'P1', 'P2'];
+
+/** 원래 칸의 다음 판 — 마지막 칸을 하나 올린다(release-tool 의 nextVersion 와 같은 계산). */
+export function nextReleaseVersion(version: string): string {
+  const [major, minor, patch] = version.split('.').map(Number);
+  return `${major}.${minor}.${patch! + 1}`;
+}
+
+/** 깊이 2 이상이면 원래 우선순위에서 한 단 낮춘다 — P2 밑으로는 내려가지 않는다. */
+function priorityForDepth(parent: PlacementPriority, depth: number): PlacementPriority {
+  const index = PRIORITY_STEPS.indexOf(parent);
+  if (index < 0 || depth < 2) return parent;
+  return PRIORITY_STEPS[Math.min(index + 1, PRIORITY_STEPS.length - 1)]!;
+}
+
+/** 후속이 반복될수록 자율은 줄고 조망은 좁힌다 — 같은 칸을 도는 사슬이 제자리 걸음으로 늙지 않게. */
+function budgetsForDepth(depth: number): { autonomyWidth: number; groundingBudget: number } {
+  const d = Math.max(1, depth);
+  return {
+    autonomyWidth: Math.max(1, FOLLOW_UP_AUTONOMY_WIDTH_BASE - (d - 1)),
+    groundingBudget: Math.max(2, Math.floor(FOLLOW_UP_GROUNDING_BUDGET_BASE / d)),
+  };
+}
+
+/**
+ * 후속 초안 한 건의 판 배치 제안 — 순수 함수, 아무것도 쓰지 않는다.
+ * 기본 = 원래 칸의 다음 판 ⊕ 같은 우선순위 · 깊이 2 이상이면 한 단 낮춤(P2 하한) ·
+ * ending 이 blocked 면 같은 판. 자율 폭·조망 예산은 깊이로 좁힌다.
+ */
+export function proposeFollowUpPlacement(record: FollowUpPlacementRecord, parent: FollowUpParentCell): FollowUpPlacementProposal {
+  const depth = Math.max(1, record.depth);
+  const blocked = record.ending === 'blocked';
+  const version = blocked ? parent.version : nextReleaseVersion(parent.version);
+  const priority = priorityForDepth(parent.priority, depth);
+  const { autonomyWidth, groundingBudget } = budgetsForDepth(depth);
+  const reason = `후속 깊이 ${depth} — ${blocked
+    ? `막힌 런의 후속은 원래 칸과 같은 판 ${version}`
+    : `원래 칸 ${parent.version} 의 다음 판 ${version}`} · ${depth >= 2
+    ? `우선순위 한 단 낮춤 ${parent.priority}→${priority}(하한 P2)`
+    : `같은 우선순위 ${priority}`} · 자율 폭 ${autonomyWidth} · 조망 예산 ${groundingBudget}`;
+  return { cellId: record.cellId, version, priority, reason, autonomyWidth, groundingBudget };
+}

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

@@ -55,6 +55,8 @@ export interface GateArtifactShard {
   files: string[];
   current: GateArtifactRun;
   baseline: GateArtifactRun;
+  /** Latest incomplete attempt only; the verdict remains unmeasured. */
+  unmeasuredReason?: string;
 }
 
 /** SIDE-VERIFY ③ — 판정 «정수»(OPT 열차 영수증 재료). 이름은 게이트 집계(`SelfGateCliResult.baseline` ·
@@ -87,6 +89,8 @@ export interface GateArtifactSummary extends GateArtifactCounts {
   /** 정수 칸 중 하나라도 null 일 때만 — 왜 못 셌나(한 줄). */
   countsUnavailableReason?: string;
   unmeasuredReason?: string;
+  /** Per-shard cause even when no process attempt was recorded. */
+  unmeasuredByShard?: Record<string, string>;
   /** 분할 없는 경로의 지금 쪽 `bun test` 종료 코드(그 경로엔 JUnit 이 없어 shardsDetail 이 비다). */
   unshardedRc?: number | null;
   artifactsUnavailable?: GateArtifactsUnavailable;
@@ -198,7 +202,12 @@ export function writeGateArtifacts(input: GateArtifactInput): { summaryPath: str
       writeFileSync(run.resultPath, runResultBody(run));
       return run;
     };
-    shardsDetail.push({ shardId: attempt.shardId, attempt: attempt.attempt, files, current: side('current'), baseline: side('baseline') });
+    shardsDetail.push({
+      shardId: attempt.shardId, attempt: attempt.attempt, files, current: side('current'), baseline: side('baseline'),
+      ...(input.sharded?.unmeasuredByShard?.[attempt.shardId] !== undefined
+        && attempt === input.sharded.attempts.filter((item) => item.shardId === attempt.shardId).at(-1)
+        ? { unmeasuredReason: input.sharded.unmeasuredByShard[attempt.shardId] } : {}),
+    });
   }
   const counts = input.counts ?? NULL_GATE_ARTIFACT_COUNTS;
   const summary: GateArtifactSummary = {
@@ -219,6 +228,7 @@ export function writeGateArtifacts(input: GateArtifactInput): { summaryPath: str
     ...(Object.values(counts).some((value) => value === null)
       ? { countsUnavailableReason: input.countsUnavailableReason ?? 'not recorded' } : {}),
     ...(input.unmeasuredReason !== undefined ? { unmeasuredReason: input.unmeasuredReason } : {}),
+    ...(input.sharded?.unmeasuredByShard !== undefined ? { unmeasuredByShard: input.sharded.unmeasuredByShard } : {}),
     ...(input.unshardedRc !== undefined ? { unshardedRc: input.unshardedRc } : {}),
     ...(input.artifactsUnavailable !== undefined ? { artifactsUnavailable: input.artifactsUnavailable } : {}),
   };
@@ -252,16 +262,17 @@ export function writeRemoteUnavailableGateArtifacts(
 
 // ── 원격 산출 회수 (SIDE-VERIFY-GATE-SHARDS ②) ──────────────────────────────
 // 원격 run 은 `$W` 임시 트리에서 돌고 끝나면 trap 이 `$W` 를 지운다(gate-remote.ts remoteScript). 그래서 원격 쪽
-// `--artifact-dir` 는 `$W` «밖»의 절대 경로(/tmp/elanous-gate-artifacts-<nonce>)로 준다 — run 이 끝나도 남고, 회수
+// `--artifact-dir` 는 `$W` «밖»의 호스트 디스크 경로(/var/tmp/elanous-gate-artifacts-<nonce>)로 준다 — run 이 끝나도 남고, 회수
 // ssh 가 읽은 뒤 지운다. 회수 프로토콜은 tar 없이 «이름 줄 · base64 한 줄» 쌍 ⊕ 끝 표지(잘림 판별).
 
-export const REMOTE_ARTIFACT_PREFIX = '/tmp/elanous-gate-artifacts-';
+export const REMOTE_ARTIFACT_PREFIX = '/var/tmp/elanous-gate-artifacts-';
 const FETCH_END = '__GATE_ARTIFACTS_END__';
 /** 다 보냈지만 원격 dir 을 못 지웠다 — 회수는 성공, 잔여는 경고로 드러낸다(조용히 남기지 않는다). */
 const FETCH_END_KEPT = '__GATE_ARTIFACTS_END_KEPT__';
 const FETCH_MISSING = '__GATE_ARTIFACTS_MISSING__';
 const FETCH_READ_FAILED = '__GATE_ARTIFACTS_READ_FAILED__';
-const remoteDirPattern = /^\/tmp\/elanous-gate-artifacts-[0-9a-f]{8,64}$/;
+// Legacy `/tmp` receipts remain readable for in-flight runs; new paths use host disk `/var/tmp`.
+const remoteDirPattern = /^\/(?:var\/)?tmp\/elanous-gate-artifacts-[0-9a-f]{8,64}$/;
 const artifactNamePattern = /^[A-Za-z0-9._-]+$/;
 export const REMOTE_ARTIFACT_FETCH_TIMEOUT_MS = 5 * 60_000;
 

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

@@ -5,6 +5,7 @@ import { dirname, join } from 'node:path';
 import { prepareDeterministicChildEnvironment } from '../../scripts/lib/deterministic-env.js';
 import { debug } 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 { reapStaleGateWorktrees } from './gate-baseline-reap.js';
 
@@ -28,6 +29,8 @@ export interface GateTestFailure {
   baselinePresence: GateBaselinePresence;
   attributedBy?: 'name-across-files' | 'copied-across-files';
   precondition?: GateFailurePrecondition;
+  /** 귀속 불일치 등으로 `unknown` 판정을 내린 이유. 판정 enum 은 바꾸지 않는다. */
+  unknownReason?: '귀속 불일치';
   /** 같은 gate 실행 안에서 같은 시험의 통과 기록이 있으면 `may-vary`로 보존한다. 타임아웃은 재실행 결과 변동성도 함께 표현한다. */
   timeoutVariability?: TimeoutVariability;
   /** 시간 초과한 정확한 시험이 base 로그에서는 통과해 자식 회귀로 귀속됐는지 나타낸다. */
@@ -189,6 +192,7 @@ 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);
@@ -197,6 +201,8 @@ export function baselineTimeoutForFiles(fileCount: number): number {
 export interface GatePassedTestEvidence {
   status: 'available' | 'unavailable';
   tests?: readonly Pick<GateTestFailure, 'file' | 'name'>[];
+  /** 기준선 JUnit 의 전체 testcase 목록(통과·실패·스킵 포함). 귀속 일치 확인에 쓴다. */
+  testCases?: readonly Pick<GateTestFailure, 'file' | 'name'>[];
   reason?: string;
 }
 
@@ -399,11 +405,15 @@ export function extractGateTestFailures(log: string): Array<Omit<GateTestFailure
 
 type GateTestIdentitySource = Pick<GateTestFailure, 'file' | 'name'>;
 
-function gateTestIdentity({ file, name }: GateTestIdentitySource): string | undefined {
+function gateTestName({ file, name }: GateTestIdentitySource): string | undefined {
   if (!file) return undefined;
   const prefix = `${file} > `;
-  const testName = name.startsWith(prefix) ? name.slice(prefix.length) : name;
-  return `${file}\u0000${testName}`;
+  return name.startsWith(prefix) ? name.slice(prefix.length) : name;
+}
+
+function gateTestIdentity(source: GateTestIdentitySource): string | undefined {
+  const testName = gateTestName(source);
+  return testName === undefined ? undefined : `${source.file}\u0000${testName}`;
 }
 
 function extractGatePassedTests(log: string): Array<Pick<GateTestFailure, 'file' | 'name'>> {
@@ -438,6 +448,44 @@ function decodeXmlEntities(value: string): string {
   })[entity]!);
 }
 
+/**
+ * 기준선 JUnit 의 전체 testcase(통과·실패·스킵 무관)를 gate identity 형태로 만든다.
+ * 귀속 일치 확인(#27844)에 쓴다 — 콘솔 실패 헤더의 파일 귀속이 JUnit 과 어긋나는지는 통과 목록만으로는 못 본다.
+ * 파일 = 감싼 testsuite 의 `file=`(바깥으로 상속) → 없으면 testcase `file=`(Bun 산출에선 둘이 같다). `classname` 은 describe 이름일 수 있어
+ * 파일로 쓰지 않는다 — 파일을 못 정하면 그 testcase 는 빼고(귀속 불일치 «양성 신호» 없음 = 기존 판정 유지).
+ * 이름 = 콘솔 `(fail)` 줄과 같은 꼴로 describe 경로를 앞에 붙인다 — 중첩 testsuite 이름들(파일 수준 제외),
+ * 중첩이 없는 평면 JUnit 이면 testcase `classname`(파일과 다를 때).
+ */
+export function extractJUnitTestCases(xml: string): Array<Pick<GateTestFailure, 'file' | 'name'>> {
+  const tests: Array<Pick<GateTestFailure, 'file' | 'name'>> = [];
+  const attribute = (attributes: string, key: string): string | undefined => {
+    const raw = attributes.match(new RegExp(`\\b${key}=(?:"([^"]*)"|'([^']*)')`))?.slice(1).find((value) => value !== undefined);
+    return raw === undefined ? undefined : decodeXmlEntities(raw);
+  };
+  const suites: Array<{ file: string | undefined; name: string | undefined }> = [];
+  const tokenRe = /<testsuite\b([^>]*?)(\/?)>|<\/testsuite\s*>|<testcase\b([^>]*?)(?:\/>|>[\s\S]*?<\/testcase>)/g;
+  for (const match of xml.matchAll(tokenRe)) {
+    const token = match[0];
+    if (token.startsWith('</testsuite')) { suites.pop(); continue; }
+    if (token.startsWith('<testsuite')) {
+      if (match[2] === '/') continue;
+      const attributes = match[1] ?? '';
+      suites.push({ file: attribute(attributes, 'file') ?? suites.at(-1)?.file, name: attribute(attributes, 'name') });
+      continue;
+    }
+    const attributes = match[3] ?? '';
+    const testName = attribute(attributes, 'name');
+    const file = suites.at(-1)?.file ?? attribute(attributes, 'file');
+    if (!testName || !file) continue;
+    const nested = suites.flatMap((suite) => suite.name && suite.name !== file && suite.name !== suite.file ? [suite.name] : []);
+    // 평면 JUnit(describe 가 testsuite 로 중첩되지 않음)은 classname 이 describe 이름이다 — 이름 복원에만 쓴다.
+    const classname = attribute(attributes, 'classname');
+    const describePath = nested.length > 0 ? nested : classname && classname !== file ? [classname] : [];
+    tests.push({ file, name: [file, ...describePath, testName].join(' > ') });
+  }
+  return tests;
+}
+
 export function extractJUnitPassedTests(xml: string): Array<Pick<GateTestFailure, 'file' | 'name'>> {
   const tests: Array<Pick<GateTestFailure, 'file' | 'name'>> = [];
   const testcaseRe = /<testcase\b([^>]*?)(?:\/>|>([\s\S]*?)<\/testcase>)/g;
@@ -461,6 +509,19 @@ function passedIdentities(tests: readonly Pick<GateTestFailure, 'file' | 'name'>
   }));
 }
 
+/** 기준선 JUnit 전체 testcase 를 시험명 → 파일 집합으로 묶는다. 귀속 불일치 양성 신호 확인에 쓴다. */
+function junitFilesByTestName(testCases: readonly Pick<GateTestFailure, 'file' | 'name'>[]): Map<string, Set<string>> {
+  const filesByTestName = new Map<string, Set<string>>();
+  for (const testCase of testCases) {
+    const testName = gateTestName(testCase);
+    if (testName === undefined || !testCase.file) continue;
+    const files = filesByTestName.get(testName) ?? new Set<string>();
+    files.add(testCase.file);
+    filesByTestName.set(testName, files);
+  }
+  return filesByTestName;
+}
+
 export function classifyGateTestFailures(
   worktreeLog: string,
   baselineLog: string | undefined,
@@ -505,6 +566,21 @@ export function classifyGateTestFailures(
       const identity = gateTestIdentity(failure);
       return identity ? [identity] : [];
     }));
+  // #27844: Bun 콘솔의 실패 헤더 귀속은 신뢰할 수 없다 — introduced 로 단정하기 전에
+  // 기준선 JUnit(testsuite file= · classname)으로 귀속을 확인한다. 기준선은 base worktree 라
+  // worktree 에서 새로 추가한 시험명을 담을 수 없어서 «이름이 없다»만으로는 귀속 불일치라 못
+  // 한다. 시험명이 «다른 파일»에 존재한다는 양성 신호가 있을 때만 귀속 불일치로 판정하고,
+  // 시험명이 귀속 파일의 JUnit 에 있으면, 또는 어디에도 없으면(신규 시험) 기존 판정을 유지한다.
+  const baselineJUnitFilesByTestName = baselinePassedEvidence?.status === 'available' && baselinePassedEvidence.testCases !== undefined
+    ? junitFilesByTestName(baselinePassedEvidence.testCases)
+    : undefined;
+  const junitAttributionMismatch = (failure: GateTestIdentitySource): boolean => {
+    if (!baselineJUnitFilesByTestName) return false;
+    const testName = gateTestName(failure);
+    if (testName === undefined || !failure.file) return false;
+    const files = baselineJUnitFilesByTestName.get(testName);
+    return files !== undefined && !files.has(failure.file);
+  };
   const comparable = worktreeFailures.filter((failure) => !isTimeoutDiagnostic(failure.diagnostic) && !matchedGatePrecondition(failure.diagnostic ?? '') && !(failure.file && missing.has(failure.file)) && baselineLog !== undefined && Boolean(failure.file));
   const comparison = classifyAgainstBaseline(baselineFailures, comparable, (failure) => failure.name);
   const preexisting = new Set(comparison.preexisting);
@@ -585,10 +661,18 @@ export function classifyGateTestFailures(
         debug.log('self-implement.gate', 'attributed-copy-across-files', { name: path, file: failure.file, baselineFile: original.file });
         return { ...failure, attribution: 'preexisting' as const, attributedBy: 'copied-across-files' as const, baselinePresence };
       }
+      if (junitAttributionMismatch(failure)) {
+        debug.log('self-implement.gate', 'attribution-mismatch', { name: failure.name, file: failure.file });
+        return { ...failure, attribution: 'unknown' as const, baselinePresence, unknownReason: '귀속 불일치' as const };
+      }
       return { ...failure, attribution: 'introduced' as const, baselinePresence };
     }
     if (baselineLog === undefined || !failure.file) return { ...failure, attribution: 'unknown' as const, baselinePresence };
     const attribution = preexisting.has(failure) ? 'preexisting' as const : 'introduced' as const;
+    if (attribution === 'introduced' && junitAttributionMismatch(failure)) {
+      debug.log('self-implement.gate', 'attribution-mismatch', { name: failure.name, file: failure.file });
+      return { ...failure, attribution: 'unknown' as const, baselinePresence, unknownReason: '귀속 불일치' as const };
+    }
     // 재실행 관측이 `pass`일 때만 흔들림으로 강등한다. 관측이 없거나 실패면 원래 귀속을 유지한다.
     if (attribution === 'introduced' && observationsFor(failure.name).includes('pass')) {
       return { ...failure, attribution: 'flaky-rerun' as const, baselinePresence };
@@ -705,12 +789,38 @@ function runIsolatedBunTest(cwd: string, args: string[], timeout: number): Proce
   try {
     // SIGKILL — a test that traps SIGTERM while blocked in a native wait never runs its handler, so spawnSync
     // waited forever and its drive grandchildren lived on as ppid=1 orphans (09-30 O1: 19 processes, up to 11h).
-    return spawnSync('bun', ['test', ...args], { cwd, env: isolated.env, encoding: 'utf8', timeout, killSignal: 'SIGKILL', maxBuffer: 32 * 1024 * 1024 });
+    const started = Date.now();
+    const result = spawnSync('bun', ['test', ...args], { cwd, env: isolated.env, encoding: 'utf8', timeout, killSignal: 'SIGKILL', maxBuffer: 32 * 1024 * 1024 });
+    debug.log('self-implement.gate-baseline', 'test-process-result', {
+      status: result.status, signal: result.signal, errorCode: (result.error as NodeJS.ErrnoException | undefined)?.code ?? null,
+      elapsedMs: Date.now() - started, timeoutMs: timeout, parentRssBytes: process.memoryUsage().rss,
+      cgroupMemoryCurrentBytes: cgroupMemoryBytes('memory.current'), cgroupMemoryLimitBytes: cgroupMemoryBytes('memory.max'),
+    });
+    return result;
   } finally {
     isolated.cleanup();
   }
 }
 
+function cgroupMemoryBytes(name: 'memory.current' | 'memory.max'): number | null {
+  try {
+    const raw = readFileSync(`/sys/fs/cgroup/${name}`, 'utf8').trim();
+    const value = Number(raw);
+    return Number.isSafeInteger(value) && value >= 0 ? value : null;
+  } catch { return null; }
+}
+
+/** 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 {
+  const reason = add.errorCode === 'ETIMEDOUT' ? 'worktree-add-timeout'
+    : add.signal ? `worktree-add-signal-${add.signal}` : 'worktree-add-failed';
+  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)`,
+    output: `${add.stdout}\n${add.stderr}`,
+  };
+}
+
 function junitReportTemporaryDirectory(): string {
   return process.env.ELANOUS_GATE_JUNIT_TMPDIR || tmpdir();
 }
@@ -730,7 +840,15 @@ function runBaselineBunTest(cwd: string, args: string[], timeout: number): Proce
       if (!existsSync(reportPath)) {
         return { ...process, passedTestEvidence: { status: 'unavailable', reason: 'JUnit passed-test evidence unavailable: reporter outfile was not created' } };
       }
-      return { ...process, passedTestEvidence: { status: 'available', tests: extractJUnitPassedTests(readFileSync(reportPath, 'utf8')) } };
+      const junitXml = readFileSync(reportPath, 'utf8');
+      return {
+        ...process,
+        passedTestEvidence: {
+          status: 'available',
+          tests: extractJUnitPassedTests(junitXml),
+          testCases: extractJUnitTestCases(junitXml),
+        },
+      };
     } catch (error) {
       return { ...process, passedTestEvidence: { status: 'unavailable', reason: `JUnit passed-test evidence unreadable: ${String(error)}` } };
     }
@@ -830,8 +948,16 @@ export function withBaselineWorktree<T>(cwd: string, baseRef: string, run: (base
   const baselineDir = mkdtempSync(join(tmpdir(), 'elanous-gate-baseline-'));
   let attached = false;
   try {
-    const add = runGitCommand(cwd, gateWorktreeAddArgs(baselineDir, baseRef), { encoding: 'utf8', timeout: 60_000 });
-    if (add.status !== 0) return classifyBaselineProcess({ status: add.status, stdout: add.stdout, stderr: add.stderr });
+    const started = Date.now();
+    const add = runGitCommand(cwd, gateWorktreeAddArgs(baselineDir, baseRef), { encoding: 'utf8', timeout: BASELINE_WORKTREE_ADD_TIMEOUT_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,
+      cgroupMemoryCurrentBytes: cgroupMemoryBytes('memory.current'), cgroupMemoryLimitBytes: cgroupMemoryBytes('memory.max'),
+    });
+    if (add.status !== 0) return classifyBaselineWorktreeAddFailure(add, elapsedMs);
     attached = true;
     linkDependencies(cwd, baselineDir);
     return run(baselineDir);
@@ -863,8 +989,16 @@ function withVerifyWorktree<T>(cwd: string, baseRef: string, run: (dir: string)
   let attached = false;
   try {
     dir = mkdtempSync(join(tmpdir(), 'elanous-gate-baseline-'));
-    const add = runGitCommand(cwd, gateWorktreeAddArgs(dir, baseRef), { encoding: 'utf8', timeout: 60_000 });
-    if (add.status !== 0) return classifyBaselineProcess({ status: add.status, stdout: add.stdout, stderr: add.stderr });
+    const started = Date.now();
+    const add = runGitCommand(cwd, gateWorktreeAddArgs(dir, baseRef), { encoding: 'utf8', timeout: BASELINE_WORKTREE_ADD_TIMEOUT_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,
+      cgroupMemoryCurrentBytes: cgroupMemoryBytes('memory.current'), cgroupMemoryLimitBytes: cgroupMemoryBytes('memory.max'),
+    });
+    if (add.status !== 0) return classifyBaselineWorktreeAddFailure(add, elapsedMs);
     attached = true;
     linkDependencies(cwd, dir);
     return run(dir);
@@ -1343,7 +1477,8 @@ export function formatGateBaselineNote(report: GateBaselineReport, unrunImporter
     + (report.missingAtBase > 0 ? `, missing-at-base=${report.missingAtBase}` : '');
   const lines = report.failures.map((failure) => `- ${failure.attribution}: ${failure.name}`
     + (includesBaselinePresence ? ` [baseline=${failure.baselinePresence}]` : '')
-    + (failure.precondition ? ` (${failure.precondition.name}; ${failure.precondition.remediation})` : ''));
+    + (failure.precondition ? ` (${failure.precondition.name}; ${failure.precondition.remediation})` : '')
+    + (failure.unknownReason ? ` (${failure.unknownReason})` : ''));
   const timedOutFailures = report.failures.filter((failure) => failure.attribution === 'flaky-timeout');
   const { mayVary, same, unknown } = report.timeoutVariabilityCounts;
   const timedOutLine = timedOutFailures.length > 0

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

@@ -859,7 +859,7 @@ function runSelfGateCliCore(cwd: string, options: SelfGateCliOptions, deps: Self
       : runShards(cwd, testFiles, selection.baseRef, shardCount);
     capture.sharded = sharded;
     capture.verdict = sharded.aggregate.status;
-    lines.push(`shards: ${sharded.shards.length} (${sharded.shards.map((shard) => `${shard.id}=${shard.files.join(',')}`).join('; ')})${sharded.measurementFailures ? ` · 측정 실패 ${sharded.measurementFailures}` : ''}${options.fixedShardDistribution ? ' · 고정 분배(사전 측정 없음)' : ''}`);
+    lines.push(`shards: ${sharded.shards.length} (${sharded.shards.map((shard) => `${shard.id}=${shard.files.join(',')}`).join('; ')})${sharded.expandedFrom !== undefined ? ` · RSS 예산상 ${sharded.expandedFrom}→${sharded.shards.length} 자동 확장` : ''}${sharded.measurementFailures ? ` · 측정 실패 ${sharded.measurementFailures}` : ''}${options.fixedShardDistribution ? ' · 고정 분배(사전 측정 없음)' : ''}${sharded.distribution === 'fixed-cap-fallback' ? ` · 호스트 상한 자동 고정 분배(${sharded.fallbackReason})` : ''}`);
     // 조각이 «못 쟀다»일 때 이유가 줄에 없으면 자리·시간 초과·죽음을 가를 수 없다(OP 10-09 light RC) — 종료 코드·신호를 같이 싣는다.
     const side = (code: number | null, signal: string | null | undefined, junit: string | undefined) => signal ? `signal ${signal}` : code === null ? 'exit ?' : `exit ${code}${junit === undefined ? ' · junit 없음' : ''}`;
     for (const attempt of sharded.attempts) {
@@ -886,7 +886,12 @@ function runSelfGateCliCore(cwd: string, options: SelfGateCliOptions, deps: Self
     let shardBaseline: SelfGateCliResult['baseline'];
     let unmeasuredReason: string | undefined;
     if (aggregate.status === 'unmeasured') {
-      unmeasuredReason = aggregate.retryShardIds.join(', ') || sharded.reason || 'no complete JUnit';
+      unmeasuredReason = sharded.reason
+        ? redactSecretText(sharded.reason).replace(/[\r\n\t\x00-\x1f\x7f]+/g, ' ').slice(0, 500)
+        : aggregate.retryShardIds.join(', ') || 'no complete JUnit';
+      for (const shardId of aggregate.retryShardIds) {
+        lines.push(`shard unmeasured: ${shardId} · ${sharded.unmeasuredByShard?.[shardId] ?? sharded.reason ?? 'cause unavailable'}`);
+      }
       lines.push(`shards: unmeasured (${unmeasuredReason})`);
       capture.unmeasuredReason = unmeasuredReason;
     }

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

@@ -88,6 +88,25 @@ export function extractGateRemoteFlags(argv: readonly string[]): GateRemoteFlags
   return out;
 }
 
+/** A remote importer sweep must not silently become one large test process. The measured planner may grow this
+ *  starting count further when the observed RSS needs more memory-bounded bundles. */
+export function remoteSelfGateArgv(input: {
+  changed?: boolean;
+  base?: string;
+  shards?: number;
+  fixedShardDistribution?: boolean;
+  includeImporters?: boolean;
+  artifactDir?: string;
+}, sha: (ref: string) => string): string[] {
+  const shards = input.shards ?? (input.includeImporters ? 2 : undefined);
+  return ['bun', 'bin/elanous.mjs', 'self', 'gate', '--local', ...(input.changed ? ['--changed'] : []),
+    ...(input.base ? ['--base', input.base === 'origin/main' ? input.base : sha(input.base)] : []),
+    ...(shards !== undefined ? ['--shards', String(shards)] : []),
+    ...(input.fixedShardDistribution ? ['--fixed-shard-distribution'] : []),
+    ...(input.includeImporters ? ['--include-importers'] : []),
+    ...(input.artifactDir ? ['--artifact-dir', input.artifactDir] : [])];
+}
+
 export interface GateDispatchDecision { mode: 'local' | 'remote'; host?: string; reason: string; load1: number }
 
 export function decideGateDispatch(input: { flags: Pick<GateRemoteFlags, 'remote' | 'local'>; settings: GateRemoteSettings; load1: number; env?: NodeJS.ProcessEnv }): GateDispatchDecision {
@@ -249,7 +268,13 @@ export function remoteScript(input: { mirror: string; commit: string; fetchShas:
     'umask 077',
     'PATH="$HOME/.bun/bin:/opt/homebrew/bin:$PATH"; export PATH',
     `infra() { echo "${INFRA}$1" >&2; exit 97; }`,
-    'W=$(mktemp -d /tmp/gate-remote-XXXXXXXX) || infra mktemp',
+    // `/tmp` is a 20 GiB tmpfs on WSL. One baseline checkout can exhaust it before any shard starts.
+    // Keep the entire child temp tree on the host disk; a low-space host yields infra fallback.
+    'TMPDIR=/var/tmp; export TMPDIR',
+    'free_kib=$(df -Pk "$TMPDIR" 2>/dev/null | awk \'NR==2 {print $4}\')',
+    'case "$free_kib" in ""|*[!0-9]*) infra disk-unmeasured;; esac',
+    'if [ "$free_kib" -lt 8388608 ]; then infra "disk-low:${free_kib}KiB"; fi',
+    'W=$(mktemp -d /var/tmp/elanous-gate-remote-XXXXXXXX) || infra mktemp',
     'export W',
     'trap \'rm -rf "$W"\' EXIT',
     ...payloadLines,
@@ -412,11 +437,13 @@ export interface DispatchOptions {
   /** Set when this invocation cannot be reproduced remotely (e.g. self gate without --base): automatic placement
    *  falls back with this reason; an explicit self gate --remote reports an unmeasured check instead. */
   localOnlyReason?: string;
-  /** Self gate CLI only: explicit --remote must never be measured by a local fallback. */
+  /** Explicit or caller-required remote measurement must never become a local fallback. */
   explicitRemoteOnly?: boolean;
+  /** Keep the remote checkout and TypeScript cache per host slot across repeated checks. */
+  stableCheckout?: boolean;
   /** Self gate CLI only: name the host for both automatic and explicit remote execution. */
   reportRemoteHost?: boolean;
-  /** Self gate's state universe; omitted by other callers and injected tests. */
+  /** Release gate host reservations shared by self gate and changed typecheck. */
   reservationRoot?: string;
   runLocal: () => number | Promise<number>;
   /** Called once with the final remote outcome (never on a local decision), before its output passes through or the
@@ -457,12 +484,14 @@ export async function dispatchHeavyCheck(opts: DispatchOptions, deps: DispatchDe
     return opts.runLocal();
   }
   let host = decision.host!;
-  const reservationRoot = opts.tool === 'self-gate' ? opts.reservationRoot ?? (deps.runner ? undefined : gateHostReservationRoot()) : undefined;
+  const reservationRoot = opts.tool === 'self-gate' || opts.tool === 'ci-typecheck-changed'
+    ? opts.reservationRoot ?? (deps.runner ? undefined : gateHostReservationRoot()) : undefined;
   if (reservationRoot) {
     const reservationHost = host.split('@').at(-1)!;
     const first = inspectReleaseGateHost(reservationRoot, reservationHost);
     if (first.status !== 'free') {
-      const alternate = reservationHost === 'node-b' ? 'node-c' : null;
+      // Changed typecheck has a fixed node-b placement; a release reservation makes it unmeasured.
+      const alternate = opts.tool === 'self-gate' && reservationHost === 'node-b' ? 'node-c' : null;
       const other = alternate ? inspectReleaseGateHost(reservationRoot, alternate) : null;
       if (alternate && other?.status === 'free') {
         debug.log('gate.remote', 'host-reserved-reroute', { from: host, to: alternate, reason: first.reason, status: first.status });
@@ -495,7 +524,7 @@ export async function dispatchHeavyCheck(opts: DispatchOptions, deps: DispatchDe
   let outcome: RemoteRunOutcome;
   for (;;) {
     try {
-      outcome = runOnRemote({ repo: opts.repo, host, mirror: settings.mirror, argv: opts.remoteArgv, refs: opts.refs, ...(opts.commit !== undefined ? { commit: opts.commit } : {}), installPwa: opts.installPwa, payloadFiles: opts.payloadFiles, hostCap }, deps.runner);
+      outcome = runOnRemote({ repo: opts.repo, host, mirror: settings.mirror, argv: opts.remoteArgv, refs: opts.refs, ...(opts.commit !== undefined ? { commit: opts.commit } : {}), installPwa: opts.installPwa, payloadFiles: opts.payloadFiles, stableCheckout: opts.stableCheckout, hostCap }, deps.runner);
     } catch (error) {
       outcome = { kind: 'infra', reason: `exception: ${error instanceof Error ? error.message : String(error)}` };
     }

package/src/self-implement/goal-author-identity.ts

@@ -0,0 +1,66 @@
+const IDENTITY_LINE = /^(agent|track|session|submitted):\s*(.*?)\s*$/i;
+
+export function repositoryIdentifiers(ask: string): string[] {
+  const lines = ask.split(/\r?\n/);
+  const metadata = leadingIdentityMetadata(ask);
+  const body = metadata.size
+    ? (lines[0]?.trim() === '---' ? lines.slice(lines.slice(1).findIndex((line) => line.trim() === '---') + 2) : lines.slice(lines.findIndex((line) => !IDENTITY_LINE.test(line))))
+    : lines;
+  return body
+    .filter((line) => !line.startsWith('Checkable requested criterion:'))
+    .join('\n')
+    .match(/[A-Za-z0-9]+(?:-[A-Za-z0-9]+)*/g) ?? [];
+}
+
+function leadingIdentityMetadata(ask: string): Map<string, string> {
+  const lines = ask.split(/\r?\n/);
+  let candidates: string[] = [];
+  if (lines[0]?.trim() === '---') {
+    const end = lines.slice(1).findIndex((line) => line.trim() === '---');
+    if (end < 0) return new Map();
+    candidates = lines.slice(1, end + 1);
+  } else if (IDENTITY_LINE.test(lines[0] ?? '')) {
+    candidates = lines.slice(0, lines.findIndex((line) => !IDENTITY_LINE.test(line)) === -1
+      ? lines.length
+      : lines.findIndex((line) => !IDENTITY_LINE.test(line)));
+  }
+
+  const metadata = new Map<string, string>();
+  for (const line of candidates) {
+    const match = IDENTITY_LINE.exec(line);
+    const value = match?.[2].trim();
+    if (match && value && !metadata.has(match[1].toLowerCase())) metadata.set(match[1].toLowerCase(), value);
+  }
+  return metadata;
+}
+
+/** `submitted` 는 KST 로 적는다 — 두 트랙이 같은 벽시계를 인용해야 이력이 정렬된다. */
+export function formatSubmittedAt(at: Date): string {
+  const parts = new Intl.DateTimeFormat('sv-SE', {
+    timeZone: 'Asia/Seoul', year: 'numeric', month: '2-digit', day: '2-digit',
+    hour: '2-digit', minute: '2-digit', hour12: false,
+  }).format(at);
+  return `${parts.replace(' ', ' ')} KST`;
+}
+
+/**
+ * 신원 머리말 — **값이 있는 줄만** 낸다.
+ *
+ * ⛔ 빈 값·`unknown` 을 찍지 않는다: 부재와 미지가 같은 값이 되면 조회가 거짓을 생산한다.
+ *    *"모르면 비워라"* 가 아니라 **"없으면 줄을 쓰지 마라"** 다.
+ * ⭐ 우선순위는 **ask 에 이미 적힌 값 > 환경/시계 유도**다(호출자가 명시한 것이 이긴다).
+ */
+export function identityLines(ask: string, cwd: string, env: NodeJS.ProcessEnv, at: Date): string[] {
+  const metadata = leadingIdentityMetadata(ask);
+  const tree = /[/\\](pilot|axon)[/\\]/i.exec(cwd)?.[1]?.toLowerCase();
+  const track = metadata.get('track') ?? (tree === 'pilot' ? 'S' : tree === 'axon' ? 'T' : undefined);
+  const agent = metadata.get('agent') ?? env.AI_AGENT?.trim();
+  const session = metadata.get('session') ?? env.CLAUDE_CODE_SESSION_ID?.trim();
+  const submitted = metadata.get('submitted') ?? formatSubmittedAt(at);
+  return [
+    agent && `agent: ${agent}`,
+    track && `track: ${track}`,
+    session && `session: ${session}`,
+    submitted && `submitted: ${submitted}`,
+  ].filter((line): line is string => Boolean(line));
+}