elanous 0.2.31 → 0.2.32

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

@@ -28,6 +28,8 @@ export interface GateTestFailure {
   baselinePresence: GateBaselinePresence;
   attributedBy?: 'name-across-files' | 'copied-across-files';
   precondition?: GateFailurePrecondition;
+  /** 귀속 불일치 등으로 `unknown` 판정을 내린 이유. 판정 enum 은 바꾸지 않는다. */
+  unknownReason?: '귀속 불일치';
   /** 같은 gate 실행 안에서 같은 시험의 통과 기록이 있으면 `may-vary`로 보존한다. 타임아웃은 재실행 결과 변동성도 함께 표현한다. */
   timeoutVariability?: TimeoutVariability;
   /** 시간 초과한 정확한 시험이 base 로그에서는 통과해 자식 회귀로 귀속됐는지 나타낸다. */
@@ -197,6 +199,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 +403,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 +446,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 +507,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 +564,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 +659,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 };
@@ -730,7 +812,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)}` } };
     }
@@ -1343,7 +1433,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,

package/src/self-implement/host-regate.ts

@@ -1,6 +1,6 @@
 import { spawnSync } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
-import { existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
+import { existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, rmSync, rmdirSync, symlinkSync, unlinkSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 import { debug } from '../debug/log.js';
@@ -26,9 +26,41 @@ export function needsPwaBuild(files: readonly string[], repoRoot: string, graph:
  * land worktree (TA-LAND-WORKTREE).
  */
 export function provideCheckoutDependencies(candidate: string, sourceRoot: string, dir: string, marker: string, install: (cwd: string) => void): void {
-  if (existsSync(join(candidate, dir, 'node_modules'))) return;
-  if (existsSync(join(sourceRoot, dir, 'node_modules', marker, 'package.json'))) {
-    symlinkSync(join(sourceRoot, dir, 'node_modules'), join(candidate, dir, 'node_modules'), 'dir');
+  const candidateModules = join(candidate, dir, 'node_modules');
+  const candidateMarker = join(candidateModules, marker, 'package.json');
+  const sourceModules = join(sourceRoot, dir, 'node_modules');
+  if (existsSync(candidateMarker)) return;
+  if (existsSync(join(sourceModules, marker, 'package.json'))) {
+    let stat: ReturnType<typeof lstatSync> | undefined;
+    try { stat = lstatSync(candidateModules); }
+    catch (error) { if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error; }
+    if (stat) {
+      if (stat.isSymbolicLink()) {
+        // A dangling or stale link can block symlinkSync with EEXIST; unlink only the link itself.
+        try { unlinkSync(candidateModules); }
+        catch (error) { if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error; }
+      } else if (stat.isDirectory() && readdirSync(candidateModules).length === 0) {
+        try { rmdirSync(candidateModules); }
+        catch (error) {
+          if ((error as NodeJS.ErrnoException).code === 'ENOTEMPTY') {
+            install(join(candidate, dir));
+            return;
+          }
+          if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
+        }
+      }
+      else {
+        install(join(candidate, dir));
+        return;
+      }
+    }
+    try {
+      symlinkSync(sourceModules, candidateModules, 'dir');
+    } catch (error) {
+      // Concurrent host regates may provision the same checked-out worktree. The first link wins;
+      // accept EEXIST only after confirming its package marker is now visible.
+      if ((error as NodeJS.ErrnoException).code !== 'EEXIST' || !existsSync(candidateMarker)) throw error;
+    }
   } else install(join(candidate, dir));
 }
 

package/src/self-implement/orchestrator.ts

@@ -155,6 +155,22 @@ import { AUTO_REVIEW_LABEL, resolveAutoReviewLabels } from './context-capsule.js
 import { GOAL_TYPES, extractVerbatimOriginalAsk, leadingGoalMetadata, parseAskFile, parseGoalType, type GoalType } from './goal-author.js';
 import { goalDocumentForReleaseNote, goalChecklistIds, prTitle } from './pr-title.js';
 export { goalChecklistIds, prTitle } from './pr-title.js';
+
+/** TA's card slot is carried by the Pod, independent of goal-author prose. */
+export function prChecklistLine(feature: string, goalFile?: string, slotId = process.env.ELANOUS_POD_SLOT_ID): string {
+  const slot = slotId?.trim();
+  if (slot && /^[A-Z][A-Z0-9]*(?:-[A-Z0-9]+)+$/.test(slot)) return `칸: ${slot}`;
+  const goalIds = goalChecklistIds(feature, goalFile);
+  return `칸: 미상\n골 ID: ${goalIds.join(' · ') || '없음'}`;
+}
+/** Preserve authored card lines as quoted prose; only the first line is machine readable. */
+function onePrChecklistLine(body: string): string {
+  let first = true;
+  return body.replace(/^칸:[^\n]*$/gm, (line) => {
+    if (first) { first = false; return line; }
+    return `> ${line}`;
+  });
+}
 import { renderRoundSummaryCard, type RoundSummaryEntry } from './round-summary-card.js';
 import { computeFlexSignals } from './flex-signals.js';
 import { resolveAdaptiveMaxReworkDecision, resolveEscalateTier, resolveEscalateTarget, buildReworkFeature, failIndicator, isRepeatedUnverifiedOnlyGateFailure, unverifiedRepeatKey, appendReworkHistory, truncateReworkHistoryByItem, applyReworkBudgetDecision, parseContractConflictRelaxation, parseReworkBudgetDecision, resolveReworkBudgetCarry, stripReworkBudgetHeaders, countConsecutiveMustFixIds, mergeReworkNotes, resolveReworkKind, type ReworkPlanRevision, type ReworkNotePart } from './rework-policy.js';
@@ -2305,7 +2321,7 @@ export interface SelfImplementResult {
   /** Additive hard-cap disposition; outcome remains the stable public terminal contract. */
   salvage?: 'launched' | 'parked';
   /** Rework stopped on exclusively baseline/flaky/precondition failures; do not retry this goal against the same base. */
-  terminationReason?: 'blocked-by-baseline';
+  terminationReason?: 'blocked-by-baseline' | 'goal-only-rework-exhausted';
   sessionId?: string;
   worktreePath?: string;
   branch?: string;
@@ -2615,13 +2631,13 @@ export function gateNotRunSection(gateLog?: string): string[] {
   return lines.length ? ['', '## Gate · 안 돈 소비자 시험(상한 초과)', ...lines.map((line) => `- ${line.replace(/^⚠️ caller test cap exceeded — not run: /, '')}`)] : [];
 }
 
-function prBody(feature: string, implSummary: string, gateLog?: string, review?: SelfImplementReview, reviewIntent?: string, autoReviewDeclineReasons?: readonly string[], evidence?: string, goalFile?: string, planRevision?: ReworkPlanRevision, releaseNote?: ReturnType<typeof harnessReleaseNote>, revertGuard?: RevertGuardResult): string {
+export function prBody(feature: string, implSummary: string, gateLog?: string, review?: SelfImplementReview, reviewIntent?: string, autoReviewDeclineReasons?: readonly string[], evidence?: string, goalFile?: string, planRevision?: ReworkPlanRevision, releaseNote?: ReturnType<typeof harnessReleaseNote>, revertGuard?: RevertGuardResult): string {
   const note = releaseNote ?? releaseNoteForRun(goalFile, feature);
   const relaxation = planRevision?.relaxation
     ? ['', '## 감독 수용 기준 완화', `- 대상: ${planRevision.relaxation.target}`, `- 이전: ${planRevision.relaxation.expected}`, `- 완화: ${planRevision.relaxation.replacement}`, `- 이유: ${planRevision.reason}`, `- 적용: ${planRevision.application?.status ?? 'failed'}${planRevision.application?.detail ? ` (${planRevision.application.detail})` : ''}`, ...(planRevision.disposition ? [`- 충돌 처분: ${planRevision.disposition}`] : [])]
     : [];
-  return [
-    `칸: ${goalChecklistIds(feature, goalFile).join(' · ') || '없음'}`,
+  return onePrChecklistLine([
+    prChecklistLine(feature, goalFile),
     '## 요청',
     ...(goalFile ? [`- 골 파일: ${formatGoalFileForPrBody(goalFile)}`] : []),
     feature.trim(),
@@ -2650,7 +2666,7 @@ function prBody(feature: string, implSummary: string, gateLog?: string, review?:
     ...relaxation,
     '',
     '🤖 self-implement 오케스트레이터 (elanous 자율 구현·리뷰-게이트 병합)',
-  ].join('\n');
+  ].join('\n'));
 }
 
 /**
@@ -2838,8 +2854,8 @@ export function formatBlockedDraftClassificationSection(
 }
 
 function blockedDraftPrBody(feature: string, implSummary: string, state: BlockedDraftPrState, goalFile?: string): string {
-  return [
-    `칸: ${goalChecklistIds(feature, goalFile).join(' · ') || '없음'}`,
+  return onePrChecklistLine([
+    prChecklistLine(feature, goalFile),
     BLOCKED_DRAFT_PR_HUMAN_JUDGMENT_ANCHOR,
     state.salvageStatusExpected
       ? BLOCKED_DRAFT_PR_SALVAGE_STATUS_INSTRUCTION
@@ -2886,8 +2902,10 @@ function blockedDraftPrBody(feature: string, implSummary: string, state: Blocked
       : [`- passed: ${state.typecheck.passed}`, ...(state.typecheck.log ? ['```', state.typecheck.log.trim().slice(0, 3000), '```'] : [])]),
     ...(state.review?.mustFix.length ? ['', '## 마지막 리뷰 must-fix', ...state.review.mustFix.map((item) => `- ${item}`)] : []),
     '',
-    prBody(feature, implSummary, undefined, state.review, undefined, undefined, undefined, goalFile, state.planRevision),
-  ].join('\n');
+    // The blocked body already carries the card line above; keep exactly one machine-readable line.
+    prBody(feature, implSummary, undefined, state.review, undefined, undefined, undefined, goalFile, state.planRevision)
+      .replace(/^칸: [^\n]*\n/, ''),
+  ].join('\n'));
 }
 
 type PreparedPrBody = {
@@ -5583,6 +5601,9 @@ async function runSelfImplementInner(
     };
   }
   let round = 0;
+  // A goal-only retry spends its one allowance for this run even if a later
+  // gate/review round removes the target diff and reaches the same disposition.
+  let goalOnlyReworkUsed = false;
   // PR이 열리기 전에 프로세스가 죽으면 PR 자체가 없으므로 잃을 대화도 없다. 따라서 파일로 영속화하지 않는다.
   const prCommentBuffer: string[] = [];
   // GitHub PR comment bodies are bounded; retain the RFC header and disclose omitted source rather than losing the whole record.
@@ -6948,6 +6969,75 @@ async function runSelfImplementInner(
     // ⭐ 성공 경로에서도 닫는다 — 이 호출은 끝났고, 이후 자식이 늦게 보내는 입력은
     //   「이 라운드의 재투입」이 아니다(다음 라운드는 자기 콜백을 새로 만든다).
     closeSupervisorInput();
+    // A child that actually worked and declared completion may still leave only the
+    // harness-seeded goal document. Give it one actionable implementation retry before
+    // the blocked-artifact path reaches the goal-only PR guard.
+    let goalOnlyReworkExhausted = false;
+    if (!impl.ok && impl.completionDisposition === 'completed-without-changes'
+      && impl.terminalStatus?.reached === true && impl.terminalStatus.timedOut === false
+      && !goalOnlyReworkUsed && round < effectiveMax && !hasCurrentProviderError() && !hasCurrentCredentialFailure()
+      && opts.goalFile) {
+      let targets: readonly string[] | undefined;
+      let goalDocument: string | undefined;
+      try {
+        goalDocument = readFileSync(opts.goalFile, 'utf8');
+        const declared = declaredPathsFromGoalDocumentText(goalDocument);
+        if (declared.readable && declared.paths.length > 0) targets = declared.paths;
+      } catch { /* unreadable scope is not grounds for an automatic retry */ }
+      let before: readonly string[] | undefined;
+      try { before = (s.changedFilesForGateRoute ?? changedFiles)(wt.path); } catch { /* unknown diff */ }
+      if (targets && goalDocument && before !== undefined) {
+        const eligible = (files: readonly string[]): string[] => files.filter(path =>
+          !harnessSeededPaths.includes(path) && !isHarnessTempArtifact(path)
+          && targets!.some(target => changedFileIsInsideDeclaredTarget(path, target)));
+        if (eligible(before).length === 0) {
+          goalOnlyReworkUsed = true;
+          const firstToolCalls = impl.toolCalls ?? null;
+          const retryRound = round + 1;
+          const retryNote = [
+            '[구현 재작업 · completed-without-changes]',
+            `대상 경로: ${targets.join(' · ')}`,
+            '원래 골의 완료 경계를 위 대상 경로에 구현하라. 해당 파일에 실제 변경을 남기고 바꾼 경로와 검증 결과를 RESULT: 한 줄에 적어라.',
+            '직전 자식은 완료를 선언했지만 대상 변경이 0개였다. 원래 골의 요구와 완료 경계를 다시 읽고 그 구현에 집중하라.',
+            '원래 골 문서(완료 경계 포함):',
+            goalDocument,
+          ].join('\n');
+          observe('implementation-goal-only-rework', { status: 'started', round: retryRound, targets, firstToolCalls, targetDiffCount: 0 });
+          progress('implementing', `대상 변경 0 — 구현 재작업 ${retryRound} 시작`);
+          onNodeEntry(node('rework'), retryRound);
+          onNodeEntry(node('implement'), retryRound);
+          const retryAbort = new AbortController();
+          const first = impl;
+          try {
+            impl = await stepTimeout(s.implement({
+              sessionId, cwd: wt.path, feature: `${feature}\n\n${retryNote}`, runId, shardIdentity,
+              signal: retryAbort.signal,
+              ...(harnessSeededPaths.length ? { harnessSeededPaths } : {}),
+              onSurfaceProgress: line => progress('implementing', line.trimEnd()),
+              roundContext: { round: retryRound, effectiveMax, previousRoundFailure: retryNote },
+              ...(opts.childLlm ? { childLlm: opts.childLlm } : {}),
+              ...(opts.documentReferences ? { documentReferences: opts.documentReferences } : {}),
+            }), T.implement, 'implement');
+          } catch (error) {
+            retryAbort.abort();
+            impl = { ok: false, summary: `goal-only-rework-exhausted: ${safeErrorDescription(error)}`, completionDisposition: first.completionDisposition };
+          }
+          let after: readonly string[] | undefined;
+          try { after = (s.changedFilesForGateRoute ?? changedFiles)(wt.path); } catch { /* unknown diff */ }
+          const targetDiff = after === undefined ? undefined : eligible(after);
+          const resultLine = /(?:^|\n)\s*RESULT:\s*\S/m.test(impl.evidenceTranscript ?? impl.summary);
+          const succeeded = impl.ok && !!targetDiff?.length && resultLine;
+          goalOnlyReworkExhausted = !succeeded;
+          observe('implementation-goal-only-rework', {
+            status: succeeded ? 'succeeded' : 'exhausted', round: retryRound, targets,
+            firstToolCalls, retryToolCalls: impl.toolCalls ?? null,
+            targetDiffCount: targetDiff?.length ?? null, diffMeasured: after !== undefined, resultLine,
+          }, succeeded ? {} : { level: 'warn' });
+          if (!succeeded) impl = { ...impl, ok: false, summary: `goal-only-rework-exhausted: ${impl.summary}` };
+          round = retryRound;
+        }
+      }
+    }
     // A finished child can leave edits without a commit. Measure them before any
     // diff/no-changes classification, and commit only paths declared in the goal.
     finishedChildCommitMissing = false;
@@ -7121,7 +7211,7 @@ async function runSelfImplementInner(
         toolCalls: impl.toolCalls ?? null,
       });
       progress('aborted', progressLine);
-      const pr = await preserveBlockedArtifacts({
+      const pr = goalOnlyReworkExhausted ? undefined : await preserveBlockedArtifacts({
         stage: 'aborted',
         reason: abort.reason,
         childSummary: abort.childSummary,
@@ -7132,7 +7222,7 @@ async function runSelfImplementInner(
         salvageStatusExpected: false,
         ...(abort.terminalStatus ? { terminalStatus: abort.terminalStatus } : {}),
       });
-      return { ok: false, stage: 'aborted', node: 'implement', ...resolveRunOutcome({ termination: 'abandoned' }), sessionId, worktreePath: wt.path, branch: wt.branch, quotaExhaustionAssessment: quotaExhaustionAssessmentForRun(), ...(impl.completionDisposition ? { completionDisposition: impl.completionDisposition } : {}), ...(pr ? { prUrl: pr.url, prNumber: pr.number } : {}), detail: impl.summary };
+      return { ok: false, stage: 'aborted', node: 'implement', ...resolveRunOutcome({ termination: 'abandoned' }), ...(goalOnlyReworkExhausted ? { terminationReason: 'goal-only-rework-exhausted' as const } : {}), sessionId, worktreePath: wt.path, branch: wt.branch, quotaExhaustionAssessment: quotaExhaustionAssessmentForRun(), ...(impl.completionDisposition ? { completionDisposition: impl.completionDisposition } : {}), ...(pr ? { prUrl: pr.url, prNumber: pr.number } : {}), detail: impl.summary };
     }
 
     if (finishedChildCommitMissing) {