elanous 0.2.34 → 0.2.36

package/scripts/release-loop/traffic-transition.ts

@@ -0,0 +1,159 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { debug } from '../../src/debug/log.js';
+import type { GraphContext } from './node-verdict.js';
+import type { ReleaseLoopConfig } from './unattended-release.js';
+
+export type ReleaseTrafficEvent = 'gate-passed' | 'verify-complete';
+
+export interface TrafficFile {
+  global?: string;
+  seats: Record<string, Record<string, unknown>>;
+  releaseLifecycle?: { runId: string; version: string; stage: 1 | 2; event: ReleaseTrafficEvent; startedAt?: string; updatedAt: string };
+  [key: string]: unknown;
+}
+
+type ReleaseTrafficConfig = ReleaseLoopConfig & {
+  trafficFile?: string;
+};
+
+const SEATS = ['OP', 'TC', 'MK', 'UX'] as const;
+const STAGE: Record<ReleaseTrafficEvent, 1 | 2> = { 'gate-passed': 1, 'verify-complete': 2 };
+const TRAFFIC_PER_CYCLE = { half: 3, full: 6 } as const;
+
+export interface TrafficTransitionOptions {
+  trafficFile?: string;
+  lockTimeoutMs?: number;
+  now?: () => Date;
+  log?: (event: string, fields: Record<string, unknown>) => void;
+}
+
+function waitSync(ms: number): void {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+
+function acquireTrafficLock(path: string, timeoutMs = 10_000): () => void {
+  const lock = `${path}.lock.d`;
+  const deadline = Date.now() + timeoutMs;
+  for (let attempt = 0; ; attempt += 1) {
+    try {
+      mkdirSync(lock);
+      try { writeFileSync(`${lock}/pid`, `${process.pid}\n`, { flag: 'wx', mode: 0o600 }); }
+      catch (error) { rmSync(lock, { recursive: true, force: true }); throw error; }
+      return () => rmSync(lock, { recursive: true, force: true });
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'EEXIST') throw error;
+      try {
+        // A directory cannot be conditionally renamed by identity. Reclaiming after
+        // checking its PID can therefore move a replacement owner's live lock.
+        // Fail closed; OP can inspect and remove a stale lock after the warning mail.
+        readFileSync(`${lock}/pid`, 'utf8');
+        statSync(lock);
+      } catch { /* Unknown or concurrently changing locks are left intact. */ }
+      if (Date.now() >= deadline) throw new Error(`traffic lock timeout: ${lock}`);
+      waitSync(100);
+    }
+  }
+}
+
+function readTrafficFile(path: string): TrafficFile {
+  const parsed: unknown = JSON.parse(readFileSync(path, 'utf8'));
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) throw new Error('traffic file must contain a JSON object');
+  const file = parsed as TrafficFile;
+  if (!file.seats || typeof file.seats !== 'object' || Array.isArray(file.seats)
+    || !SEATS.every((seat) => file.seats[seat] && typeof file.seats[seat] === 'object' && !Array.isArray(file.seats[seat]))) {
+    throw new Error('traffic seats object missing');
+  }
+  return file;
+}
+
+function atomicWriteTrafficFile(path: string, file: TrafficFile): void {
+  const temp = `${path}.tmp.${process.pid}.${Date.now()}`;
+  const mode = statSync(path).mode & 0o777;
+  try {
+    writeFileSync(temp, `${JSON.stringify(file, null, 2)}\n`, { flag: 'wx', mode });
+    renameSync(temp, path);
+  } catch (error) {
+    rmSync(temp, { force: true });
+    throw error;
+  }
+}
+
+function compareReleaseVersions(left: string, right: string): number {
+  const parse = (value: string) => /^(\d+)\.(\d+)\.(\d+)(?:-(alpha|beta|rc)\.(\d+))?$/.exec(value);
+  const a = parse(left), b = parse(right);
+  if (!a || !b) return left.localeCompare(right);
+  for (const index of [1, 2, 3]) {
+    const delta = Number(a[index]) - Number(b[index]);
+    if (delta) return Math.sign(delta);
+  }
+  if (!a[4] || !b[4]) return a[4] ? -1 : b[4] ? 1 : 0;
+  const rank = { alpha: 0, beta: 1, rc: 2 } as const;
+  const kind = rank[a[4] as keyof typeof rank] - rank[b[4] as keyof typeof rank];
+  return kind || Math.sign(Number(a[5]) - Number(b[5]));
+}
+
+function isLaterRun(current: string | undefined, previous: string | undefined): boolean {
+  return Boolean(current && previous && current > previous);
+}
+
+/** Apply one monotonic release graph event while preserving unrelated traffic policy fields. */
+export async function applyReleaseTrafficEvent(
+  context: GraphContext,
+  event: ReleaseTrafficEvent,
+  options: TrafficTransitionOptions,
+): Promise<{ applied: boolean; stage: number; reason?: string }> {
+  if (!context.runId) throw new Error('release traffic event requires graph runId');
+  if (!options.trafficFile) throw new Error('traffic file path is not configured');
+  const runId = context.runId;
+  const version = context.input.version;
+  const path = resolve(options.trafficFile);
+  if (!existsSync(path)) throw new Error(`traffic file does not exist: ${path}`);
+  const log = options.log ?? ((name, fields) => debug.log('release-loop.traffic', name, fields));
+  const stage = STAGE[event];
+  const stamp = (options.now ?? (() => new Date()))().toISOString();
+  const rate = event === 'gate-passed' ? TRAFFIC_PER_CYCLE.half : TRAFFIC_PER_CYCLE.full;
+  const releaseLifecycle = { runId, version, stage, event, ...(context.startedAt ? { startedAt: context.startedAt } : {}), updatedAt: stamp };
+  const release = () => {
+    const unlock = acquireTrafficLock(path, options.lockTimeoutMs);
+    try {
+      const before = readTrafficFile(path);
+      const prior = before.releaseLifecycle;
+      const sameRun = prior?.runId === runId;
+      const newerVersion = !prior?.runId || compareReleaseVersions(version, prior.version) > 0;
+      const sameVersionLaterRun = prior?.version === version && isLaterRun(context.startedAt, prior.startedAt);
+      if (sameRun && prior.stage >= stage) return { file: before, applied: true, idempotent: true };
+      const permitted = sameRun
+        ? prior.stage === stage - 1
+        : newerVersion || (event === 'gate-passed' && prior?.version === version && (prior.stage ?? 0) < 2 && sameVersionLaterRun)
+          || (event === 'verify-complete' && prior?.version === version && sameVersionLaterRun);
+      if (!permitted) {
+        return { file: before, applied: false, idempotent: false, reason: prior?.runId && prior.runId !== runId ? 'different-run-is-current' : 'event-out-of-order' };
+      }
+      const after: TrafficFile = {
+        ...before,
+        ...(event === 'verify-complete' ? { global: 'green' } : {}),
+        seats: Object.fromEntries(Object.entries(before.seats).map(([seat, value]) => [
+          seat, SEATS.includes(seat as typeof SEATS[number]) ? { ...value, perCycle: rate } : value,
+        ])),
+        releaseLifecycle,
+      };
+      atomicWriteTrafficFile(path, after);
+      return { file: after, applied: true, idempotent: false };
+    } finally { unlock(); }
+  };
+  const result = release();
+  const reason = result.applied && result.idempotent ? 'already-applied' : result.reason;
+  log(result.idempotent ? 'already-applied' : result.applied ? 'applied' : 'ignored', {
+    runId, version, event, stage, reason, perCycle: rate, ...(event === 'verify-complete' ? { global: 'green' } : {}),
+  });
+  return { applied: result.applied, stage: result.file.releaseLifecycle?.stage ?? 0, ...(reason ? { reason } : {}) };
+}
+
+export function trafficOptionsFromConfig(env: NodeJS.ProcessEnv = process.env, rawConfig: ReleaseLoopConfig = {}): TrafficTransitionOptions {
+  const config = rawConfig as ReleaseTrafficConfig;
+  const envTrafficFile = env.ELANOUS_RELEASE_TRAFFIC_FILE?.trim();
+  const configTrafficFile = typeof config.trafficFile === 'string' ? config.trafficFile.trim() : undefined;
+  const trafficFile = envTrafficFile || configTrafficFile;
+  return trafficFile ? { trafficFile } : {};
+}

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/rhythm/daily.ts

