elanous 0.2.22 → 0.2.24

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

@@ -16,6 +16,9 @@ export interface GateShardAttempt {
   baselineExitCode: number | null;
   currentSignal?: string | null;
   baselineSignal?: string | null;
+  /** LIGHT-RC-MEASURE — the shard files that exist in the baseline tree, i.e. what the baseline side actually ran.
+   *  Absent = every shard file (the old shape). Empty = the baseline side was not run and contributes zero cases. */
+  baselineFiles?: readonly string[];
 }
 
 export interface GateShardAggregate {
@@ -25,7 +28,7 @@ export interface GateShardAggregate {
   report?: GateBaselineReport;
 }
 
-interface JUnitCase { file: string; name: string; failure?: string }
+interface JUnitCase { file: string; name: string; failure?: string; skipped?: true }
 
 const decode = (text: string): string => text.replace(/&(#x[0-9a-f]+|#\d+|amp|lt|gt|quot|apos);/gi, (entity, key: string) => {
   if (key[0] === '#') {
@@ -128,6 +131,7 @@ function readJUnit(xml: string, files: readonly string[]): JUnitCase[] | undefin
   const cases: JUnitCase[] = [];
   const counts = new Map<string, number>();
   const executed = new Set<string>();
+  const occurrences = new Map<string, number>();
   let failures = 0;
   let errors = 0;
   const matchesCount = (value: string | undefined, actual: number) => value === undefined
@@ -149,12 +153,20 @@ function readJUnit(xml: string, files: readonly string[]): JUnitCase[] | undefin
         if (!caseFile || !expected.has(caseFile) || !leaf || (file && file !== caseFile)) return undefined;
         total.tests++;
         counts.set(caseFile, (counts.get(caseFile) ?? 0) + 1);
-        if (child.children.some((c) => c.name === 'skipped')) return undefined;
+        // A skipped case is neither a pass nor a failure; it no longer voids the shard (LIGHT-RC-MEASURE ②).
+        const skipped = child.children.some((c) => c.name === 'skipped');
         const classname = child.attrs.classname;
-        const name = classname && classname !== caseFile ? `${classname} > ${leaf}` : leaf;
+        const declaredName = classname && classname !== caseFile ? `${classname} > ${leaf}` : leaf;
+        // Bun emits one name for every `test.each` row and for same-named cases in one describe; such repeats are
+        // told apart by their order in the file (#2, #3 …) on both sides instead of voiding the shard (LIGHT-RC-MEASURE).
+        const declaredIdentity = `${caseFile}\u0000${declaredName}`;
+        const ordinal = (occurrences.get(declaredIdentity) ?? 0) + 1;
+        occurrences.set(declaredIdentity, ordinal);
+        const name = ordinal === 1 ? declaredName : `${declaredName} #${ordinal}`;
         const identity = `${caseFile}\u0000${name}`;
         if (executed.has(identity)) return undefined;
         executed.add(identity);
+        if (skipped) { cases.push({ file: caseFile, name, skipped: true }); continue; }
         const failure = child.children.find((c) => c.name === 'failure' || c.name === 'error');
         if (failure?.name === 'failure') { failures++; total.failures++; }
         else if (failure) { errors++; total.errors++; }
@@ -179,6 +191,30 @@ function readJUnit(xml: string, files: readonly string[]): JUnitCase[] | undefin
   return cases;
 }
 
+const SKIPPED_PASSED_AT_BASE = 'skipped now · passed at base — a skip must not hide a regression (LIGHT-RC-MEASURE ②)';
+
+/** Cases that passed at the baseline but were skipped now are counted as `unknown` failures — never green. */
+function withSkippedRegressions(report: GateBaselineReport | undefined, skipped: readonly JUnitCase[], baselineStatus: GateBaselineReport['baselineStatus']): GateBaselineReport {
+  const base: GateBaselineReport = report ?? {
+    introduced: 0, preexisting: 0, unknown: 0, preconditionUnmet: 0, missingAtBase: 0, timedOut: 0, timeoutPassedAtBase: 0,
+    flakyRerun: 0, rerunNotRun: 0, mayVaryNonTimeout: 0, rerunAttempted: 0, rerunRecovered: 0,
+    timeoutVariabilityCounts: { mayVary: 0, same: 0, unknown: 0 }, worktreeFailuresParsed: true,
+    failures: [], files: [], baselineStatus, log: 'shard baseline JUnit complete',
+  };
+  // An unknown failure means the child is not exonerated: `childResponsibility: 'none'` only holds when every remaining
+  // failure is flaky/preexisting (decideGateChildResponsibility), which an added unknown breaks.
+  const { childResponsibility: _dropped, ...rest } = base;
+  const added = skipped.map(({ file, name }) => ({
+    name: `${file} > ${name}`, file, diagnostic: SKIPPED_PASSED_AT_BASE, attribution: 'unknown' as const, baselinePresence: 'present' as const,
+  }));
+  return {
+    ...rest,
+    unknown: base.unknown + added.length,
+    failures: [...base.failures, ...added],
+    files: [...new Set([...base.files, ...added.map((failure) => failure.file)])],
+  };
+}
+
 function asGateLog(cases: readonly JUnitCase[]): string {
   return cases.map(({ file, name, failure }) => `${file}:\n${failure === undefined ? `(pass) ${name}` : `${failure}\n(fail) ${name}`}`).join('\n');
 }
@@ -196,35 +232,47 @@ export function aggregateGateTestShards(shards: readonly GateTestShard[], attemp
   const retryShardIds: string[] = [];
   const current: JUnitCase[] = [];
   const baseline: JUnitCase[] = [];
+  const skippedRegressions: JUnitCase[] = [];
   for (const shard of shards) {
     const attempt = selected.get(shard.id);
     const head = attempt?.currentJUnit === undefined ? undefined : readJUnit(attempt.currentJUnit, shard.files);
-    const base = attempt?.baselineJUnit === undefined ? undefined : readJUnit(attempt.baselineJUnit, shard.files);
-    if (!attempt || attempt.currentExitCode === null || attempt.baselineExitCode === null
-      || attempt.currentSignal || attempt.baselineSignal
-      || ![0, 1].includes(attempt.currentExitCode) || ![0, 1].includes(attempt.baselineExitCode)
+    // LIGHT-RC-MEASURE ① — the baseline side reads only the files that exist in the baseline tree; none = not run.
+    const baselineFiles = attempt?.baselineFiles ?? shard.files;
+    const baselineSkipped = baselineFiles.length === 0;
+    const base = baselineSkipped ? [] : attempt?.baselineJUnit === undefined ? undefined : readJUnit(attempt.baselineJUnit, baselineFiles);
+    if (!attempt || attempt.currentExitCode === null || attempt.currentSignal
+      || ![0, 1].includes(attempt.currentExitCode)
+      || baselineFiles.some((file) => !shard.files.includes(file))
+      || (!baselineSkipped && (attempt.baselineExitCode === null || attempt.baselineSignal || ![0, 1].includes(attempt.baselineExitCode)))
       || !head || !base
       || (attempt.currentExitCode === 0 && head.some((test) => test.failure !== undefined))
-      || (attempt.baselineExitCode === 0 && base.some((test) => test.failure !== undefined))
+      || (!baselineSkipped && attempt.baselineExitCode === 0 && base.some((test) => test.failure !== undefined))
       || (attempt.currentExitCode !== 0 && head.every((test) => test.failure === undefined))
-      || (attempt.baselineExitCode !== 0 && base.every((test) => test.failure === undefined))) {
+      || (!baselineSkipped && attempt.baselineExitCode !== 0 && base.every((test) => test.failure === undefined))) {
       retryShardIds.push(shard.id);
       continue;
     }
-    current.push(...head);
-    baseline.push(...base);
+    current.push(...head.filter((test) => !test.skipped));
+    baseline.push(...base.filter((test) => !test.skipped));
+    const passedAtBase = new Set(base.filter((test) => !test.skipped && test.failure === undefined).map((test) => `${test.file}\u0000${test.name}`));
+    skippedRegressions.push(...head.filter((test) => test.skipped && passedAtBase.has(`${test.file}\u0000${test.name}`)));
   }
   if (retryShardIds.length > 0 || shards.length === 0) return { status: 'unmeasured', retryShardIds };
-  if (current.every((test) => test.failure === undefined)) return { status: 'passed', retryShardIds: [] };
+  const baselineStatus = baseline.some((test) => test.failure !== undefined) ? 'test-fail' as const : 'pass' as const;
+  if (current.every((test) => test.failure === undefined)) {
+    if (skippedRegressions.length === 0) return { status: 'passed', retryShardIds: [] };
+    return { status: 'failed', retryShardIds: [], report: withSkippedRegressions(undefined, skippedRegressions, baselineStatus) };
+  }
   const passedTestEvidence: GatePassedTestEvidence = {
     status: 'available',
     tests: baseline.filter((test) => test.failure === undefined).map(({ file, name }) => ({ file, name: `${file} > ${name}` })),
   };
   const report = buildGateBaselineReport(asGateLog(current), {
-    status: baseline.some((test) => test.failure !== undefined) ? 'test-fail' : 'pass',
+    status: baselineStatus,
     output: asGateLog(baseline),
     passedTestEvidence,
     log: 'shard baseline JUnit complete',
   });
+  if (skippedRegressions.length > 0) return { status: 'failed', retryShardIds: [], report: withSkippedRegressions(report, skippedRegressions, baselineStatus) };
   return { status: allowsBaselineOnlyFailure(report) ? 'passed' : 'failed', retryShardIds: [], report };
 }

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

@@ -39,7 +39,11 @@ export function planGateTestShards(
       shard = { id: `shard-${shards.length + 1}`, files: [], plannedRssMb: 0, plannedSeconds: 0 };
       shards.push(shard);
     }
-    if (!shard) throw new Error(`test files exceed ${shardCount} shard memory budgets`);
+    if (!shard) {
+      const totalRssMb = sorted.reduce((sum, candidate) => sum + rssMb.get(candidate)!, 0);
+      const largestRssMb = rssMb.get(sorted[0]!)!;
+      throw new Error(`test files exceed ${shardCount} shard memory budgets (files=${unique.length} · totalRssMb=${Math.round(totalRssMb)} · largestRssMb=${Math.round(largestRssMb)} · budgetMb=${capacity} · neededShards≥${Math.ceil(totalRssMb / capacity)})`);
+    }
     shard.files.push(file);
     shard.plannedRssMb += rss;
     shard.plannedSeconds += duration;

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

@@ -1,6 +1,7 @@
-import { existsSync, mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { existsSync, mkdtempSync, readFileSync, rmSync, statSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { debug } from '../debug/log.js';
 import { prepareDeterministicChildEnvironment } from '../../scripts/lib/deterministic-env.js';
 import { withBaselineWorktree } from '../self-implement/gate-baseline.js';
 import { aggregateGateTestShards, type GateShardAttempt, type GateShardAggregate } from './shard-aggregate.js';
@@ -22,6 +23,13 @@ export type ShardProcess = (cwd: string, files: readonly string[]) => {
   seconds?: number;
 };
 
+/** Absent only when the path provably is not a file there (missing, or not a regular file); any other stat error
+ *  (permissions …) is not evidence of absence, so the file stays in the baseline run (fail-closed: unmeasured). */
+const absentAtBaseline = (path: string): boolean => {
+  try { return !statSync(path).isFile(); }
+  catch (error) { const code = (error as NodeJS.ErrnoException).code; return code === 'ENOENT' || code === 'ENOTDIR'; }
+};
+
 /** One process per bundle and per revision; a failed runner is retried only for its own bundle. */
 export function runShardedGateTests(
   cwd: string,
@@ -71,20 +79,30 @@ export function runShardedGateTests(
   }
   const attempts: GateShardAttempt[] = [];
   const baseline = baselineWorktree(cwd, baseRef, (dir) => {
+    // LIGHT-RC-MEASURE ① — bun silently skips a path that is not in the baseline tree (exit 0), so a shard holding a
+    // new test file could never yield a complete baseline JUnit. Run the baseline side on the files the base has; an
+    // unreadable tree is not evidence of absence, so then every file stays in (the old shape).
+    const treeReadable = (() => { try { return statSync(dir).isDirectory(); } catch { return false; } })();
+    const atBase = (shard: GateTestShard) => treeReadable ? shard.files.filter((file) => !absentAtBaseline(join(dir, file))) : [...shard.files];
     let pending = shards;
     for (let round = 1; round <= 2 && pending.length; round++) {
       for (const shard of pending) {
-        const runSafely = (location: string): ReturnType<ShardProcess> => {
-          try { return run(location, shard.files); }
+        const runSafely = (location: string, selected: readonly string[]): ReturnType<ShardProcess> => {
+          try { return run(location, selected); }
           catch { return { exitCode: null }; }
         };
-        const current = runSafely(cwd);
-        const base = runSafely(dir);
+        const baselineFiles = atBase(shard);
+        if (baselineFiles.length < shard.files.length) {
+          debug.log('self-dev.shard', 'baseline-files-absent', { shardId: shard.id, round, absent: shard.files.filter((file) => !baselineFiles.includes(file)) });
+        }
+        const current = runSafely(cwd, shard.files);
+        const base = baselineFiles.length ? runSafely(dir, baselineFiles) : { exitCode: 0 };
         attempts.push({
           shardId: shard.id, attempt: round,
           currentJUnit: current.junit, baselineJUnit: base.junit,
           currentExitCode: current.exitCode, baselineExitCode: base.exitCode,
           currentSignal: current.signal, baselineSignal: base.signal,
+          baselineFiles,
         });
       }
       const retry = new Set(aggregateGateTestShards(shards, attempts).retryShardIds);

package/src/self-dev/supervisor-verdict-edges.ts

@@ -1,7 +1,5 @@
-import type { SelfDevJobResult } from './orchestrate.js';
-import type { SupervisorStopReason } from './run-supervisor.js';
-
-export type SupervisorNext = 'harvest' | 'scope-decompose' | 'self-review' | 'human-gate' | 'proposal';
+import type { SelfDevJobResult, SupervisorStopReason, SupervisorNext } from './run-types.js';
+export type { SupervisorNext } from './run-types.js';
 export type SupervisorVerdictEdge = { readonly meaning: string; readonly next: SupervisorNext };
 
 // 목표 규칙: 사람 관문은 결제·공개·자격·비가역 결정에만. 지금 max-rounds·provider-exhausted·step-timeout 이 human-gate 인 것은
@@ -20,6 +18,7 @@ export const SUPERVISOR_VERDICT_EDGES = {
   'step-timeout': { meaning: 'step budget exhausted', next: 'human-gate' },
   'decomposable-no-progress': { meaning: 'stalled with a decomposition proposal', next: 'scope-decompose' },
   'review-unobserved': { meaning: 'review was not observed', next: 'self-review' },
+  'review-oscillating': { meaning: 'review oscillation needs a human decision (its one repair is spent or cannot run here)', next: 'human-gate' },
   'deliverable-unobserved': { meaning: 'deliverable was not observed', next: 'self-review' },
   'deliverable-merged': { meaning: 'deliverable is merged', next: 'harvest' },
 } as const satisfies Record<SupervisorStopReason, SupervisorVerdictEdge>;

package/src/self-implement/blocked-draft-policy.ts

@@ -1,4 +1,7 @@
 import type { AbandonedClassification } from './abandoned-classification.js';
+import type { DraftOnStopMode } from './draft-on-stop-mode.js';
+export { DRAFT_ON_STOP_MODES, DEFAULT_DRAFT_ON_STOP, parseDraftOnStopMode } from './draft-on-stop-mode.js';
+export type { DraftOnStopMode } from './draft-on-stop-mode.js';
 
 /** Environment interruptions have a resumable branch, not a human draft decision. */
 export function blockedDraftDisposition(classification: string | undefined): 'open-draft' | 'preserve-branch' {
@@ -7,19 +10,6 @@ export function blockedDraftDisposition(classification: string | undefined): 'op
     : 'open-draft';
 }
 
-/**
- * DRAFT-NOT-ARCHIVE (RFC-draft-pr-accumulation-root-fix R1 · 첫 조각)
- *
- * S: 멈춘 런은 산출을 draft PR 로 남겼다 — PR 이 «실패 보관소»가 되어 열린 PR 이 200 을 넘고 겹침 검사가 눈이 멀었다.
- * C: 닫힌 147건 중 사람이 실제로 봐야 했던 것은 «주인 자리» 47건뿐이었다.
- * Q: 어느 멈춤이 PR 을 열 자격이 있나?
- * A: 사람 판단이 필요한 멈춤(needs-owner)만. 나머지(harvestable)는 수확 가지 `salvage/<run>/<leaf>` ⊕ 런 원장의 «사유 · 다음 수»로 남긴다.
- *    `tools.selfImplement.draftOnStop` = 'always'(기본 · 종전) | 'needs-owner-only'.
- */
-export type DraftOnStopMode = 'needs-owner-only' | 'always';
-export const DRAFT_ON_STOP_MODES = ['needs-owner-only', 'always'] as const satisfies readonly DraftOnStopMode[];
-export const DEFAULT_DRAFT_ON_STOP: DraftOnStopMode = 'always';
-
 /** landable = 승인된 산출(merge-approved-abandoned) — 다음 수가 `pr land` 이므로 수확 가지로 숨기지 않고 PR 로 남긴다(⛔ needs-owner 라벨은 안 단다). */
 export type StopClass = 'needs-owner' | 'harvestable' | 'landable';
 
@@ -99,9 +89,3 @@ export function salvageBranchForRun(runId: string, branch: string): string {
   const leaf = branch.replace(/[^A-Za-z0-9._-]+/g, '-').replace(/^[-.]+|[-.]+$/g, '').replace(/\.\.+/g, '.').replace(/\.lock$/i, '-lock') || 'branch';
   return `salvage/${runShort}/${leaf}`;
 }
-
-export function parseDraftOnStopMode(raw: unknown): { mode: DraftOnStopMode; invalid: boolean } {
-  if (raw === undefined) return { mode: DEFAULT_DRAFT_ON_STOP, invalid: false };
-  if (typeof raw === 'string' && (DRAFT_ON_STOP_MODES as readonly string[]).includes(raw)) return { mode: raw as DraftOnStopMode, invalid: false };
-  return { mode: DEFAULT_DRAFT_ON_STOP, invalid: true };
-}

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

@@ -2,8 +2,8 @@
 // 회전·사용량 저장소·선호 해석은 기존 함수를 부른다. 여기선 다시 만들지 않는다.
 
 import type { RotationCandidate } from '../oauth/codex-account-rotation.js';
-import { inspectCodexRotation } from '../oauth/codex-account-store.js';
-import { codexPolicyAllowsCredits } from '../oauth/codex-quota-policy.js';
+import { DEFAULT_CODEX_CREDIT_RESERVE, inspectCodexRotation } from '../oauth/codex-account-store.js';
+import { codexPolicyAllowsCredits, codexPolicyAllowsFallback } from '../oauth/codex-quota-policy.js';
 import { getUsageStore } from '../budget/usage-store.js';
 import type { UsageSnapshot } from '../budget/types.js';
 import { debug } from '../debug/log.js';
@@ -35,7 +35,7 @@ export interface BudgetCodexCandidate {
 
 export interface DecideBudgetInput {
   readonly preference: {
-    readonly chain: readonly { readonly provider: string; readonly model?: string }[];
+    readonly chain: readonly { readonly provider: string; readonly model?: string; readonly codexCredits?: true }[];
     readonly budgetGate: { readonly onShortfall: BudgetGateOnShortfall };
   };
   readonly codexCandidates: readonly BudgetCodexCandidate[];
@@ -44,6 +44,8 @@ export interface DecideBudgetInput {
   readonly maxUsedPercent: BudgetGateMaxUsedPercent;
   /** codex 한도 정책이 credits 인가(`codexPolicyAllowsCredits` · 회전·Pod 배분과 같은 해석). 없으면 false. */
   readonly codexCreditsAllowed?: boolean;
+  /** SUBSCRIPTION-EXHAUST-REROUTE — `llm.codexCreditReserve`. 잔액이 이 값 «초과»인 계정만 크레딧 후보다. 없으면 종전(> 0). */
+  readonly codexCreditReserve?: number;
 }
 
 export interface BudgetDecision {
@@ -59,6 +61,13 @@ export interface BudgetInputs {
   readonly grokUsedPercent: number | undefined;
   readonly maxUsedPercent: BudgetGateMaxUsedPercent;
   readonly codexCreditsAllowed?: boolean;
+  readonly codexCreditReserve?: number;
+}
+
+/** `llm.codexCreditReserve` from the same config the preference was read from — invalid or absent = default. */
+function budgetCreditReserve(config: ChildLlmPreferenceInput): number {
+  const raw = (config as { llm?: { codexCreditReserve?: unknown } }).llm?.codexCreditReserve;
+  return typeof raw === 'number' && Number.isFinite(raw) && raw >= 0 ? raw : DEFAULT_CODEX_CREDIT_RESERVE;
 }
 
 const WEEKLY_WINDOW_MINUTES = 7 * 24 * 60;
@@ -109,11 +118,15 @@ function codexCandidateUsable(candidate: BudgetCodexCandidate, cap: number | und
 
 /** BUDGET-GATE(10-05) — 정책이 credits 면 구독 % 가 차도 크레딧 잔액이 «확인된» 계정으로 계속 간다(Pod 배분과 같은 결론).
  *  잔액을 모르면 쓰지 않는다 — 크레딧은 돈이라 fail-closed. 잔액이 가장 큰 계정 하나를 돌려준다. */
-function codexCreditCandidate(input: DecideBudgetInput): BudgetCodexCandidate | undefined {
-  if (input.codexCreditsAllowed !== true) return undefined;
+function codexCreditCandidate(input: DecideBudgetInput, creditsStep = false): BudgetCodexCandidate | undefined {
+  // `codex-credits` 칸은 «체인이 거기까지 왔을 때»만 크레딧을 연다 — 정책(첫 칸)의 크레딧 금지와 별개다.
+  if (input.codexCreditsAllowed !== true && !creditsStep) return undefined;
+  // The credits step (new spend path) defaults to the reserve when none was passed — money, fail-closed; the policy path keeps > 0.
+  const floor = typeof input.codexCreditReserve === 'number' && Number.isFinite(input.codexCreditReserve) && input.codexCreditReserve >= 0
+    ? input.codexCreditReserve : creditsStep && input.codexCreditsAllowed !== true ? DEFAULT_CODEX_CREDIT_RESERVE : 0;
   return input.codexCandidates
     .filter((candidate) => candidate.hasCredits !== false
-      && typeof candidate.creditBalance === 'number' && Number.isFinite(candidate.creditBalance) && candidate.creditBalance > 0)
+      && typeof candidate.creditBalance === 'number' && Number.isFinite(candidate.creditBalance) && candidate.creditBalance > floor)
     .sort((a, b) => (b.creditBalance! - a.creditBalance!) || (a.name < b.name ? -1 : a.name > b.name ? 1 : 0))[0];
 }
 
@@ -121,7 +134,19 @@ function slotUsable(
   provider: string,
   input: DecideBudgetInput,
   allowUnmeasured = false,
+  codexCreditsSlot = false,
 ): { usable: boolean; reason: string; unmeasured?: boolean } {
+  if (provider === CODEX_PROVIDER && codexCreditsSlot) {
+    // CODEX-CREDITS-STEP — 잔액이 «확인된» 계정만(모르면 못 쓴다 · 돈이라 fail-closed). 미측정 통과도 «없다».
+    const credit = codexCreditCandidate(input, true);
+    if (!credit) {
+      // 칸에 «닿았지만» 잔액 확인된 계정이 없다 — 실패한 도달도 남긴다.
+      try { debug.log('budget.gate', 'codex-credits-step', { outcome: 'skipped', why: 'codex-credits-unavailable' }); } catch { /* observation is fail-soft */ }
+    }
+    return credit
+      ? { usable: true, reason: `codex-credits: ${credit.name} 크레딧 잔액 ${credit.creditBalance} (체인 마지막 칸 · 과금)` }
+      : { usable: false, reason: 'codex-credits: 잔액이 확인된 계정 없음' };
+  }
   if (provider === CODEX_PROVIDER) {
     const cap = capFor(input.maxUsedPercent, CODEX_PROVIDER);
     const measuredUsable = input.codexCandidates.some((candidate) => codexCandidateUsable(candidate, cap));
@@ -139,16 +164,19 @@ function slotUsable(
   }
   if (provider === GROK_PROVIDER) {
     const configured = capFor(input.maxUsedPercent, GROK_PROVIDER);
-    // 발사 관문은 `elanous usage` 와 같은 주간 사용률에 80% 상한을 실제로 적용한다.
-    // «못 쟀다»(undefined)는 통과가 아니다. decideBudget 은 설정 상한을 그대로 쓴다.
+    // 발사 관문은 잰 주간 사용률에만 80% 상한을 적용한다.
+    // «못 쟀다»(undefined)는 allowUnmeasured 일 때 통과하고 unmeasured 를 남긴다(codex 와 같은 꼴).
+    // decideBudget 은 설정 상한을 그대로 쓰고 모름을 통과로 보지 않는다.
     const cap = allowUnmeasured ? LAUNCH_GROK_USED_PERCENT_CAP : configured;
     const known = typeof input.grokUsedPercent === 'number' && Number.isFinite(input.grokUsedPercent);
-    const usable = cap === undefined
+    const measuredUsable = cap === undefined
       ? known
       : known && (input.grokUsedPercent as number) < cap;
+    const unmeasured = allowUnmeasured && !known;
     return {
-      usable,
+      usable: measuredUsable || unmeasured,
       reason: formatGrokReason(input.grokUsedPercent, cap),
+      ...(unmeasured ? { unmeasured: true } : {}),
     };
   }
   return { usable: false, reason: `${provider}: 예산 판정 없음` };
@@ -176,13 +204,19 @@ function decideBudgetWithPolicy(input: DecideBudgetInput, allowUnmeasured: boole
   let firstUnusable = false;
   for (let index = 0; index < input.preference.chain.length; index++) {
     const slot = input.preference.chain[index]!;
-    const judged = slotUsable(slot.provider, input, allowUnmeasured);
+    const judged = slotUsable(slot.provider, input, allowUnmeasured, slot.codexCredits === true);
     reasons.push(judged.reason);
     if (!judged.usable) {
       if (index === 0) firstUnusable = true;
       continue;
     }
     const action: BudgetAction = index === 0 || !firstUnusable ? 'proceed' : 'next-provider';
+    if (slot.codexCredits === true) {
+      try {
+        // 체인이 «마지막 칸»(유료)에 닿을 때마다 한 줄 — 앞 칸을 왜 못 썼나는 reasons 가 말한다(비밀 없음).
+        debug.log('budget.gate', 'codex-credits-step', { outcome: 'credits', action, reasons, launch: allowUnmeasured }, { level: 'warn' });
+      } catch { /* observation is fail-soft */ }
+    }
     return {
       decision: {
         action,
@@ -230,8 +264,12 @@ export interface ReadBudgetInputsDeps {
 /** 설정·codex 회전·grok 스냅숏을 읽어 판정 입력을 만든다. 판정 자체는 하지 않는다. */
 export function readBudgetInputs(deps: ReadBudgetInputsDeps = {}): BudgetInputs {
   const config = deps.config ?? deps.loadConfig?.() ?? loadLiveConfig();
-  const preference = resolveChildLlmPreference(config);
+  const resolved = resolveChildLlmPreference(config);
   const rotation = (deps.inspectCodex ?? inspectCodexRotation)();
+  // 정책 within-quota(한도 안에서만)는 크레딧을 «절대» 안 쓴다 — `codex-credits` 칸도 뺀다(회전·폴백 판정과 같은 해석).
+  const preference = rotation.policy && !codexPolicyAllowsFallback(rotation.policy.policy)
+    ? { ...resolved, chain: resolved.chain.filter((slot) => slot.codexCredits !== true) }
+    : resolved;
   const snapshot = deps.grokSnapshot
     ? deps.grokSnapshot()
     : getUsageStore().getSnapshot('grok');
@@ -242,7 +280,9 @@ export function readBudgetInputs(deps: ReadBudgetInputsDeps = {}): BudgetInputs
     grokUsedPercent: grokWeeklyUsedPercent(snapshot),
     maxUsedPercent,
     // 회전·Pod 배분과 같은 해석(`resolveCodexQuotaPolicy` → `codexPolicyAllowsCredits`)을 읽는다 — 다시 짓지 않는다.
-    ...(rotation.policy && codexPolicyAllowsCredits(rotation.policy.policy) ? { codexCreditsAllowed: true } : {}),
+    ...(rotation.policy && codexPolicyAllowsCredits(rotation.policy.policy) ? { codexCreditsAllowed: true, codexCreditReserve: budgetCreditReserve(config) }
+      // CODEX-CREDITS-STEP — the `codex-credits` slot keeps the same reserve (a credit spend below it is the case the reserve exists for).
+      : preference.chain.some((slot) => slot.codexCredits === true) ? { codexCreditReserve: budgetCreditReserve(config) } : {}),
   };
 }
 

package/src/self-implement/child-context-composition.ts

@@ -0,0 +1,139 @@
+import { debug } from '../debug/log.js';
+
+export const SMALL_CHILD_CONTEXT_TOKEN_BUDGET = 32_000;
+
+export const CHILD_CONTEXT_COMPONENT_NAMES = [
+  'systemPrompt',
+  'agentsMd',
+  'claudeMd',
+  'toolSchemas',
+  'goal',
+  'ledger',
+] as const;
+
+export type ChildContextComponentName = typeof CHILD_CONTEXT_COMPONENT_NAMES[number];
+export type ChildContextProfile = 'default' | 'small';
+
+export interface ChildContextComponents {
+  readonly systemPrompt?: string;
+  readonly agentsMd?: string;
+  readonly claudeMd?: string;
+  readonly toolSchemas?: string;
+  readonly goal?: string;
+  readonly ledger?: string;
+}
+
+export interface ChildContextComponentMeasurement {
+  readonly inputBytes: number;
+  readonly includedBytes: number;
+  readonly truncated: boolean;
+}
+
+export interface ChildContextComposition {
+  readonly text: string;
+  readonly profile: ChildContextProfile;
+  readonly budgetTokens: number | null;
+  /** UTF-8 bytes are a conservative upper bound on tokenizer tokens. */
+  readonly tokenUpperBound: number;
+  readonly components: Readonly<Record<ChildContextComponentName, ChildContextComponentMeasurement>>;
+}
+
+export interface ComposeChildContextOptions {
+  readonly profile?: ChildContextProfile;
+  readonly log?: (event: string, data: Record<string, unknown>) => void;
+}
+
+const JOINER = '\n\n';
+
+function utf8Bytes(value: string): number {
+  return Buffer.byteLength(value, 'utf8');
+}
+
+function prefixWithinUtf8Budget(value: string, byteBudget: number): string {
+  if (byteBudget <= 0) return '';
+  let included = '';
+  let bytes = 0;
+  for (const character of value) {
+    const characterBytes = utf8Bytes(character);
+    if (bytes + characterBytes > byteBudget) break;
+    included += character;
+    bytes += characterBytes;
+  }
+  return included;
+}
+
+function emptyMeasurements(): Record<ChildContextComponentName, ChildContextComponentMeasurement> {
+  return {
+    systemPrompt: { inputBytes: 0, includedBytes: 0, truncated: false },
+    agentsMd: { inputBytes: 0, includedBytes: 0, truncated: false },
+    claudeMd: { inputBytes: 0, includedBytes: 0, truncated: false },
+    toolSchemas: { inputBytes: 0, includedBytes: 0, truncated: false },
+    goal: { inputBytes: 0, includedBytes: 0, truncated: false },
+    ledger: { inputBytes: 0, includedBytes: 0, truncated: false },
+  };
+}
+
+function emitCompositionEvent(
+  log: ((event: string, data: Record<string, unknown>) => void) | undefined,
+  data: Record<string, unknown>,
+): void {
+  try {
+    if (log) log('child.context-composition', data);
+    else debug.log('self-implement', 'child.context-composition', data);
+  } catch {
+    // Context composition must not fail because an observation sink is unavailable.
+  }
+}
+
+/**
+ * Composes the implementation child's first-turn context and records the byte
+ * contribution of every input component. The small profile spends its hard cap
+ * on executable context first and trims repository instruction files last.
+ */
+export function composeChildContext(
+  components: ChildContextComponents,
+  options: ComposeChildContextOptions = {},
+): ChildContextComposition {
+  const profile = options.profile ?? 'default';
+  const budgetBytes = profile === 'small' ? SMALL_CHILD_CONTEXT_TOKEN_BUDGET : null;
+  const measurements = emptyMeasurements();
+  const included: Partial<Record<ChildContextComponentName, string>> = {};
+  const order: readonly ChildContextComponentName[] = profile === 'small'
+    ? ['systemPrompt', 'toolSchemas', 'goal', 'ledger', 'agentsMd', 'claudeMd']
+    : CHILD_CONTEXT_COMPONENT_NAMES;
+  let usedBytes = 0;
+  let includedCount = 0;
+
+  for (const name of order) {
+    const value = components[name] ?? '';
+    const inputBytes = utf8Bytes(value);
+    const separatorBytes = includedCount > 0 && value.length > 0 ? utf8Bytes(JOINER) : 0;
+    const availableBytes = budgetBytes === null ? Number.POSITIVE_INFINITY : Math.max(0, budgetBytes - usedBytes - separatorBytes);
+    const includedValue = inputBytes <= availableBytes ? value : prefixWithinUtf8Budget(value, availableBytes);
+    const includedBytes = utf8Bytes(includedValue);
+    measurements[name] = { inputBytes, includedBytes, truncated: includedBytes < inputBytes };
+    if (includedValue.length === 0) continue;
+    included[name] = includedValue;
+    usedBytes += separatorBytes + includedBytes;
+    includedCount += 1;
+  }
+
+  const text = CHILD_CONTEXT_COMPONENT_NAMES
+    .flatMap((name) => included[name] === undefined ? [] : [included[name]!])
+    .join(JOINER);
+  const tokenUpperBound = utf8Bytes(text);
+  const result: ChildContextComposition = {
+    text,
+    profile,
+    budgetTokens: budgetBytes === null ? null : SMALL_CHILD_CONTEXT_TOKEN_BUDGET,
+    tokenUpperBound,
+    components: measurements,
+  };
+  emitCompositionEvent(options.log, {
+    profile,
+    budgetTokens: result.budgetTokens,
+    tokenUpperBound,
+    components: measurements,
+  });
+  return result;
+}

package/src/self-implement/child-llm-preference.ts

@@ -11,9 +11,12 @@ import type {
 import { DEFAULT_BUDGET_GATE } from '../user-config.js';
 import { debug } from '../debug/log.js';
 
+/** 체인 한 칸. `codexCredits` = `llm.fallbackChain` 의 `codex-credits` 칸(codex 를 선불 크레딧으로 · 마지막 수단). */
+export type ChildLlmChainSlot = ChildLlmChainEntry & { readonly codexCredits?: true };
+
 export interface ResolvedChildLlmPreference {
   mode: ChildLlmPreferenceMode;
-  chain: ChildLlmChainEntry[];
+  chain: ChildLlmChainSlot[];
   budgetGate: {
     minHeadroomPercent: number;
     onShortfall: BudgetGateOnShortfall;
@@ -27,6 +30,8 @@ export type ChildLlmPreferenceInput = Pick<UserConfig, 'tools' | 'llm'> & Partia
 const FALLBACK_NAME_TO_PROVIDER: Readonly<Record<string, string>> = {
   'codex-rotate': 'openai-codex',
   grok: 'grok',
+  // CODEX-CREDITS-STEP — provider 는 같은 codex 지만 «크레딧 칸»이라 따로 센다(아래 중복 판정).
+  'codex-credits': 'openai-codex',
 };
 
 function warnPreference(detail: string): void {
@@ -39,15 +44,18 @@ function warnPreference(detail: string): void {
 }
 
 /** `llm.fallbackChain` 이름을 자식 프로바이더 칸으로 옮긴다. 모르는 이름은 경고하고 건너뛴다. */
-export function chainFromFallbackNames(names: readonly string[] | undefined): ChildLlmChainEntry[] {
-  const chain: ChildLlmChainEntry[] = [];
+export function chainFromFallbackNames(names: readonly string[] | undefined): ChildLlmChainSlot[] {
+  const chain: ChildLlmChainSlot[] = [];
   for (const name of names ?? []) {
     const provider = FALLBACK_NAME_TO_PROVIDER[name];
     if (!provider) {
       warnPreference(`llm.fallbackChain 의 모르는 이름 '${name}' 을 건너뜀`);
       continue;
     }
-    if (!chain.some((entry) => entry.provider === provider)) chain.push({ provider });
+    const codexCredits = name === 'codex-credits';
+    if (!chain.some((entry) => entry.provider === provider && (entry.codexCredits === true) === codexCredits)) {
+      chain.push(codexCredits ? { provider, codexCredits: true } : { provider });
+    }
   }
   return chain;
 }
@@ -60,7 +68,7 @@ export function resolveChildLlmPreference(config: ChildLlmPreferenceInput): Reso
   const mode: ChildLlmPreferenceMode = explicitMode ?? (provider ? 'pinned' : 'auto');
   const modeSource: ResolvedChildLlmPreference['source']['mode'] = explicitMode ? 'explicit' : 'inferred';
 
-  let chain: ChildLlmChainEntry[];
+  let chain: ChildLlmChainSlot[];
   let chainSource: ResolvedChildLlmPreference['source']['chain'];
   if (mode === 'pinned') {
     // 계정 회전은 여기 없다. provider 없는 model 은 pinned 가 아니다.