elanous 0.2.34 → 0.2.35

package/scripts/release-loop/resume-release.ts

@@ -10,7 +10,7 @@ import { lastJsonObject, runGraph, verifyReleaseCommandRoot, type GraphRunState
 import { withOpSeatFlock } from '../../src/steward/resync-tick.js';
 import { releaseRunUniverse } from './release-universe.js';
 import { isReleaseVersion } from './release-version.js';
-import { changedFilesBetween, clearPartialPlan, planPartialRegate, writePartialPlan } from './gate-partial.js';
+import { changedFilesBetween, clearPartialPlan, planPartialRegate, planStalledShardRecheck, writePartialPlan, writeRecheckPlan } from './gate-partial.js';
 import { gitClosureTree, testsReachingChanged, TRACEABLE_RELEASE_JSON, type ClosureTree } from './gate-closure.js';
 import { releaseResumeAcceptedRegressions, releaseResumeGateExecutor, releaseResumeGatePodPool, releaseResumeWaiver, type AcceptedRegression } from './resume.js';
 import { reserveReleaseResumeAttempt } from './resume-cap.js';
@@ -173,13 +173,50 @@ function preparePartial(tip: TipRefresh, opts: { from: string; partial?: boolean
   const reachesGate = (opts.from === 'gate' || opts.from === 'export-check') && fromIndex >= 0 && gateIndex >= fromIndex;
   // The default applies only where it can help: a gate re-run on a tip that moved. An unchanged tip re-uses its own
   // shard results by commit already.
-  if (opts.partial === false || (auto && (!reachesGate || !tip.changed))) return { requested: false };
+  if (opts.partial === false || (auto && (!reachesGate || (!tip.changed && opts.from !== 'gate')))) return { requested: false };
   const fallback = (reason: string): PartialOutcome => {
-    debug.log('release-loop.resume', 'partial-fallback', { version: tip.version, reason, auto });
+    debug.log('release-loop.resume', 'partial-fallback', { version: tip.version, reason, auto,
+      planKind: 'full', remeasureFileCount: 0, preservedShardCount: 0, fallbackReason: reason });
     return { requested: true, applied: false, reason, ...(auto ? { auto: true as const } : {}) };
   };
   if (!reachesGate) return fallback('--partial requires a restart that reaches gate');
-  if (!tip.changed) return fallback('release branch tip unchanged — nothing new to re-check');
+  if (!tip.changed) {
+    if (opts.from !== 'gate') return fallback('same-commit stalled-shard recheck requires --from gate');
+    const saved = JSON.parse(readFileSync(tip.statePath, 'utf8')) as GraphRunState;
+    const gateRecord = saved.nodes.find((node) => node.nodeId === 'gate');
+    const previousGate = gateRecord ? lastJsonObject(gateRecord.output) as Record<string, unknown> | undefined : undefined;
+    const stalled = previousGate?.stalledShards;
+    const summary = previousGate?.partialSummary as { pass?: unknown; fail?: unknown; errors?: unknown; ran?: unknown; files?: unknown } | undefined;
+    const measured = previousGate?.partialFailures as { failures?: unknown; errors?: unknown } | undefined;
+    if (previousGate?.outcome !== 'error' || previousGate.commit !== tip.to || !Array.isArray(stalled) || !stalled.length || !summary || !measured
+      || !['pass', 'fail', 'errors', 'ran', 'files'].every((key) => Number.isSafeInteger(summary[key as keyof typeof summary]) && Number(summary[key as keyof typeof summary]) >= 0)
+      || !Array.isArray(measured.failures) || !measured.failures.every((id) => typeof id === 'string')
+      || !Array.isArray(measured.errors) || !measured.errors.every((id) => typeof id === 'string')
+      || measured.failures.length !== Number(summary.fail) || measured.errors.length !== Number(summary.errors))
+      return fallback('same-commit gate has no complete stalled-shard measurement record');
+    const stalledFiles: string[] = [];
+    for (const item of stalled) {
+      if (!item || typeof item !== 'object' || !Array.isArray((item as { files?: unknown }).files)
+        || !(item as { files: unknown[] }).files.every((file) => typeof file === 'string')
+        || !['incomplete', 'no-output', 'job-failed', 'exit-code', 'unattributed', 'timeout'].includes(String((item as { reason?: unknown }).reason)))
+        return fallback('stalled-shard record is malformed');
+      stalledFiles.push(...(item as { files: string[] }).files);
+    }
+    const closure = (deps.closureTree ?? ((commit: string) => gitClosureTree(deps.repo ?? process.cwd(), commit)))(tip.to);
+    const tracked = new Set(closure.files);
+    const preservedShardCount = Number.isSafeInteger(previousGate?.preservedShardCount)
+      && Number(previousGate?.preservedShardCount) >= 0 ? Number(previousGate?.preservedShardCount) : undefined;
+    const planned = planStalledShardRecheck({ version: tip.version, measuredCommit: tip.to, forCommit: tip.to,
+      failures: measured.failures as string[], errors: measured.errors as string[], stalledFiles,
+      ...(preservedShardCount === undefined ? {} : { preservedShardCount }),
+      existsAtCommit: (file) => tracked.has(file) });
+    if (!planned.ok) return fallback(planned.reason);
+    const path = writeRecheckPlan(root, planned.plan);
+    debug.log('release-loop.resume', 'stalled-recheck-planned', { version: tip.version, commit: tip.to,
+      planKind: planned.plan.kind, remeasureFileCount: planned.plan.files.length,
+      preservedShardCount: planned.plan.preservedShardCount ?? 0, fallbackReason: null, path });
+    return { requested: true, applied: true, files: planned.plan.files.length, priorCommit: tip.to, ...(auto ? { auto: true as const } : {}) };
+  }
   let prior: { commit?: unknown; failures?: unknown; errors?: unknown } | undefined;
   for (const location of [...new Set([deps.ledgerRoot ?? releaseLedgerRoot(), root])]) {
     const path = join(location, 'release', tip.version, 'gate-failures.json');

package/scripts/release-loop/unattended-release.ts

@@ -39,6 +39,8 @@ export interface ReleaseLoopConfig {
   gatePodCpu?: number | string | { request?: number | string; limit?: number | string };
   gateRemote?: string;
   gateRemoteMirror?: string;
+  /** RELEASE-PWA-NODE-RESILIENCE ① — SSH host the `pwa` node runs its scenario suite on (e.g. `node-b`); absent = this machine. No fallback. */
+  pwaRemote?: string;
   opsHosts?: string[];
   internalDist?: string;
   opsRestart?: boolean;

package/scripts/test-diet/lib.ts

@@ -93,7 +93,12 @@ export type Verdict = 'keep' | 'failing' | 'review';
 export type Proposal = 'delete' | 'shrink' | 'rewrite-cheap' | 'move-out-of-gate' | 'investigate';
 export interface Td1Disposition { disposition: string; alternative: string; guards: string; why_slow: string }
 export interface Judged extends Measurement { caught90: number; flags: string[]; verdict: Verdict; effectiveness?: Effectiveness; proposal?: Proposal | null; basis?: string | null }
-export interface LedgerLine { at: string; range: string; start: number; end: number; next: number; total: number; commit: string; budgetSecs: number; results: Judged[]; sweepVisited?: number; sweepCostSecs?: number; sweepSlices?: number }
+export interface LedgerLine {
+  at: string; range: string; start: number; end: number; next: number; total: number; commit: string; budgetSecs: number; results: Judged[];
+  /** Exact non-contiguous selection; `range` encodes these indices in selection order. */
+  selectedFiles?: string[]; selectedIndices?: number[];
+  sweepVisited?: number; sweepCostSecs?: number; sweepSlices?: number;
+}
 
 /** `file\tsecs\t…` (TD1 whole-gate TSV) → seconds per file. */
 export function costTable(tsv: string): Map<string, number> {

package/scripts/test-diet/node.ts

@@ -7,12 +7,13 @@ import { appendFileSync, existsSync, mkdtempSync, mkdirSync, readFileSync, rmSyn
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { debug } from '../../src/debug/log.js';
-import { effectiveInstanceRoot } from '../../src/instance/resolve.js';
+import { effectiveInstanceRoot, releaseLedgerRoot } from '../../src/instance/resolve.js';
 import { CardStore } from '../../src/task-cards/card-store.js';
 import { GATE_NIGHTLY_AUDITS } from '../release-loop/gate-node.js';
 import { isCredentialKey } from '../lib/deterministic-env.js';
 import { appendLedger, costTable, judge, lastLedgerLine, ledgerPath, mainFailureFiles, nightlyAuditLedgerPath, pickRange, propose, td1Dispositions, writeCardDraft, writeMainFailureDay, type LedgerLine, type MainFailureResult, type Measurement, type Td1Disposition } from './lib.js';
 import { fixedCountAssertions, flakeVerdict, sweepSlice, unreachableImports, type Mutation, type TestRun } from './effectiveness.js';
+import { gateHistory, type GateHistoryRow } from '../release-loop/gate-history.js';
 
 type Context = { graphId?: string; input: Record<string, unknown>; outputs: Record<string, Record<string, unknown> | null> };
 function context(): Context {
@@ -27,6 +28,129 @@ function emit(result: Record<string, unknown> & { outcome: 'ok' | 'fail' | 'erro
 }
 const git = (args: string[]) => spawnSync('git', args, { encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 }).stdout ?? '';
 
+/**
+ * GATE-FAIL-HISTORY → per-file failure likelihood (boundary ①): a file the landed gate already failed on is picked
+ * before one it never failed on, and preexisting/knownEnv repeat offenders outrank one-off introduced/load-flaky hits.
+ */
+const GATE_FAIL_WEIGHT = { preexisting: 4, knownEnv: 3, flaky: 3, introduced: 2 } as const;
+
+/** Only the buckets the pick order and the prescription both read — no write-only fields. */
+export type GateFailWeight = { file: string; weight: number; preexisting: number; knownEnv: number; flaky: number };
+
+export function gateFailWeights(rows: readonly GateHistoryRow[]): Map<string, GateFailWeight> {
+  const weights = new Map<string, GateFailWeight>();
+  for (const row of rows) {
+    const weight = row.preexisting * GATE_FAIL_WEIGHT.preexisting + row.env * GATE_FAIL_WEIGHT.knownEnv
+      + row.flaky * GATE_FAIL_WEIGHT.flaky + row.introduced * GATE_FAIL_WEIGHT.introduced;
+    if (weight <= 0) continue;
+    const file = String(row.file);
+    weights.set(file, { file, weight, preexisting: row.preexisting, knownEnv: row.env, flaky: row.flaky });
+  }
+  return weights;
+}
+
+/** Reads the gate's own failure ledger; an unreadable ledger is an empty history, never a failed pick. */
+export function loadGateFailWeights(deps: {
+  instanceRoots?: readonly string[]; ledgerRoots?: readonly string[]; rows?: readonly GateHistoryRow[];
+} = {}): Map<string, GateFailWeight> {
+  if (deps.rows) return gateFailWeights(deps.rows);
+  try {
+    const report = gateHistory({
+      instanceRoots: deps.instanceRoots ?? [effectiveInstanceRoot()],
+      ledgerRoots: deps.ledgerRoots ?? [releaseLedgerRoot()],
+    }, { mergedPrs: () => [] });
+    return gateFailWeights(report.rows);
+  } catch (error) {
+    debug.log('test-diet', 'history-read-failed', { error: String(error) });
+    return new Map();
+  }
+}
+
+/**
+ * `pickRange` with the history-weighted order on top: every gate-failed file that fits the budget comes first
+ * (weight desc, then cheaper), the cursor slice fills the rest. Cursor `next` only advances past cursor files the
+ * budget actually selected — an unselected cursor file stays before `next`, so no file is skipped in a daily verdict
+ * or a sweep.
+ */
+export function pickWithHistory(files: readonly string[], start: number, costs: ReadonlyMap<string, number>, budgetSecs: number,
+  weights: ReadonlyMap<string, GateFailWeight>): ReturnType<typeof pickRange> & {
+    historyFiles: GateFailWeight[]; selectedIndices: number[]; rangeLabel: string; cursorVisitedCount: number;
+  } {
+  const range = pickRange(files, start, costs, budgetSecs);
+  const cost = (file: string) => costs.get(file) ?? 10;
+  const historyFiles = [...weights.values()].filter((entry) => files.includes(entry.file))
+    .sort((a, b) => b.weight - a.weight || cost(a.file) - cost(b.file) || a.file.localeCompare(b.file));
+  const describeSelection = (selectedFiles: string[]) => {
+    const selectedIndices = selectedFiles.map((file) => files.indexOf(file));
+    const contiguous = selectedIndices.length > 0
+      && selectedIndices.every((index, position) => position === 0 || index === selectedIndices[position - 1]! + 1);
+    const rangeLabel = selectedIndices.length === 0 ? '#empty'
+      : contiguous ? `#${selectedIndices[0]}~#${selectedIndices.at(-1)}`
+        : selectedIndices.map((index) => `#${index}`).join(',');
+    return { selectedIndices, rangeLabel };
+  };
+  if (historyFiles.length === 0) return { ...range, historyFiles, cursorVisitedCount: range.files.length, ...describeSelection(range.files) };
+  const ordered: string[] = [];
+  let estimatedSecs = 0;
+  for (const file of [...historyFiles.map((entry) => entry.file), ...range.files]) {
+    if (ordered.includes(file)) continue;
+    const added = cost(file);
+    if (ordered.length > 0 && estimatedSecs + added > budgetSecs) continue;
+    ordered.push(file);
+    estimatedSecs += added;
+  }
+  // 예산을 이력 파일로 채웠을 때: 커서는 실제로 선택한 커서 조각까지만 전진한다.
+  // 선택되지 않은 커서 파일을 next 너머로 건너뛰면 일일 판정·sweep에서 영구 누락된다.
+  const firstUnpicked = range.files.findIndex((file) => !ordered.includes(file));
+  const next = firstUnpicked === -1 ? range.next : (range.start + firstUnpicked) % files.length;
+  return { ...range, files: ordered, estimatedSecs, historyFiles, next,
+    cursorVisitedCount: range.files.filter((file) => ordered.includes(file)).length, ...describeSelection(ordered) };
+}
+
+/** MANUAL-gate-regression-response-recipe §2 T1~T7, plus TA for a verdict that is only a draft for the card. */
+export type CleanseRecipeType = 'T1' | 'T2' | 'T3' | 'T4' | 'T5' | 'T6' | 'T7' | 'TA';
+export type CleanseRecipe = { type: CleanseRecipeType; file: string; action: string; basis: string };
+
+const RECIPE_ACTIONS: Record<CleanseRecipeType, string> = {
+  T1: 'fixture·단언을 새 계약으로 고쳐 쓴다(제품 동작은 그대로)',
+  T2: '제품 회귀 — 제품 동작을 고친다(시험 완화 금지)',
+  T3: '규칙 문면을 규칙 원본과 맞춘다',
+  T4: '시험 문면을 지금 문안으로 맞춘다(프로토콜·기본 동작은 그대로)',
+  T5: '빈 환경 의존을 주입으로 없앤다(credential·경로·도구를 명시 주입)',
+  T6: '간섭을 격리한다(단독 실행·임시 HOME·동시성 낮춤)',
+  T7: '인프라 실패 — 재게이트하고 TA 카드로 사람에게 넘긴다',
+  TA: '결과를 TA 카드로 남긴다(지우기·이동은 사람·주인 확인)',
+};
+
+export type RecipeInput = { file: string; verdict: string; reason?: string; flaky?: boolean; effectiveness?: { flake?: string };
+  history?: { preexisting: number; knownEnv: number; flaky?: number } };
+
+/** Exactly one prescription per verdict — the draft only, never a deletion. */
+export function recipeFor(result: RecipeInput): CleanseRecipe {
+  const reason = (result.reason ?? '').toLowerCase();
+  const flaky = result.flaky === true || result.effectiveness?.flake === 'flaky';
+  const history = result.history;
+  // The gate ledger's flaky bucket is the same «history» the pick weighs, so a repeat-flaky file that measures
+  // keep still gets the isolation prescription (T6) instead of falling through to a bare TA card.
+  const historyFlaky = history?.flaky ?? 0;
+  const type: CleanseRecipeType = result.verdict === 'failing'
+    ? (/enospc|out of memory|cannot allocate|oomkilled|no space|pod .*(restart|terminat)|preempt/.test(reason) ? 'T7'
+      : flaky ? 'T6'
+        : /enoent|eacces|no llm provider|command not found|cannot find module|credential|api key|not found: |git config/.test(reason) ? 'T5'
+          : /timed out|timeout|waitfor|expected text|wording|문면/.test(reason) ? 'T4'
+            : /rules-contract|(^|\/)\.rules\//.test(result.file) ? 'T3'
+              : /typeerror|referenceerror|is not a function|is not defined|syntaxerror/.test(reason) ? 'T2'
+                : 'T1')
+    : history?.knownEnv ? 'T5'
+      : flaky || history?.preexisting || historyFlaky > 0 ? 'T6'
+        : 'TA';
+  const tail = reason.split('\n')[0]?.slice(0, 160) ?? '';
+  const historyBasis = history && (history.preexisting > 0 || history.knownEnv > 0 || historyFlaky > 0)
+    ? ` · gate history preexisting ${history.preexisting} · knownEnv ${history.knownEnv}`
+      + `${historyFlaky > 0 ? ` · flaky ${historyFlaky}` : ''}` : '';
+  return { type, file: result.file, action: RECIPE_ACTIONS[type], basis: `${result.verdict}${tail ? `: ${tail}` : ''}${historyBasis}` };
+}
+
 function pick(ctx: Context, sweep = false): number {
   const files = git(['ls-files', '*.test.ts']).split('\n').filter(Boolean).sort();
   const costs = costTable(readFileSync(join(process.cwd(), 'docs/measurements/td1-whole-gate-mechanical-2026-10-01.tsv'), 'utf8'));
@@ -35,7 +159,7 @@ function pick(ctx: Context, sweep = false): number {
   const totalCostSecs = sweep ? files.reduce((sum, file) => sum + (costs.get(file) ?? 10), 0) : 0;
   // `start` re-looks a slice on purpose; otherwise continue from the ledger cursor.
   const startAt = typeof ctx.input.start === 'number' && ctx.input.start >= 0 ? ctx.input.start : last?.next ?? 0;
-  const continuing = ctx.input.start === undefined && last?.sweepVisited && last.sweepVisited < files.length && last.next === startAt && last.total === files.length;
+  const continuing = ctx.input.start === undefined && typeof last?.sweepVisited === 'number' && last.sweepVisited < files.length && last.next === startAt && last.total === files.length;
   const remaining = continuing ? files.length - last.sweepVisited! : files.length;
   const elapsed = continuing ? last.sweepSlices ?? 0 : 0;
   const slotsLeft = Math.max(1, 28 - elapsed);
@@ -43,8 +167,13 @@ function pick(ctx: Context, sweep = false): number {
     slotsLeft, minBudgetSecs: continuing ? last.budgetSecs : 0 }) : undefined;
   const budgetSecs = sweepPlan?.budgetSecs
     ?? (typeof ctx.input.budgetSecs === 'number' && ctx.input.budgetSecs > 0 ? ctx.input.budgetSecs : 1800);
-  const range = pickRange(files, startAt, costs, budgetSecs);
-  return emit({ outcome: 'ok', summary: `test-diet pick #${range.start}~#${range.end} of ${files.length} (≈${Math.round(range.estimatedSecs)}s)`, ...range, total: files.length, budgetSecs,
+  const measuredLastSlice = new Set((last?.results ?? []).map((result) => result.file));
+  const cursorParked = last?.next === startAt && last.selectedIndices?.every((index) => index !== startAt);
+  // When a prior history-only slice left the cursor parked, force the next slice onto the cursor.
+  // Suppressing only the last history winner allows two weighted files to alternate forever.
+  const availableHistory = cursorParked ? new Map() : new Map([...loadGateFailWeights()].filter(([file]) => !measuredLastSlice.has(file)));
+  const range = pickWithHistory(files, startAt, costs, budgetSecs, availableHistory);
+  return emit({ outcome: 'ok', summary: `test-diet pick ${range.rangeLabel} of ${files.length} (≈${Math.round(range.estimatedSecs)}s)`, ...range, total: files.length, budgetSecs,
     ...(sweep ? { sweep: true, totalCostSecs, slicesNeeded: sweepPlan?.slicesNeeded, sweepElapsed: elapsed } : {}) });
 }
 
@@ -180,6 +309,23 @@ function recordNightlyAudit(ctx: Context): number {
   return emit({ outcome: failing ? 'fail' : 'ok', summary: `nightly audit ${results.length} · failing ${failing}${card ? ' · card draft' : ''}`, failing, ledger: path, ...(card ? { card } : {}) });
 }
 
+/** The pick's own gate-history snapshot — `record` reads the files `pick` actually selected from, never a fresh
+ * ledger query, so the prescription and the ledger line keep the same basis even if the gate ledger changed
+ * between the two graph steps. */
+function pickHistoryFiles(p: Record<string, unknown> | null): GateFailWeight[] {
+  const raw = p?.historyFiles;
+  if (!Array.isArray(raw)) return [];
+  const files: GateFailWeight[] = [];
+  for (const entry of raw) {
+    if (entry === null || typeof entry !== 'object') continue;
+    const x = entry as GateFailWeight;
+    if (typeof x.file !== 'string' || typeof x.weight !== 'number' || !Number.isFinite(x.weight)
+      || typeof x.preexisting !== 'number' || typeof x.knownEnv !== 'number' || typeof x.flaky !== 'number') continue;
+    files.push({ file: x.file, weight: x.weight, preexisting: x.preexisting, knownEnv: x.knownEnv, flaky: x.flaky });
+  }
+  return files;
+}
+
 export function record(ctx: Context, deps: { createStore?: (root: string) => Pick<CardStore, 'createCard' | 'appendSection' | 'close'>; td1?: ReadonlyMap<string, Td1Disposition> } = {}): number {
   const p = ctx.outputs.pick;
   const m = ctx.outputs.measure;
@@ -188,27 +334,61 @@ export function record(ctx: Context, deps: { createStore?: (root: string) => Pic
   const td1 = deps.td1 ?? td1Dispositions(readFileSync(join(process.cwd(), 'docs/measurements/td1-top200-content-review-2026-10-01.tsv'), 'utf8'));
   const results = measurements.map((x) => propose(judge(x, git(['log', '--since=90.days', '--format=%s', '--', x.file]).split('\n').filter((s) => /^fix\b/i.test(s)).length), td1));
   const previous = p.sweep === true ? lastLedgerLine(effectiveInstanceRoot()) : null;
-  const continuing = previous?.sweepVisited && previous.sweepVisited < Number(p.total)
+  const continuing = typeof previous?.sweepVisited === 'number' && previous.sweepVisited < Number(p.total)
     && previous.next === Number(p.start) && previous.total === Number(p.total);
-  const visited = p.sweep === true ? Math.min(Number(p.total), (continuing ? previous.sweepVisited! : 0) + results.length) : undefined;
+  const visited = p.sweep === true ? Math.min(Number(p.total), (continuing ? previous.sweepVisited! : 0) + Number(p.cursorVisitedCount ?? results.length)) : undefined;
   const sweepCostSecs = p.sweep === true ? (continuing ? previous.sweepCostSecs ?? 0 : 0) + Number(p.estimatedSecs) : undefined;
   const sweepSlices = p.sweep === true ? Number(p.sweepElapsed ?? (continuing ? previous.sweepSlices ?? 0 : 0)) + 1 : undefined;
+  const root = effectiveInstanceRoot();
+  const historyFiles = pickHistoryFiles(p);
+  const weights = new Map(historyFiles.map((entry) => [entry.file, entry]));
+  const historyFailures = results.map((result) => weights.get(result.file))
+    .filter((entry): entry is GateFailWeight => entry !== undefined);
+  const slicePreexisting = historyFailures.reduce((sum, entry) => sum + entry.preexisting, 0);
+  const slicePreexistingKnownEnv = historyFailures.reduce((sum, entry) => sum + entry.knownEnv, 0);
+  // Metric (boundary ③): each ledger line carries its slice's preexisting ⊕ knownEnv totals AND their delta
+  // against the previous slice line, so «판마다 이월» is readable row by row — even on a zero line.
+  const previousHistory = (lastLedgerLine(root) as { gateHistory?: { preexisting?: number; knownEnv?: number } } | null)?.gateHistory;
+  const history = {
+    preexisting: slicePreexisting,
+    knownEnv: slicePreexistingKnownEnv,
+    total: slicePreexisting + slicePreexistingKnownEnv,
+    files: historyFailures.map((entry) => entry.file),
+    deltaPreexisting: slicePreexisting - Number(previousHistory?.preexisting ?? 0),
+    deltaKnownEnv: slicePreexistingKnownEnv - Number(previousHistory?.knownEnv ?? 0),
+  };
+  const selectedFiles = Array.isArray(p.files) ? p.files.filter((file): file is string => typeof file === 'string') : results.map((result) => result.file);
+  const selectedIndices = Array.isArray(p.selectedIndices) && p.selectedIndices.every((index) => typeof index === 'number')
+    ? p.selectedIndices as number[] : [];
   const line = {
-    at: new Date().toISOString(), range: `#${p.start}~#${p.end}`, start: Number(p.start), end: Number(p.end), next: Number(p.next), total: Number(p.total),
+    // start/end/next are cursor coordinates; range + selectedIndices describe the exact weighted selection.
+    at: new Date().toISOString(), range: typeof p.rangeLabel === 'string' ? p.rangeLabel : `#${p.start}~#${p.end}`,
+    start: Number(p.start), end: Number(p.end), next: Number(p.next), total: Number(p.total), selectedFiles, selectedIndices,
     commit: String(m?.commit ?? '?'), budgetSecs: Number(p.budgetSecs), results, ...(visited === undefined ? {} : { sweepVisited: visited, sweepCostSecs, sweepSlices }),
+    gateHistory: { preexisting: history.preexisting, knownEnv: history.knownEnv, total: history.total,
+      deltaPreexisting: history.deltaPreexisting, deltaKnownEnv: history.deltaKnownEnv },
   };
-  const root = effectiveInstanceRoot();
   appendLedger(root, line);
   const card = writeCardDraft(root, line);
+  const recipes = new Map(results.map((result) => {
+    const entry = weights.get(result.file);
+    return [result.file, recipeFor(entry ? { ...result, history: entry } : result)] as const;
+  }));
+  const recipeCounts: Record<string, number> = {};
+  for (const recipe of recipes.values()) recipeCounts[recipe.type] = (recipeCounts[recipe.type] ?? 0) + 1;
   const proposals: Record<string, number> = {};
   for (const result of results) {
-    if (!result.proposal) continue;
-    proposals[result.proposal] = (proposals[result.proposal] ?? 0) + 1;
+    if (td1.get(result.file)?.disposition === 'keep' && result.verdict === 'keep' && !result.proposal) continue;
+    const recipe = recipes.get(result.file)!;
+    const historyEntry = weights.get(result.file);
+    // YAML이 약속한 «판정마다 처방 카드 초안 하나» — 제안·실패·이력이 없는 keep 판정도 카드를 건너뛰지 않는다.
+    const proposal = result.proposal ?? (result.verdict === 'failing' ? 'failing' : historyEntry !== undefined ? `gate-history:${recipe.type}` : `verdict:${recipe.type}`);
+    proposals[proposal] = (proposals[proposal] ?? 0) + 1;
     let store: Pick<CardStore, 'createCard' | 'appendSection' | 'close'> | undefined;
     try {
       store = deps.createStore?.(root) ?? new CardStore(root);
-      const task = store.createCard({ goalId: `test-diet:${result.file}:${result.proposal}`, title: `시험 다이어트 제안 — ${result.file} · ${result.proposal}` });
-      const observation = { proposal: result.proposal, basis: result.basis, guards: td1.get(result.file)?.guards ?? '',
+      const task = store.createCard({ goalId: `test-diet:${result.file}:${proposal}`, title: `시험 다이어트 제안 — ${result.file} · ${proposal} · ${recipe.type}` });
+      const observation = { proposal: result.proposal, recipe, basis: result.basis, guards: td1.get(result.file)?.guards ?? '',
         secs: result.secs, rssMb: result.rssMb, caught90: result.caught90, range: line.range, ...(result.effectiveness ? { effectiveness: result.effectiveness } : {}) };
       const fingerprint = createHash('sha256').update(JSON.stringify(observation)).digest('hex');
       const key = `test-diet:${line.commit}:${fingerprint}`;
@@ -233,8 +413,9 @@ export function record(ctx: Context, deps: { createStore?: (root: string) => Pic
   }
   debug.log('test-diet', 'proposed', { range: line.range, proposals });
   const counts = { keep: results.filter((r) => r.verdict === 'keep').length, review: results.filter((r) => r.verdict === 'review').length, failing: results.filter((r) => r.verdict === 'failing').length };
+  debug.log('test-diet', 'prescriptions', { range: line.range, recipes: recipeCounts, preexisting: history.preexisting, knownEnv: history.knownEnv });
   debug.log('test-diet', 'recorded', { range: line.range, ...counts, card: card !== null });
-  return emit({ outcome: 'ok', summary: `test-diet ${line.range} · keep ${counts.keep} · review ${counts.review} · failing ${counts.failing}${card ? ' · card draft' : ''}`, range: line.range, ...counts, ...(card ? { card } : {}) });
+  return emit({ outcome: 'ok', summary: `test-diet ${line.range} · keep ${counts.keep} · review ${counts.review} · failing ${counts.failing}${card ? ' · card draft' : ''}`, range: line.range, ...counts, ...(card ? { card } : {}), recipes: recipeCounts, history });
 }
 
 export function mainFailures(ctx: Context, deps: { root?: string; checkout?: string; runFile?: (file: string, cwd: string) => MainFailureResult; now?: Date } = {}): number {

package/scripts/ux-sim.ts

@@ -17,6 +17,7 @@
 //   bun scripts/ux-sim.ts --fault pod-death   # 결함 주입: PARTIAL 줄을 남긴 Pod 가 SIGTERM 으로 지워짐 → 호스트 재방출 판정
 //   bun scripts/ux-sim.ts --fault pool-cap    # 결함 주입: --pod-pool 에 :N 이 빠진 풀 → 승인 판정(limitedBy)
 //   bun scripts/ux-sim.ts --fault sqlite-busy # 결함 주입: 실제 SQLite 잠금 → 로그 배치 버퍼·복구
+//   bun scripts/ux-sim.ts emit child-error-long --json # 사건 주입(L0): 격리 우주 원장에 주입 줄 → 소비자 목록
 //
 // ⛔ 이 CLI 는 «실제 위젯 render()» 를 부른다 — 흉내 렌더러가 아니다.
 import { simRenderLogFrame } from '../src/ux-sim/render-frame.js';
@@ -29,6 +30,44 @@ const PHASES: TurnPhase[] = [
 
 const argv = process.argv.slice(2);
 
+// ── 사건 주입 «이벤트 몽키» (SIM-EVENT-MONKEY · L0) — 자기 플래그를 가진 하위 명령 ──
+//   bun scripts/ux-sim.ts emit <kind> [--run <id>] [--variant allowed|refused] [--state-dir <dir>] [--json]
+//   bun scripts/ux-sim.ts emit --list
+//   ⛔ 운영 우주(~/.elanous)면 쓰기 전에 거부(rc 3). 격리 우주는 ELANOUS_STATE_DIR 또는 --state-dir.
+if (argv[0] === 'emit') {
+  // 얇은 별칭 — 해석은 `eln sim emit` 과 «같은» runEventMonkeyCli 하나가 한다.
+  const rest = argv.slice(1);
+  const EMIT_FLAGS = new Set(['--run', '--variant', '--state-dir', '--json', '--list']);
+  const VALUED = new Set(['--run', '--variant', '--state-dir']);
+  const unknown = rest.filter((a) => a.startsWith('--') && !EMIT_FLAGS.has(a));
+  if (unknown.length > 0) {
+    console.error(`⛔ 모르는 인자다: ${unknown.join(' ')} — 아는 것: ${[...EMIT_FLAGS].join(' · ')}`);
+    process.exit(2);
+  }
+  const value = (flag: string): string | undefined => {
+    const i = rest.indexOf(flag);
+    if (i < 0) return undefined;
+    const v = rest[i + 1];
+    if (!v || v.startsWith('--')) { console.error(`⛔ ${flag} 에 값이 필요하다`); process.exit(2); }
+    return v;
+  };
+  const { renderEventMonkeyKinds, runEventMonkeyCli } = await import('../src/ux-sim/event-monkey.js');
+  if (rest.includes('--list')) { console.log(renderEventMonkeyKinds(rest.includes('--json')).join('\n')); process.exit(0); }
+  const positional = rest.filter((a, i) => !a.startsWith('--') && !VALUED.has(rest[i - 1] ?? ''));
+  if (positional.length > 1) {
+    console.error(`⛔ 사건은 하나만 받는다 — 남는 인자: ${positional.slice(1).join(' ')}`);
+    process.exit(2);
+  }
+  const runId = value('--run');
+  const variant = value('--variant');
+  const stateDir = value('--state-dir');
+  const out = runEventMonkeyCli({ kindName: positional[0], json: rest.includes('--json'),
+    ...(runId ? { runId } : {}), ...(variant ? { variant } : {}), ...(stateDir ? { stateDir } : {}) });
+  for (const line of out.stdout) console.log(line);
+  for (const line of out.stderr) console.error(line);
+  process.exit(out.code);
+}
+
 // ⛔⭐ 모르는 인자를 «조용히 삼키지» 않는다 — 이름을 대고 거부한다.
 //
 //  🚨 2026-08-27 실측: `--trajectory-list`(오타 · 실제는 `--list-trajectories`)를 쳤더니

package/src/agent/self-ambient-cache.ts

@@ -18,8 +18,16 @@ import { elanousSelfAmbientBaseParts } from './self-ambient.js';
 
 export const SELF_AMBIENT_FRESH_MS = 30_000;
 export const SELF_AMBIENT_STALE_MAX_MS = 10 * 60_000;
+export const SELF_AMBIENT_KEEP_WARM_ACTIVE_MS = 25_000;
+export const SELF_AMBIENT_KEEP_WARM_IDLE_MS = 8 * 60_000;
+const SELF_AMBIENT_IDLE_AFTER_MS = 2 * 60_000;
 const WORKER_TIMEOUT_MS = 60_000;
 
+/** Keep turn context warm while active; avoid periodic ambient scans during a long idle. */
+export function selfAmbientKeepWarmIntervalMs(idleMs: number): number {
+  return idleMs >= SELF_AMBIENT_IDLE_AFTER_MS ? SELF_AMBIENT_KEEP_WARM_IDLE_MS : SELF_AMBIENT_KEEP_WARM_ACTIVE_MS;
+}
+
 interface CacheEntry { at: number; version: number; parts: string[] }
 
 export interface SelfAmbientCacheDeps {

package/src/agent-substrate/acp-reviewer.ts

@@ -35,6 +35,22 @@ export interface AcpReviewerOpts {
   timeoutMs?: number;
   /** One deadline for spawn → initialize → session/new → model select (ms). A child that never answers ACP must not hang the review. Default min(timeoutMs, 60000). */
   handshakeTimeoutMs?: number;
+  /**
+   * ACP-REVIEW-VIA-TEAMCLAUDE: how a `claude` review without an explicit `backendSpec` finds the teamclaude
+   * (cct) route. Default (production, non-injected) = `resolveTeamclaudeReviewRoute()`; an injected agent
+   * without this seam does not probe the host.
+   */
+  resolveClaudeRoute?: () => import('../self-dev/review-provider-fallback.js').TeamclaudeReviewRoute
+    | Promise<import('../self-dev/review-provider-fallback.js').TeamclaudeReviewRoute>;
+}
+
+/** ACP claude reviews read the repo with tools and ran 228–345s in practice (OPC #25934); 300s cut them. */
+const ACP_CLAUDE_REVIEW_TIMEOUT_SEC = 600;
+const ACP_REVIEW_TIMEOUT_SEC = 300;
+
+/** Default per-review deadline (seconds) when the caller gives none. */
+export function defaultAcpReviewTimeoutSec(backend: string): number {
+  return canonicalizeBackendId(backend) === 'claude' ? ACP_CLAUDE_REVIEW_TIMEOUT_SEC : ACP_REVIEW_TIMEOUT_SEC;
 }
 
 /**
@@ -96,6 +112,26 @@ export function makeAcpReviewLLM(opts: AcpReviewerOpts): (prompt: string, images
     // The injected seam deliberately accepts arbitrary test backends. The
     // production path alone resolves aliases and transport through the factory.
     const backend = canonicalizeBackendId(requestedBackend);
+    const timeoutMs = opts.timeoutMs ?? defaultAcpReviewTimeoutSec(backend) * 1000;
+    // ACP-REVIEW-VIA-TEAMCLAUDE (대표 10-21): a claude review goes through teamclaude (multi-account proxy) when it
+    //   answers with a base URL — same cct spawn as the subscription lane. No answer = the prior path, recorded.
+    let backendSpec = opts.backendSpec;
+    let childEnv = opts.env;
+    const resolveClaudeRoute = backend === 'claude' && !opts.backendSpec
+      ? opts.resolveClaudeRoute ?? (injected ? undefined
+        : async () => (await import('../self-dev/review-provider-fallback.js')).resolveTeamclaudeReviewRoute())
+      : undefined;
+    if (resolveClaudeRoute) {
+      let route: import('../self-dev/review-provider-fallback.js').TeamclaudeReviewRoute;
+      try { route = await resolveClaudeRoute(); } catch { route = { reason: 'teamclaude-unavailable' }; }
+      if (route.spawn) { backendSpec = route.spawn.backendSpec; childEnv = route.spawn.env; }
+      debug.log('review.acp', 'claude-route', {
+        viaTeamclaude: Boolean(route.spawn),
+        baseUrlSet: Boolean(childEnv?.ANTHROPIC_BASE_URL),
+        timeoutSec: Math.round(timeoutMs / 1000),
+        reason: route.reason,
+      });
+    }
     // ⛔⭐⭐⭐ 백엔드 해석은 «`try` 밖»이라 여기서 던지면 아래 `catch` 의 `acp-review/error` 가
     //   «안 걸린다**. 그래서 `--acp-backend claude-code`(미등록) 같은 오타를 주면 레지스트리가
     //   ***`Unknown ACP backend "claude-code". Known: …"`*** 라는 «완벽한» 오류를 던지는데도
@@ -105,14 +141,13 @@ export function makeAcpReviewLLM(opts: AcpReviewerOpts): (prompt: string, images
     //   ⇒ 이 한 줄만 자기 catch 로 감싼다(전체 try 를 앞당기면 `start` 관측이 그 안으로 들어간다).
     let transport: string | null;
     try {
-      transport = injected ? null : opts.backendSpec?.transport ?? getAcpBackend(backend).transport ?? 'acp';
+      transport = injected ? null : backendSpec?.transport ?? getAcpBackend(backend).transport ?? 'acp';
     } catch (e) {
       debug.log('acp-review', 'error', {
         requestedBackend, backend, stage: 'resolve-backend', message: (e as Error).message,
       }, { level: 'error' });
       throw e;
     }
-    const timeoutMs = opts.timeoutMs ?? 300_000;
     debug.log('acp-review', 'start', {
       requestedBackend,
       backend,
@@ -130,7 +165,7 @@ export function makeAcpReviewLLM(opts: AcpReviewerOpts): (prompt: string, images
     let capabilitiesObserved = false;
     const agentOpts: Omit<AcpAgentOpts, 'backendId'> = {
       cwd: opts.cwd,
-      ...(opts.backendSpec ? { backendSpec: opts.backendSpec, env: opts.env } : {}),
+      ...(backendSpec ? { backendSpec, env: childEnv } : {}),
       log: (message) => debug.log('acp-review', 'agent-log', { backend, message }),
       onCapabilities: (capabilities) => {
         capabilitiesObserved = true;
@@ -159,7 +194,7 @@ export function makeAcpReviewLLM(opts: AcpReviewerOpts): (prompt: string, images
     // chat agents, whose callbacks and lifecycle must not be mutated here.
     // Grok's start can hang before the manager registers the subprocess;
     // own it directly so the handshake timeout can stop that child.
-    const directAgent = injected || Boolean(opts.backendSpec) || backend === 'grok';
+    const directAgent = injected || Boolean(backendSpec) || backend === 'grok';
     const reviewManager = directAgent ? undefined : new AcpAgentManager();
     let agent: AcpAgent | undefined;
     let text = '';

package/src/agent-substrate/pr-reviewer.ts

@@ -684,7 +684,21 @@ const LONG_BRACKETED_SENTINEL = new RegExp(String.raw`^[([（【]\s*(?:[-—–]
 const KNOWN_NO_FINDING_REMARKS = new Set([
   // #27349 저장 JSON의 실제 무소견 문구.
   '문서 전용 변경이고 의도된 산출물이 실제로 존재하며 배선 누락·죽은 코드·Goodhart 해당 없음',
+  // #29974 ACP 실측: 단독 (없음) 뒤에 차단 결함 부재와 통과 근거를 적은 닫힌 문장.
+  '막는 결함은 찾지 못했다. ref → 전체 SHA 고정, 이미지 SHA12 태그, Job 쪽 `imageCommit==source.sha`·`image==shelfImage` 가드까지 한 줄로 이어진다.',
 ]);
+// #30028 ACP 저장 리뷰의 긍정 수용 서술. 광범위한 의미 추정보다 원문을 고정한다.
+const KNOWN_POSITIVE_FINDINGS = new Set([
+  '없음. 수용 기준은 코드와 시험 기준으로 충족한다.',
+  '프로토타입 키(`constructor`·`__proto__`)를 Map 으로 바르게 센다.',
+  '분모는 `task-agent/entrance-denominator` 별도 이벤트로만 나간다. `task-agent/action` 은 그대로다.',
+  'retro 사실과 tasks cover 집계는 분모 줄이 있든 없든 같다. 시험(`retro-cli.test.ts`)이 이를 고정하고, 임시 폴더는 `finally` 의 `rmSync` 로 지운다.',
+  // 이 후속 PR 자체의 ACP r2: 닫힌 무소견 문장.
+  '없음 — 막는 결함은 찾지 못했다.',
+]);
+function isPositiveNoFinding(text: string): boolean {
+  return KNOWN_POSITIVE_FINDINGS.has(text);
+}
 /** 괄호 안 `없음` 뒤 설명이 닫힌 무소견 문법에 정확히 들어가는가. */
 function isLongNoFindingBracket(text: string): boolean {
   const m = LONG_BRACKETED_SENTINEL.exec(text.trim());
@@ -699,8 +713,11 @@ function isLongNoFindingBracket(text: string): boolean {
 export function isNoneSentinelFinding(finding: string): boolean {
   const text = finding.trim();
   if (!text || isBracketedPlaceholder(text)) return true;
+  if (isPositiveNoFinding(text)) return true;
   if (/^[-—–]+$/.test(text)) return true;
   const markerText = text.replace(/^[—–-]+\s*|\s*[—–-]+$/g, '').trim();
+  const leadingNone = /^[（(]\s*(?:없음|none)\s*[）)]\s+(.+)$/i.exec(markerText);
+  if (leadingNone && KNOWN_NO_FINDING_REMARKS.has(leadingNone[1]!.trim())) return true;
   if (markerText && (BARE_SENTINEL.test(markerText) || DASH_ONLY_SENTINEL.test(markerText) || DASH_WRAPPED_BRACKETED_SENTINEL.test(markerText))) return true;
   const bracketed = BRACKETED_SENTINEL.exec(markerText);
   if (bracketed) {