elanous 0.2.40 → 0.2.41

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

@@ -43,6 +43,11 @@ export interface SupervisorRound {
   mainSyncRelaunchFeatures?: string[];
   /** PR 없는 미분류 실패에 대해 실제 분해 실행기로 수복한 원래 골. 새 taskId에도 한 번 상한을 지킨다. */
   selfHealDecomposeFeatures?: string[];
+  /**
+   * NEEDS-HUMAN-REASON-REPAIR — 사유별 자가 수복 1회의 소진 기억(사유 → 그때 수복한 골 전문).
+   * 사유가 다르면 다른 시도다. 옛 원장엔 이 칸이 없다 = 「안 쟀다」이지 「시도했다」가 아니다.
+   */
+  selfHealRepairFeatures?: Partial<Record<NeedsHumanRepairReason, string[]>>;
   /**
    * Tasks of this round that ended `status=failed` without a PR. Omitted when there are none — and on older
    * history, which never measured it, so the no-PR streak guard reads it as «not measured» and stays off.
@@ -137,7 +142,96 @@ export interface SupervisorDecision {
   };
   oscillation?: { taskIds: string[]; helper: 'review-oscillation'; signature: string; repairGoals?: Record<string, string>; heldTaskIds?: string[] };
   pendingDecision?: 'attempt-care-escalation';
-  selfHeal?: { reason: 'supervisor-unclassified-decompose'; attempt: 1; taskIds: string[] };
+  selfHeal?: { reason: SelfHealReason; attempt: 1; taskIds: string[]; repairGoals?: Record<string, string> };
+}
+
+/**
+ * NEEDS-HUMAN-REASON-REPAIR — needs-human 으로 접히기 «전»에 한 번 수복해 볼 사유.
+ * 각 사유의 수복은 다르다: 없는 경로 → 재접지 · 범위 확장 → 좁히기 · 시간 초과 → 좁은 시험 · 조각 없음 → 조각 재걸기.
+ */
+export type NeedsHumanRepairReason = 'missing-path' | 'scope-expansion' | 'step-timeout' | 'no-piece';
+
+/** 선행 0.2.38 의 분해 수복 사유까지 포함한 자가 수복 사유 전체. */
+export type SelfHealReason = 'supervisor-unclassified-decompose' | `supervisor-${NeedsHumanRepairReason}`;
+
+const NEEDS_HUMAN_REPAIR_REASONS: readonly NeedsHumanRepairReason[] = ['missing-path', 'scope-expansion', 'step-timeout', 'no-piece'];
+
+/** 파일 부재의 두 코드 — 없는 경로(ENOENT)와 중간 성분이 파일인 경로(ENOTDIR). */
+const MISSING_PATH_ERROR_CODES: ReadonlySet<string> = new Set(['ENOENT', 'ENOTDIR']);
+
+const NEEDS_HUMAN_REPAIR_INSTRUCTION: Record<NeedsHumanRepairReason, string> = {
+  'missing-path': '없는 경로를 다시 접지한다 — 저장소에 있는 파일이나 골에 명시된 대상 경로만 고르고, 새 파일은 골이 신설을 요구할 때만 만든다',
+  'scope-expansion': '범위 확장을 좁힌다 — 대상 경로 밖으로 나간 변경을 되돌리고 골의 대상·완료 경계 안에서만 구현한다',
+  'step-timeout': '단계 예산을 넘겼다 — 좁은 시험 하나로 판정선을 먼저 세우고 나머지 실행은 그 뒤로 미룬다',
+  'no-piece': '조각 없이 실패했다 — 같은 골을 다시 걸되 완료 경계를 한 조각 분량으로 잘라 건다',
+};
+
+function normalizedRepairPath(path: string): string {
+  return path.replace(/^\.\//u, '').replace(/[),.;:]+$/u, '');
+}
+
+/** 경로가 범위 집합 안인가 — 정확 일치 · 디렉터리 접두 · (언급이 파일 이름뿐이면) 파일 이름 일치. */
+function pathWithinScope(path: string, scope: readonly string[]): boolean {
+  const p = normalizedRepairPath(path);
+  return scope.some((raw) => {
+    const s = normalizedRepairPath(raw);
+    if (s === p) return true;
+    if (s.endsWith('/') ? p.startsWith(s) : p.startsWith(`${s}/`)) return true;
+    return !p.includes('/') && s.split('/').at(-1) === p;
+  });
+}
+
+/**
+ * 범위 확장 — «밖»이라고 잰 변경 전부.
+ * ⛔ 대상 경로를 모르면 `changedFiles` 로는 «밖»을 단정하지 않는다(둘 다 쟀을 때만).
+ *    다만 실행 범위 가드가 «대상 밖»으로 직접 잰 값(`outsideTargetFiles`)은 그 자체가 측정이다.
+ */
+function expandedBeyondTargetPaths(result: SupervisorJobResult): string[] {
+  const measured = result.outsideTargetFiles ?? [];
+  const changed = result.changedFiles;
+  const targets = result.targetPaths;
+  const byScope = changed !== undefined && targets !== undefined && targets.length > 0
+    ? changed.filter((file) => !pathWithinScope(file, targets))
+    : [];
+  return [...new Set([...measured, ...byScope])];
+}
+
+/**
+ * needs-human 앞의 수복 사유 discriminator — 결과에 이미 실리는 판정 재료만 본다:
+ * 단계(`timed-out`) · 오류 코드(ENOENT/ENOTDIR) · 변경 파일 vs 골 대상 경로 · 분해 제안 조각 수.
+ * PR 이 있는 결과(사람이 볼 PR)와 재시도 재료가 있는 결과는 여기 대상이 아니다(undefined).
+ */
+export function needsHumanRepairReason(result: SupervisorJobResult): NeedsHumanRepairReason | undefined {
+  if (result.status !== 'failed' || result.prNumber !== undefined || result.prUrl) return undefined;
+  if (result.stage === 'timed-out') return 'step-timeout';
+  if (result.error?.code !== undefined && MISSING_PATH_ERROR_CODES.has(result.error.code)) return 'missing-path';
+  if (expandedBeyondTargetPaths(result).length > 0) return 'scope-expansion';
+  if ((result.decomposeProposal?.pieces.length ?? 0) < 2) return 'no-piece';
+  return undefined;
+}
+
+/** 사유별 수복 골 원문 — 사유의 수복 지시 + 골의 대상 경로 + 관측된 원인 + 원래 골. */
+export function needsHumanRepairGoal(result: SupervisorJobResult, reason: NeedsHumanRepairReason): string {
+  const outside = expandedBeyondTargetPaths(result);
+  const repairTargets = result.targetPaths?.length ? result.targetPaths : undefined;
+  return [
+    `[supervisor-needs-human-repair:${reason}] ${NEEDS_HUMAN_REPAIR_INSTRUCTION[reason]}`,
+    ...(repairTargets?.length ? [`대상 경로: ${repairTargets.join(', ')}`] : []),
+    ...(outside.length ? [`대상 경로 밖 변경: ${outside.join(', ')}`] : []),
+    ...(result.error?.message ? [`이전 실패: ${result.error.message.slice(0, 200)}`] : []),
+    result.feature,
+  ].join('\n');
+}
+
+/** 수복 사유가 붙은 자가 수복인가 — 선행 분해 수복('supervisor-unclassified-decompose')과 갈라낸다. */
+function needsHumanRepairDecisionReason(reason: SelfHealReason): NeedsHumanRepairReason | undefined {
+  return NEEDS_HUMAN_REPAIR_REASONS.find((candidate) => reason === `supervisor-${candidate}`);
+}
+
+/** 사유별 소진 기억에 이 조각이 이미 있는가 — 새 taskId 여도 골 전문으로 짝을 맞춘다. */
+function needsHumanRepairSpent(history: readonly SupervisorRound[], reason: NeedsHumanRepairReason, feature: string): boolean {
+  const key = resumeKey(feature);
+  return history.some((entry) => (entry.selfHealRepairFeatures?.[reason] ?? []).some((spent) => resumeKey(spent) === key));
 }
 
 export interface SupervisorLimits {
@@ -245,6 +339,11 @@ export type SupervisorJobResult = SelfDevJobResult & {
   reviewReason?: string;
   salvage?: 'launched' | 'parked';
   next?: SupervisorNext;
+  /**
+   * NEEDS-HUMAN-REASON-REPAIR — 실행 범위 가드가 «대상 경로 밖»으로 직접 잰 변경.
+   * 골이 대상 경로를 안 선언했어도 이 값은 측정이다 — `changedFiles` 와 달리 «밖»을 단정할 수 있다.
+   */
+  outsideTargetFiles?: readonly string[];
 };
 
 export function aggregateReviewTrend(results: readonly SelfDevJobResult[]): ReviewRework['trend'] | undefined {
@@ -360,6 +459,8 @@ export function decideNextRun(input: {
   reviewMustFixTrend?: ReviewRework['trend'];
   /** True: the rerun consumes the authored goal. False: it cannot, so oscillation stops for a human. Undefined: pure decision. */
   repairGoalExecution?: boolean;
+  /** Separate opt-in for needs-human reason repairs; omitted keeps the new repair execution disabled. */
+  needsHumanReasonRepairExecution?: boolean;
   /** 분해 제안을 실제 조각 실행으로 승격할 수 있는 supervisor 경로에만 true. */
   decompositionExecution?: boolean;
 }): SupervisorDecision {
@@ -550,7 +651,52 @@ export function decideNextRun(input: {
         why: `supervisor-unclassified-decompose (attempt: 1/1) — PR 없는 미분류 조각 ${taskIds.length}개를 실증된 분해 제안으로 한 번 재걸기`,
       };
     }
+    // NEEDS-HUMAN-REASON-REPAIR — 사람에게 접기 «전»에 사유별로 한 번 수복한다. 수복 골은 rerun 이 그대로 실행한다.
+    //   ⛔ 실행기가 선언되지 않았으면(repairGoalExecution !== true) 수복 대신 지금처럼 사람에게 간다.
+    if (input.repairGoalExecution === true && input.needsHumanReasonRepairExecution === true && round + 1 <= maxRounds) {
+      const repairable = activeResults.flatMap((result) => {
+        if (!t.needsHuman.includes(result.taskId)) return [];
+        if (!t.classifications.some((classification) => classification.taskId === result.taskId && classification.kind === 'unclassified')) return [];
+        const reason = needsHumanRepairReason(result);
+        if (reason === undefined || (result.targetPaths?.length ?? 0) === 0) return [];
+        return needsHumanRepairSpent(history, reason, result.feature) ? [] : [{ result, reason }];
+      });
+      const first = repairable[0];
+      const single = first !== undefined && repairable.length === 1 && t.needsHuman.every((id) => id === first.result.taskId)
+        ? first : undefined;
+      if (single) {
+        const taskIds = [single.result.taskId];
+        return {
+          ...base,
+          action: 'relaunch',
+          needsHuman: t.needsHuman.filter((id) => !taskIds.includes(id)),
+          selfHeal: {
+            reason: `supervisor-${single.reason}`,
+            attempt: 1,
+            taskIds,
+            repairGoals: { [single.result.taskId]: needsHumanRepairGoal(single.result, single.reason) },
+          },
+          why: `supervisor-${single.reason} (attempt: 1/1) — ${NEEDS_HUMAN_REPAIR_INSTRUCTION[single.reason]}`,
+        };
+      }
+    }
     if (t.needsHuman.length > 0) {
+      // 이미 한 번 수복했는데 같은 사유로 다시 섰다 — 사유·시도를 원문으로 남기고 사람에게 넘긴다.
+      const exhausted = activeResults.flatMap((result) => {
+        if (!t.needsHuman.includes(result.taskId)) return [];
+        const reason = needsHumanRepairReason(result);
+        if (reason === undefined || !needsHumanRepairSpent(history, reason, result.feature)) return [];
+        return [{ result, reason }];
+      });
+      if (exhausted.length > 0) {
+        return {
+          ...base,
+          action: 'stop',
+          stopReason: 'needs-human',
+          why: withGoalPlanRevisionObservation(`${exhausted.map(({ result, reason }) =>
+            `supervisor-${reason} (attempt: 1/1) — ${NEEDS_HUMAN_REPAIR_INSTRUCTION[reason]} 을 한 번 시도했으나 같은 조각이 다시 실패했다(${result.taskId})`).join(' · ')} · 사람이 볼 것 ${t.needsHuman.length}`),
+        };
+      }
       return {
         ...base,
         action: 'stop',
@@ -802,6 +948,9 @@ export function appendRound(
     if (result.durationMs === undefined) { unknownTimeTaskIds.add(result.taskId); continue; }
     lostTimeMsByTask[result.taskId] = (lostTimeMsByTask[result.taskId] ?? 0) + result.durationMs;
   }
+  const selfHealRepairReason = decision?.action !== 'stop' && decision?.selfHeal
+    ? needsHumanRepairDecisionReason(decision.selfHeal.reason)
+    : undefined;
   return [...history, {
     round: history.length,
     landed: countLanded(results),
@@ -826,6 +975,15 @@ export function appendRound(
         return feature === undefined ? [] : [feature];
       }),
     } : {}),
+    // NEEDS-HUMAN-REASON-REPAIR — 사유별 수복 1회 소진을 회차 원장에 남긴다(사유가 다르면 다른 시도).
+    ...(selfHealRepairReason !== undefined && decision?.selfHeal ? {
+      selfHealRepairFeatures: {
+        [selfHealRepairReason]: decision.selfHeal.taskIds.flatMap((id) => {
+          const feature = results.find((result) => result.taskId === id)?.feature;
+          return feature === undefined ? [] : [feature];
+        }),
+      },
+    } : {}),
     ...(decision?.action === 'add-repair-task' && decision.oscillation ? (() => {
       // Each repaired task is recorded under its original goal feature and, when a rerun runs the authored goal as
       // the piece's new feature (orchestrate), under that repair text too — so the repair's own oscillation stops.
@@ -1048,6 +1206,7 @@ export interface SuperviseRunOptions {
   sweepPendingMerges?: typeof sweepFrozenMerges;
   /** True only when rerun consumes `invocation.repairGoals`; omitted or false → a review oscillation stops for a human. */
   repairGoalExecution?: boolean;
+  needsHumanReasonRepairExecution?: boolean;
   /**
    * TASK-AGENT-SHADOW — 멈춤이 확정되면 판단부를 그림자로 부른다(기본 `recordTaskAgentShadowMove`).
    * `false` 면 끈다. 던져도 런의 결말은 바뀌지 않는다(fail-soft).
@@ -1097,6 +1256,7 @@ export async function rejudgeTerminalTaskCard(runId: string | null, deps: {
 export async function superviseRun(opts: SuperviseRunOptions): Promise<SupervisorJobResult[]> {
   let results = [...opts.initial];
   let history: SupervisorRound[] = [];
+  const maxRounds = opts.limits?.maxRounds ?? DEFAULT_MAX_ROUNDS;
 
   for (;;) {
     try {
@@ -1144,6 +1304,7 @@ export async function superviseRun(opts: SuperviseRunOptions): Promise<Superviso
       decompositionExecution: opts.promoteDecomposition !== undefined,
       // Undeclared = cannot run the repair goal: an add-repair-task would otherwise be a same-strategy relaunch.
       repairGoalExecution: opts.repairGoalExecution === true,
+      ...(opts.needsHumanReasonRepairExecution === undefined ? {} : { needsHumanReasonRepairExecution: opts.needsHumanReasonRepairExecution }),
       ...(aggregateReviewTrend(results) ? { reviewMustFixTrend: aggregateReviewTrend(results) } : {}),
       ...(opts.limits ? { limits: opts.limits } : {}),
       ...(observed.deployFindings ? { deployFindings: observed.deployFindings } : {}),
@@ -1154,6 +1315,21 @@ export async function superviseRun(opts: SuperviseRunOptions): Promise<Superviso
       } : {}),
     });
 
+    const reasonRepairSkipped = decision.action !== 'stop' || decision.stopReason !== 'needs-human' || history.length + 1 > maxRounds
+      ? [] : results.flatMap((result) => {
+      if (!decision.needsHuman.includes(result.taskId) || needsHumanRepairReason(result) === undefined) return [];
+      if (!decision.classifications.some((classification) => classification.taskId === result.taskId && classification.kind === 'unclassified')) return [];
+      const repairReason = needsHumanRepairReason(result)!;
+      if (needsHumanRepairSpent(history, repairReason, result.feature)) return [];
+      const reason = opts.repairGoalExecution !== true || opts.needsHumanReasonRepairExecution !== true
+        ? 'disabled' : 'no-target-paths';
+      if (reason === 'no-target-paths' && (result.targetPaths?.length ?? 0) > 0) return [];
+      return [{ taskId: result.taskId, reason }];
+    });
+    for (const skipped of reasonRepairSkipped) {
+      try { opts.observe?.('supervisor.reason-repair-skipped', skipped); } catch { /* fail-soft */ }
+    }
+
     // The supervisor consumes knowhow when it judges a failed piece. Keep the child prompt untouched.
     const failedPiece = results.find((result) => result.status === 'failed' && result.feature.trim());
     if (failedPiece) {
@@ -1188,7 +1364,13 @@ export async function superviseRun(opts: SuperviseRunOptions): Promise<Superviso
         decomposePromotion = { attempted: true, reason: `shim-failed: ${String(error)}` };
       }
     }
-    if (decision.selfHeal) {
+    if (decision.selfHeal && needsHumanRepairDecisionReason(decision.selfHeal.reason) !== undefined) {
+      // NEEDS-HUMAN-REASON-REPAIR — 수복 시도는 rerun 이 사유별 수복 골로 실행한다(아래 repairGoals).
+      //   여기서는 «한 번 시도했다»를 관측하고 relaunch 를 유지한다 — 실패는 다음 라운드 판정이 사유·시도 원문으로 접는다.
+      try { opts.observe?.('supervisor-self-heal', { runId, reason: decision.selfHeal.reason,
+        attempt: decision.selfHeal.attempt, taskIds: decision.selfHeal.taskIds,
+        outcome: 'relaunching', repairGoalTasks: Object.keys(decision.selfHeal.repairGoals ?? {}) }); } catch { /* fail-open */ }
+    } else if (decision.selfHeal) {
       const promoted = decomposePromotion.attempted && (decomposePromotion.pieceCount ?? 0) >= 2;
       try { opts.observe?.('supervisor-self-heal', { runId, reason: decision.selfHeal.reason,
         attempt: decision.selfHeal.attempt, taskIds: decision.selfHeal.taskIds,
@@ -1309,7 +1491,7 @@ export async function superviseRun(opts: SuperviseRunOptions): Promise<Superviso
     // but their results stay in the round so the human hand-off (and the final review-oscillating stop) keeps them.
     const held = decision.oscillation?.heldTaskIds ?? [];
     const heldResults = results.filter((result) => held.includes(result.taskId));
-    const repairGoals = { ...decision.relaunchGoals, ...decision.oscillation?.repairGoals };
+    const repairGoals = { ...decision.relaunchGoals, ...decision.selfHeal?.repairGoals, ...decision.oscillation?.repairGoals };
     const rerunResults = await opts.rerun(held.length ? results.filter((result) => !held.includes(result.taskId)) : results,
       { relaunch: true, ...(Object.keys(repairGoals).length > 0 ? { repairGoals } : {}) });
     results = [...rerunResults, ...heldResults.filter((heldResult) => !rerunResults.some((result) => result.taskId === heldResult.taskId))];

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

@@ -114,6 +114,9 @@ export interface SelfDevJobResult {
   completionDisposition?: string;
   /** Abandoned-run classification from the child. Independent of completionDisposition. */
   failureClassification?: AbandonedClassification;
+  /** Basis and explicit terminal reason are kept separate from the classification label. */
+  classificationBasis?: string;
+  terminationReason?: string;
   /** Provider failure evidence from the child result; absent when unobserved. */
   providerErrors?: { count: number; provider: string; category: 'quota' | 'credential' | 'request' | 'other' };
   /** Stable child run identity used to join its run-ledger proposal. */

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

@@ -78,6 +78,8 @@ export interface GateArtifactSummary extends GateArtifactCounts {
   head40: string | null;
   base40: string | null;
   envKey: string;
+  /** Seat self-gate marker observed at process entry (true only for ELANOUS_TRAIN_GATE=1). */
+  trainGate?: boolean;
   shards: number;
   cohort: string[];
   shardsDetail: GateArtifactShard[];
@@ -128,6 +130,7 @@ export interface GateArtifactInput {
   head40: string | null;
   base40: string | null;
   envKey: string;
+  trainGate?: boolean;
   testFiles: readonly string[];
   verdict: string | null;
   verdictLine?: string;
@@ -218,6 +221,7 @@ export function writeGateArtifacts(input: GateArtifactInput): { summaryPath: str
     head40: input.head40,
     base40: input.base40,
     envKey: input.envKey,
+    ...(input.trainGate !== undefined ? { trainGate: input.trainGate } : {}),
     shards: input.sharded ? input.sharded.shards.length : 0,
     cohort: sorted(input.testFiles),
     shardsDetail,
@@ -251,12 +255,14 @@ export function writeRemoteUnavailableGateArtifacts(
   reason: 'remote-unsupported' | 'remote-fetch-failed',
   resolveRev: RevResolver = defaultRevResolver(cwd),
   envKey: () => string = defaultGateEnvKey,
+  trainGate?: boolean,
 ): { summaryPath: string; junitFiles: string[] } {
   return writeGateArtifacts({
     dir: resolveArtifactDir(dir, cwd),
     head40: resolveRev('HEAD'),
     base40: baseRef ? resolveRev(baseRef) : null,
     envKey: envKey(),
+    trainGate,
     testFiles: [],
     verdict: null,
     exitCode,
@@ -266,6 +272,13 @@ export function writeRemoteUnavailableGateArtifacts(
   });
 }
 
+/** The local train wrapper owns the receipt marker, including when artifacts came from a remote host. */
+export function recordGateTrainMarker(summaryPath: string, trainGate: boolean): void {
+  const summary = JSON.parse(readFileSync(summaryPath, 'utf8')) as Record<string, unknown>;
+  summary.trainGate = trainGate;
+  writeFileSync(summaryPath, `${JSON.stringify(summary, null, 2)}\n`);
+}
+
 // ── 원격 산출 회수 (SIDE-VERIFY-GATE-SHARDS ②) ──────────────────────────────
 // 원격 run 은 `$W` 임시 트리에서 돌고 끝나면 trap 이 `$W` 를 지운다(gate-remote.ts remoteScript). 그래서 원격 쪽
 // `--artifact-dir` 는 `$W` «밖»의 호스트 디스크 경로(/var/tmp/elanous-gate-artifacts-<nonce>)로 준다 — run 이 끝나도 남고, 회수

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

@@ -4,7 +4,6 @@ import { tmpdir } from 'node:os';
 import { spawnSync } from 'node:child_process';
 import { basename, join, resolve } from 'node:path/posix';
 import { prepareDeterministicChildEnvironment } from '../../scripts/lib/deterministic-env.js';
-import { audit as auditEntryBudget, entryBudgetAffected } from '../../scripts/ratchets/next-tui-entry-budget.js';
 import { withGateTestEnv } from '../../scripts/lib/gate-test-env.js';
 import { runIsolationHardcodeGate } from '../../scripts/ci-isolation-hardcode-gate.js';
 import { runModelHardcodeGate } from '../../scripts/ci-model-hardcode-gate.js';
@@ -58,6 +57,49 @@ export interface SelfGateCliOptions {
   scenarioFile?: string;
   /** SIDE-VERIFY — 조각별 지금/기준 JUnit ⊕ summary.json 을 이 디렉토리에 «쓰기만» 한다(판정·exit·기존 줄 불변). */
   artifactDir?: string;
+  /** Marker captured by the process entry point; keeps receipts stable if the environment changes during dispatch. */
+  trainGate?: boolean;
+}
+
+const SELF_GATE_SEAT_TRACKS = new Set(['OP', 'OPC', 'OPT', 'TC', 'UX', 'MK']);
+
+interface SelfGateTrainMarker {
+  track: string | null;
+  received: boolean;
+}
+
+/** Capture and log the marker exactly as the self-gate process received it. */
+export function observeSelfGateTrainMarker(): SelfGateTrainMarker {
+  const track = process.env.ELANOUS_TRACK?.trim() || null;
+  const received = process.env.ELANOUS_TRAIN_GATE === '1';
+  try { debug.log('self-gate', 'train-gate-marker', { track, received }); } catch { /* evidence logging must not change gate behavior */ }
+  return { track, received };
+}
+
+/** Seat invocations may only measure the pinned tree after the landing train has admitted the gate. */
+export function refuseSeatSelfGateWithoutTrainMarker(marker = observeSelfGateTrainMarker()): { track: string; message: string } | undefined {
+  const { track, received } = marker;
+  if (!track || !SELF_GATE_SEAT_TRACKS.has(track) || received) return undefined;
+  try { debug.log('self-gate', 'seat-refused', { track, requiredMarker: 'ELANOUS_TRAIN_GATE=1' }); } catch { /* refusal must survive an unavailable observer */ }
+  return { track, message: 'gate 는 열차가 착지 때 1회 — land-enqueue.sh 로 줄에 올려라' };
+}
+
+/** A refused admission still writes the observed marker when an artifact directory was requested. */
+export function writeSeatSelfGateRefusalArtifact(cwd: string, artifactDir: string, marker: SelfGateTrainMarker): string | undefined {
+  if (!artifactDir.trim()) return undefined;
+  const dir = resolveArtifactDir(artifactDir, cwd);
+  const written = writeGateArtifacts({
+    dir,
+    head40: defaultRevResolver(cwd)('HEAD'),
+    base40: null,
+    envKey: defaultGateEnvKey(),
+    trainGate: marker.received,
+    testFiles: [],
+    verdict: 'seat-refused',
+    verdictLine: `seat gate refused before dispatch (track=${marker.track ?? 'none'}; trainGate=${marker.received})`,
+    exitCode: 2,
+  });
+  return written.summaryPath;
 }
 
 interface ProcessResult {
@@ -125,7 +167,6 @@ interface SelfGateCliDeps {
   /** iOS 순수-로직 시험 게이트 심(시험 주입용). */
   runIosGate?: (out: GateOutput) => number;
   runPwaGate?: (out: GateOutput) => number;
-  runEntryBudgetGate?: (cwd: string, changedFiles: readonly string[]) => { affected: boolean; errors: string[] };
   listPrWorktrees?: (cwd: string) => PrWorktreeListEntry[] | { lookupFailed: string };
   inspectWorktreeDirtiness?: (path: string) => { dirty: boolean } | { lookupFailed: string };
   /** `--artifact-dir` 전용 심 — 커밋 sha 해석(실패 = null) · 환경 키. */
@@ -809,23 +850,25 @@ export function selectGateTestFiles(cwd: string, options: GateSelectionOptions =
 
 export function runSelfGateCli(cwd: string, options: SelfGateCliOptions = {}, deps: SelfGateCliDeps = {}): SelfGateCliResult {
   const capture: GateArtifactCapture = {};
+  const trainGate = options.trainGate ?? process.env.ELANOUS_TRAIN_GATE === '1';
   const result = runSelfGateCliCore(cwd, options, deps, capture, false) as SelfGateCliResult;
   persistGateReceipt(cwd, capture, deps);
-  if (options.artifactDir !== undefined) emitGateArtifacts(cwd, options.artifactDir, result, capture, deps);
+  if (options.artifactDir !== undefined) emitGateArtifacts(cwd, options.artifactDir, result, capture, deps, trainGate);
   return result;
 }
 
 /** Production path: shard bundles use async Bun children; all non-shard policy and timeout logic is shared. */
 export async function runSelfGateCliAsync(cwd: string, options: SelfGateCliOptions = {}, deps: SelfGateCliDeps = {}): Promise<SelfGateCliResult> {
   const capture: GateArtifactCapture = {};
+  const trainGate = options.trainGate ?? process.env.ELANOUS_TRAIN_GATE === '1';
   const result = await runSelfGateCliCore(cwd, options, deps, capture, true);
   persistGateReceipt(cwd, capture, deps);
-  if (options.artifactDir !== undefined) emitGateArtifacts(cwd, options.artifactDir, result, capture, deps);
+  if (options.artifactDir !== undefined) emitGateArtifacts(cwd, options.artifactDir, result, capture, deps, trainGate);
   return result;
 }
 
 /** 쓰기 실패는 «경고 한 줄»로만 접는다 — 판정·exit 코드는 그대로다. */
-function emitGateArtifacts(cwd: string, artifactDir: string, result: SelfGateCliResult, capture: GateArtifactCapture, deps: SelfGateCliDeps): void {
+function emitGateArtifacts(cwd: string, artifactDir: string, result: SelfGateCliResult, capture: GateArtifactCapture, deps: SelfGateCliDeps, trainGate: boolean): void {
   if (!artifactDir.trim()) {
     result.lines.push('⚠ artifacts: --artifact-dir 가 빈 경로라 안 썼다 (판정은 그대로다)');
     return;
@@ -839,6 +882,7 @@ function emitGateArtifacts(cwd: string, artifactDir: string, result: SelfGateCli
       head40: resolveRev('HEAD'),
       base40: capture.baseRef ? resolveRev(capture.baseRef) : null,
       envKey: (deps.envKey ?? defaultGateEnvKey)(),
+      trainGate,
       testFiles: capture.testFiles ?? result.testFiles,
       verdict: capture.verdict ?? null,
       ...(capture.verdictLine !== undefined ? { verdictLine: capture.verdictLine } : {}),
@@ -1210,20 +1254,6 @@ function runSelfGateCliCore(cwd: string, options: SelfGateCliOptions, deps: Self
   // 🍎 iOS 축 — 안드로이드와 «같은 자리»에 둔다(skipTestStep 앞). Swift 만 바뀐 PR 도 여기서 조기 리턴한다.
   const iosPassed = runAdditionalGate('ios-gate', deps.runIosGate ?? runIosUnitTestGate, selection.files, cwd, lines);
   const pwaPassed = runAdditionalGate('pwa-gate', deps.runPwaGate ?? runPwaBuildGate, selection.files, cwd, lines);
-  let entryBudgetPassed = false;
-  try {
-    const budget = (deps.runEntryBudgetGate ?? ((dir, files) => {
-      const affected = entryBudgetAffected(files);
-      return { affected, errors: affected ? auditEntryBudget(dir).errors : [] };
-    }))(cwd, selection.files);
-    entryBudgetPassed = budget.errors.length === 0;
-    lines.push(budget.affected
-      ? `next-tui-entry-budget: ${entryBudgetPassed ? 'pass' : `FAIL ${budget.errors.join('; ')}`}`
-      : 'next-tui-entry-budget: skip (unrelated changes)');
-  } catch (error) {
-    lines.push(`next-tui-entry-budget: UNMEASURED ${error instanceof Error ? error.message : String(error)}`);
-  }
-
   if (receiptDecision?.mode === 'inherit' && testFiles.length === 0 && fullTestFiles.length > 0) {
     capture.testReceiptMeasured = true;
     capture.failedTestFiles = [];
@@ -1235,7 +1265,7 @@ function runSelfGateCliCore(cwd: string, options: SelfGateCliOptions, deps: Self
     const policyPassed = runPolicyGates(selection.files, cwd, lines, deps);
     logGateCliBaseline(cwd, { ...ZERO_GATE_BASELINE, unrunImporterTotal, lookupFailed: importerLookupFailed });
     return {
-      exitCode: policyPassed && androidPassed && iosPassed && pwaPassed && entryBudgetPassed && expose.passed ? 0 : 1,
+      exitCode: policyPassed && androidPassed && iosPassed && pwaPassed && expose.passed ? 0 : 1,
       lines, changedFiles: selection.files, testFiles, unverified: scope.unverified,
       documentPaths: scope.documentPaths, documentsWithoutDerivedTests: scope.documentsWithoutDerivedTests,
       alwaysIncludeMissing, importerTestsAdded,
@@ -1249,7 +1279,7 @@ function runSelfGateCliCore(cwd: string, options: SelfGateCliOptions, deps: Self
     capture.failedTestFiles = [];
     logGateCliBaseline(cwd, { ...ZERO_GATE_BASELINE, unrunImporterTotal, lookupFailed: importerLookupFailed });
     Object.assign(capture, { verdict: 'skipped', artifactsUnavailable: 'no-tests' } satisfies GateArtifactCapture);
-    return { exitCode: androidPassed && iosPassed && pwaPassed && entryBudgetPassed && policyPassed && expose.passed ? 0 : 1, lines, changedFiles: selection.files, testFiles: [], unverified: scope.unverified, documentPaths: scope.documentPaths, documentsWithoutDerivedTests: scope.documentsWithoutDerivedTests, alwaysIncludeMissing, importerTestsAdded, baseline: { introduced: 0, preexisting: 0, unknown: 0, preconditionUnmet: 0 } };
+    return { exitCode: androidPassed && iosPassed && pwaPassed && policyPassed && expose.passed ? 0 : 1, lines, changedFiles: selection.files, testFiles: [], unverified: scope.unverified, documentPaths: scope.documentPaths, documentsWithoutDerivedTests: scope.documentsWithoutDerivedTests, alwaysIncludeMissing, importerTestsAdded, baseline: { introduced: 0, preexisting: 0, unknown: 0, preconditionUnmet: 0 } };
   }
 
   // The default direct Bun path has one process and one 300s limit. Route real child/PTY tests through
@@ -1339,7 +1369,7 @@ function runSelfGateCliCore(cwd: string, options: SelfGateCliOptions, deps: Self
       capture.verdictLine = lines[lines.length - 1];
       const policyPassed = runPolicyGates(selection.files, cwd, lines, deps);
       return {
-        exitCode: capture.verdict !== 'passed' || !policyPassed || !androidPassed || !iosPassed || !pwaPassed || !entryBudgetPassed || !expose.passed ? 1 : 0,
+        exitCode: capture.verdict !== 'passed' || !policyPassed || !androidPassed || !iosPassed || !pwaPassed || !expose.passed ? 1 : 0,
         lines, changedFiles: selection.files, testFiles, unverified: scope.unverified,
         documentPaths: scope.documentPaths, documentsWithoutDerivedTests: scope.documentsWithoutDerivedTests,
         alwaysIncludeMissing, importerTestsAdded, ...(shardBaseline ? { baseline: shardBaseline } : {}),
@@ -1359,7 +1389,7 @@ function runSelfGateCliCore(cwd: string, options: SelfGateCliOptions, deps: Self
     Object.assign(capture, { verdict: 'passed', verdictLine: lines[lines.length - 1] } satisfies GateArtifactCapture);
     const policyPassed = runPolicyGates(selection.files, cwd, lines, deps);
     logGateCliBaseline(cwd, { ...ZERO_GATE_BASELINE, unrunImporterTotal, lookupFailed: importerLookupFailed });
-    return { exitCode: policyPassed && androidPassed && iosPassed && pwaPassed && entryBudgetPassed && expose.passed ? 0 : 1, lines, changedFiles: selection.files, testFiles, unverified: scope.unverified, documentPaths: scope.documentPaths, documentsWithoutDerivedTests: scope.documentsWithoutDerivedTests, alwaysIncludeMissing, importerTestsAdded, baseline: { introduced: 0, preexisting: 0, unknown: 0, preconditionUnmet: 0 } };
+    return { exitCode: policyPassed && androidPassed && iosPassed && pwaPassed && expose.passed ? 0 : 1, lines, changedFiles: selection.files, testFiles, unverified: scope.unverified, documentPaths: scope.documentPaths, documentsWithoutDerivedTests: scope.documentsWithoutDerivedTests, alwaysIncludeMissing, importerTestsAdded, baseline: { introduced: 0, preexisting: 0, unknown: 0, preconditionUnmet: 0 } };
   }
 
   if (worktreeLog.includes('deterministic environment setup failed')) lines.push(worktreeLog);
@@ -1394,7 +1424,7 @@ function runSelfGateCliCore(cwd: string, options: SelfGateCliOptions, deps: Self
     verdictLine: lines[lines.length - 1],
   } satisfies GateArtifactCapture);
   const policyPassed = runPolicyGates(selection.files, cwd, lines, deps);
-  const exitCode = !androidPassed || !iosPassed || !pwaPassed || !entryBudgetPassed || !policyPassed || !expose.passed || report.introduced > 0 || report.unknown > 0 || report.preconditionUnmet > 0 ? 1 : 0;
+  const exitCode = !androidPassed || !iosPassed || !pwaPassed || !policyPassed || !expose.passed || report.introduced > 0 || report.unknown > 0 || report.preconditionUnmet > 0 ? 1 : 0;
   return { exitCode, lines, changedFiles: selection.files, testFiles, unverified: scope.unverified, documentPaths: scope.documentPaths, documentsWithoutDerivedTests: scope.documentsWithoutDerivedTests, alwaysIncludeMissing, importerTestsAdded, baseline: { introduced: report.introduced, preexisting: report.preexisting, unknown: report.unknown, preconditionUnmet: report.preconditionUnmet } };
 }
 

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

@@ -7,7 +7,7 @@ import { existsSync, lstatSync, realpathSync } from 'node:fs';
 import { loadavg } from 'node:os';
 import { isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { debug } from '../debug/log.js';
-import { gateHostReservationRoot, inspectReleaseGateHost } from '../release-loop/gate-host-reservation.js';
+import { gateHostReservationRoot, inspectReleaseGateHost, readGateHostResourcesForHost, type GateHostResourceReading } from '../release-loop/gate-host-reservation.js';
 import type { GateRemoteConfig } from '../user-config.js';
 
 export type GateRemoteTool = 'self-gate' | 'ci-typecheck-changed' | 'public-export-test-run';
@@ -538,6 +538,8 @@ export interface DispatchDeps {
   now?: () => number;
   /** Test seam for gate.remote events; production defaults to the structured debug log. */
   log?: (event: string, data: Record<string, unknown>) => void;
+  /** Read-only host-resource probe; production reads Pod pool ledgers, tests inject the same measured snapshot. */
+  readHostResources?: (host: string) => GateHostResourceReading;
   write?: { out: (data: string | Uint8Array) => void; err: (data: string | Uint8Array) => void };
 }
 
@@ -595,8 +597,24 @@ export async function dispatchHeavyCheck(opts: DispatchOptions, deps: DispatchDe
   const reservationRoot = opts.tool === 'self-gate' || opts.tool === 'ci-typecheck-changed'
     ? opts.reservationRoot ?? (deps.runner ? undefined : gateHostReservationRoot()) : undefined;
   if (reservationRoot) {
+    const resourceStatus = (target: string) => {
+      if (!deps.readHostResources && deps.runner) return null; // fake runners keep tests hermetic unless the producer is explicitly exercised
+      return (deps.readHostResources ?? ((selected) => readGateHostResourcesForHost(selected, env)))(target.split('@').at(-1)!);
+    };
+    const inspect = (target: string) => {
+      const claim = inspectReleaseGateHost(reservationRoot, target);
+      const resources = resourceStatus(target);
+      if (!resources) return claim;
+      if (resources.status === 'unmeasurable') {
+        // Keep a concrete release owner visible even if the independent Pod ledgers cannot be read.
+        if (claim.status === 'reserved') return claim;
+        return { status: 'unknown' as const, reason: `resource probe unmeasurable: ${resources.reason}` };
+      }
+      if (!resources.empty) return { status: 'reserved' as const, reason: `Pod resource pool occupied (${resources.reservations} reservations)` };
+      return claim;
+    };
     const reservationHost = host.split('@').at(-1)!;
-    const first = inspectReleaseGateHost(reservationRoot, reservationHost);
+    const first = inspect(reservationHost);
     if (first.status !== 'free') {
       // A reserved host is never a reason to run this check locally (반증: 예약 상태에서 --local 무거운 시험 금지).
       // Self gate first tries another remote host, then waits bounded for the release, then ends unmeasured with
@@ -609,7 +627,7 @@ export async function dispatchHeavyCheck(opts: DispatchOptions, deps: DispatchDe
         : `observed-at=${observedAt}`;
       const alternates = opts.tool === 'self-gate'
         ? gateReservationAlternateHosts(reservationHost, opts.reservationAltHosts) : [];
-      const alternate = alternates.find((candidate) => inspectReleaseGateHost(reservationRoot, candidate).status === 'free');
+      const alternate = alternates.find((candidate) => inspect(candidate).status === 'free');
       if (alternate) {
         const rerouted = host.includes('@') ? `${host.slice(0, host.lastIndexOf('@'))}@${alternate}` : alternate;
         debug.log('gate.remote', 'host-reserved-reroute', { tool: opts.tool, from: host, to: rerouted, owner, reason: first.reason, reservedAt: first.reservedAt, observedAt });
@@ -619,7 +637,7 @@ export async function dispatchHeavyCheck(opts: DispatchOptions, deps: DispatchDe
         const waitSeconds = opts.tool === 'self-gate' ? opts.reservationWaitSeconds ?? settings.slotWaitSeconds : 0;
         const waitStart = now();
         const deadline = waitStart + Math.max(0, waitSeconds) * 1000;
-        let latest = inspectReleaseGateHost(reservationRoot, reservationHost);
+        let latest = inspect(reservationHost);
         while (waitSeconds > 0 && latest.status !== 'free') {
           const left = deadline - now();
           if (left <= 0) break;
@@ -627,7 +645,7 @@ export async function dispatchHeavyCheck(opts: DispatchOptions, deps: DispatchDe
           const before = now();
           await sleep(Math.min(15_000, left));
           if (now() <= before) break; // a frozen test clock must not spin past the bound
-          latest = inspectReleaseGateHost(reservationRoot, reservationHost);
+          latest = inspect(reservationHost);
         }
         const waitedMs = Math.max(0, now() - waitStart);
         if (latest.status === 'free') {