@@ -15,7 +15,10 @@ import { loopEvent } from '../../src/loops/observe.js';
 import { kindRouteTarget, mainHomeTarget } from '../../src/domains/telegram-kind-route.js';
 import { recordOutbound } from '../../src/domains/outbound-alert.js';
 import { listSelfDevRuns, runSummaryLine, selfDevRunsDir } from '../../src/self-dev/run-store.js';
-import { runDraftSweep } from '../../src/self-dev/draft-sweep.js';
+import { runDraftSweep, sweptReasonLabel } from '../../src/self-dev/draft-sweep.js';
+import { LogStore } from '../../src/mss/logging/log-store.js';
+import { BriefItemsLedger } from '../../src/briefing/brief-items.js';
+import { debug } from '../../src/debug/log.js';
 import { retroBriefingLines } from '../../src/retro/daily.js';
 import { dispatchCooAdmin } from '../../src/domains/coo-admin-tool.js';
 
@@ -76,6 +79,133 @@ export function collectRunSummaries(now: Date, root = effectiveInstanceRoot(), l
       prNumbers }));
 }
 
+/**
+ * DRAFT-SWEEP-DAILY-SUMMARY — 닫힌 draft 사유를 «하루 한 번 브리핑 원장 1건» 으로 적는다.
+ * 사유의 정본은 DRAFT-SWEEP-QUIET 이 닫을 때 남기는 `closed` 로그(PR 댓글 0 계약은 그쪽이 지킨다)이고,
+ * 이 경로는 로그 원장 «읽기» ⊕ 브리핑 원장 «쓰기» 만 한다 — GitHub 에 아무것도 쓰지 않는다.
+ */
+export const DRAFT_CLOSE_BRIEF_SOURCE = 'rhythm.daily.draft-close';
+/** DRAFT-SWEEP-QUIET 가 닫힌 draft마다 남기는 로그 — 사유의 정본 좌표. */
+const SWEPT_DRAFT_LOG = { category: 'self-dev.draft-sweep', event: 'closed' } as const;
+const SWEPT_LABEL_PREFIX = 'elanous:swept:';
+
+export type ClosedDraftReason = { reason: string; count: number };
+export type ClosedDraftCount = { closed: number; reasons: ClosedDraftReason[]; unreadable: number };
+export type DraftCloseSummary = {
+  /** 요약이 다루는 날짜(어제, KST). */
+  day: string;
+  closed: number;
+  reasons: ClosedDraftReason[];
+  /** 브리핑 원장에 실린 한 줄 — 표본이 없으면 null. */
+  text: string | null;
+  state: 'recorded' | 'already-recorded' | 'unmeasured' | 'unreadable';
+  /** 미측정·실패 사유(한 줄). */
+  detail?: string;
+  itemId?: number;
+};
+
+/** `closed` 로그 한 줄의 `{ reason }` — Pod 전달 래퍼(`originalData`)도 벗긴다. 못 읽으면 null. */
+function closedLogReason(data: string | null): string | null {
+  if (typeof data !== 'string' || !data.trim()) return null;
+  let payload: unknown;
+  try { payload = JSON.parse(data); } catch { return null; }
+  let body = record(payload);
+  const forwarded = body.originalData;
+  if (forwarded !== undefined) {
+    if (typeof forwarded !== 'string') body = record(forwarded);
+    else { try { body = record(JSON.parse(forwarded)); } catch { return null; } }
+  }
+  const reason = string(body.reason).trim();
+  return reason ? shortReason(reason) : null;
+}
+
+/** 사유를 DRAFT-SWEEP-QUIET 의 사유 종류로 접는다(`superseded-by #24123` → `superseded-by`). */
+export function sweptReasonKind(reason: string): string {
+  const label = sweptReasonLabel(reason);
+  return label.startsWith(SWEPT_LABEL_PREFIX) ? label.slice(SWEPT_LABEL_PREFIX.length) : label;
+}
+
+/**
+ * 어제(KST 00:00–24:00) 닫힌 draft 사유를 로그 원장에서 센다.
+ * ⛔ 원장이 없거나 못 읽으면 null — «0건»이 아니라 «미측정»이다.
+ */
+export function collectClosedDrafts(root: string, now: Date): ClosedDraftCount | null {
+  const path = join(root, 'logs', 'logs.db');
+  if (!existsSync(path)) return null;
+  const from = new Date(`${kstDay(new Date(now.getTime() - 86_400_000))}T00:00:00+09:00`);
+  const store = LogStore.openReadOnly(path);
+  try {
+    const rows = store.queryAll({ exactCategories: [SWEPT_DRAFT_LOG.category], events: [SWEPT_DRAFT_LOG.event],
+      sinceMs: from.getTime(), untilMs: from.getTime() + 86_400_000 - 1 });
+    const counts = new Map<string, number>();
+    let unreadable = 0;
+    for (const row of rows) {
+      const reason = closedLogReason(row.data);
+      if (reason === null) { unreadable += 1; continue; }
+      const kind = sweptReasonKind(reason);
+      counts.set(kind, (counts.get(kind) ?? 0) + 1);
+    }
+    return { closed: [...counts.values()].reduce((sum, count) => sum + count, 0),
+      reasons: [...counts].map(([reason, count]) => ({ reason, count }))
+        .sort((a, b) => b.count - a.count || sortNames(a.reason, b.reason)),
+      unreadable };
+  } finally { store.close(); }
+}
+
+/** 브리핑 한 줄 — 사유 종류별 건수, 상위 5종만 적고 나머지는 «외 N종» 으로 접는다. */
+export function composeDraftCloseSummaryText(reasons: readonly ClosedDraftReason[]): string {
+  const total = reasons.reduce((sum, item) => sum + item.count, 0);
+  const shown = reasons.slice(0, 5).map(item => `${item.reason} ${item.count}`).join(' · ');
+  const omitted = Math.max(0, reasons.length - 5);
+  return `어제 닫힌 draft ${total}건${shown ? ` — ${shown}` : ''}${omitted > 0 ? ` · 외 ${omitted}종` : ''}`;
+}
+
+/**
+ * 어제 닫힌 draft 사유를 브리핑 원장(`<state>/briefing/items.sqlite`, `eln brief`)에 **하루 1건** 으로 적는다.
+ * 표본이 없거나 원장을 못 읽으면 아무것도 쓰지 않고 `unmeasured`/`unreadable` 로 남긴다(«0건»으로 적지 않는다).
+ * 관측은 `deps.log`(루프 tick 전용)가 아니라 로그에 직접 남긴다 — 데일리 tick 의 의미를 바꾸지 않는다.
+ */
+export function recordDraftCloseSummary(root: string, now: Date,
+  log: (category: string, event: string, data?: unknown) => void = (category, event, data) => debug.log(category, event, data),
+): DraftCloseSummary {
+  const observe = (summary: DraftCloseSummary): DraftCloseSummary => {
+    try {
+      log('rhythm.daily', 'draft-close-summary', { day: summary.day, closed: summary.closed, state: summary.state,
+        reasons: summary.reasons.map(item => `${item.reason} ${item.count}`).join(' · '),
+        ...(summary.detail ? { detail: summary.detail } : {}), ...(summary.itemId === undefined ? {} : { itemId: summary.itemId }) });
+    } catch { /* 관측 실패가 브리핑을 막지 않는다 */ }
+    return summary;
+  };
+  const day = kstDay(new Date(now.getTime() - 86_400_000));
+  let counted: ClosedDraftCount | null;
+  try { counted = collectClosedDrafts(root, now); }
+  catch (error) { return observe({ day, closed: 0, reasons: [], text: null, state: 'unreadable',
+    detail: shortReason(`로그 원장 못 읽음 · ${reasonOf(error)}`) }); }
+  if (counted === null) return observe({ day, closed: 0, reasons: [], text: null, state: 'unmeasured', detail: '로그 원장 없음' });
+  if (counted.closed === 0) return observe({ day, closed: 0, reasons: [], text: null, state: 'unmeasured',
+    detail: counted.unreadable > 0 ? `사유 못 읽은 closed 로그 ${counted.unreadable}건` : '닫힌 draft 없음' });
+  // 사유를 못 읽은 closed 로그가 섞이면 읽힌 건수만으로 닫힘 총수를 단정할 수 없다 — 원장에 확정 기록하지 않고 부분 미측정으로 남긴다.
+  if (counted.unreadable > 0) return observe({ day, closed: counted.closed, reasons: counted.reasons, text: null,
+    state: 'unmeasured',
+    detail: `사유 못 읽은 closed 로그 ${counted.unreadable}건 — 읽힌 ${counted.closed}건만 셈(부분 미측정)` });
+  const text = composeDraftCloseSummaryText(counted.reasons);
+  try {
+    const ledger = new BriefItemsLedger({ stateDir: root, now: () => now, log });
+    const today = kstDay(now);
+    const recorded = ledger.list().find(item => item.source === DRAFT_CLOSE_BRIEF_SOURCE
+      && kstDay(new Date(item.created_at)) === today);
+    if (recorded) return observe({ day, closed: counted.closed, reasons: counted.reasons, text,
+      state: 'already-recorded', itemId: recorded.id });
+    const item = ledger.add({ text, domain: '운영', priority: 'P2', source: DRAFT_CLOSE_BRIEF_SOURCE,
+      evidence: `elanous logs --category ${SWEPT_DRAFT_LOG.category} --event ${SWEPT_DRAFT_LOG.event} --since 24h`,
+      createdAt: now.toISOString(), dedupeKey: `${DRAFT_CLOSE_BRIEF_SOURCE}:${today}`, dedupeWithinMs: 86_400_000 });
+    return observe({ day, closed: counted.closed, reasons: counted.reasons, text, state: 'recorded', itemId: item.id });
+  } catch (error) {
+    return observe({ day, closed: counted.closed, reasons: counted.reasons, text, state: 'unreadable',
+      detail: shortReason(`브리핑 원장 못 씀 · ${reasonOf(error)}`) });
+  }
+}
+
 /** 기본은 어제 KST 00:00–24:00, 창을 주면 그 안에 실제 병합된 PR만 센다. */
 export async function collectLandings(now: Date, window?: { from: Date; to: Date }, source?: { repoRoot?: string; repoName?: string; stateRoot?: string }): Promise<Landing[]> {
   const configuredTree = source?.repoRoot ?? getUserConfig().ops?.cronRepoRoot;
@@ -495,7 +625,8 @@ export async function runDaily(options: { dryRun?: boolean; noNews?: boolean; st
         else loopEvent('rhythm-daily', 'tick', tick);
       }
     }
-    return { file, markdown, header, risks, sections, sent, ...vault, sendError, recordError, status, deliveryState, deliveryLine };
+    return { file, markdown, header, risks, sections, sent, ...vault, sendError, recordError, status, deliveryState, deliveryLine,
+      draftCloseSummary: undefined };
   }
   const safe = async <T>(fetch: () => Promise<T>): Promise<Section<T>> => {
     try { return { status: 'ok', value: await fetch() }; } catch (e) { return unreadable(reasonOf(e)); }
@@ -589,6 +720,9 @@ export async function runDaily(options: { dryRun?: boolean; noNews?: boolean; st
     writeFileSync(file, review.markdown);
   }
   const { vaultError, vaultFatal } = options.dryRun ? { vaultError: null, vaultFatal: false } : copyToVault(review.markdown, now, deps);
+  // DRAFT-SWEEP-DAILY-SUMMARY — 어제 닫힌 draft 사유를 오늘 브리핑 원장 1건으로 적는다(PR별 댓글 0 유지).
+  // --dry-run 은 원장에 쓰지 않는다(다른 산출물과 같은 규칙).
+  const draftCloseSummary = options.dryRun ? undefined : recordDraftCloseSummary(root, now);
   let enabled = deps.sendEnabled === true;
   let sendError: string | null = null;
   let deliveryState = options.stage === 'collect' ? 'pending' : options.dryRun ? 'dry-run' : 'send-disabled';
@@ -628,7 +762,7 @@ export async function runDaily(options: { dryRun?: boolean; noNews?: boolean; st
       else loopEvent('rhythm-daily', 'tick', tick);
     }
   }
-  return { file, ...review, sent, vaultError, vaultFatal, sendError, recordError, status, deliveryState, deliveryLine };
+  return { file, ...review, sent, vaultError, vaultFatal, sendError, recordError, status, deliveryState, deliveryLine, draftCloseSummary };
 }
 
 export async function main(args: string[] = process.argv.slice(2), deps: DailyDeps = {}): Promise<Awaited<ReturnType<typeof runDaily>>> {

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 {