elanous 0.2.32 → 0.2.35

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/acp/core-turn-bridge.ts

@@ -54,6 +54,7 @@ import { readOriginSessionMeta } from './origin-session-meta.js';
 import { isFactQuestion } from './fact-question.js';
 import { classifyTuiChatIntent, formatTuiRouteLine, isSeatOpsDirective, type TuiChatRoute } from '../core-turn/short-question.js';
 import { HARNESS_ROLE_ENV } from '../harness/harness-space.js';
+import { createReasoningThoughtBuffer } from './reasoning-thought-buffer.js';
 
 const FACT_QUESTION_INSTRUCTION = '사실·최신 정보 질문이다. WebSearch 를 1~2회 쓰고 검색 결과(제목·스니펫·URL)로 답하라. 출처 링크를 붙여라. 셸·브라우저·파일 도구는 검색 결과로 부족할 때만. 도구 예산에 닿으면 지금까지 근거로 답하고 끝에 «더 찾아볼까요?»를 붙여라.';
 
@@ -382,6 +383,16 @@ export function bridgeCoreTurnToAcp(
             return approvedDispatch(name, args, dispatchCtx);
           }
         : approvedDispatch;
+      // TUI-TURN-NARRATION 조각 2 — 추론 요약을 «문단» 단위로 모아 ACP `agent_thought_chunk`
+      //   (`_meta.reasoning: true`)로 보낸다. 대시보드가 흐린 💭 한 줄로 그린다(`acp-chat.ts`).
+      //   ⛔ 전에는 debug.log 로만 남아 화면엔 «무엇을 하는지»가 0줄이었다(결함 #87).
+      const reasoningThoughts = createReasoningThoughtBuffer((text) => {
+        debug.log('llm.reasoning', 'thought-emitted', { sessionId: turnCtx.sessionId, chars: text.length });
+        void turnCtx.pushSessionUpdate(
+          { sessionUpdate: 'agent_thought_chunk', content: { type: 'text', text } },
+          { reasoning: true },
+        );
+      });
       const dispatchResult = await runTurnDispatch({
         sessionId: turnCtx.sessionId,
         ...(originSessionId ? { originSessionId } : {}),
@@ -403,6 +414,7 @@ export function bridgeCoreTurnToAcp(
             // contract is synchronous onText. Chunks are delivered in
             // order because `sessionUpdate` is serialized per-
             // connection on the ACP SDK side.
+            if (delta.length > 0) reasoningThoughts.flush();
             streamedTextSum += delta;
             void turnCtx.push(delta);
           },
@@ -420,6 +432,7 @@ export function bridgeCoreTurnToAcp(
               toolKinds.add(call.name);
               observeToolBudget();
             }
+            reasoningThoughts.flush();
             void turnCtx.pushToolCall(call);
           },
           onToolResult: (call) => { void turnCtx.pushToolResult(call); },
@@ -435,15 +448,15 @@ export function bridgeCoreTurnToAcp(
               ...(resolvedRoute ? { routeProvider: resolvedRoute.provider } : {}),
             });
           },
-          // Codex Responses API reasoning summary stream. Currently
-          // surfaced via forensic only (debug.log) — acts as the
-          // "did the model actually emit reasoning?" verification
-          // signal before we wire the dashboard UI in a fast-follow.
+          // Codex Responses API reasoning summary stream. Surfaced to the
+          // dashboard as `agent_thought_chunk` via `reasoningThoughts`
+          // (TUI-TURN-NARRATION 조각 2) ⊕ the forensic debug.log below.
           // The forensic line carries the streamed delta and the
           // running summary index so a single grep gives the
           // reasoning trace in order. summary_part_added marks the
           // paragraph boundary; summary_delta is the text within.
           onReasoning: (event) => {
+            reasoningThoughts.onEvent(event);
             if (debug.enabled) {
               if (event.kind === 'summary_delta') {
                 debug.log('llm.reasoning', 'codex.summary.delta', {
@@ -459,6 +472,7 @@ export function bridgeCoreTurnToAcp(
             }
           },
           onTurnComplete: async (newMessages) => {
+            reasoningThoughts.flush();
             // Surface runtime-injected synthesis to ACP. emitTurnComplete
             // pushes the final assistant text (which may be the W5-E/F/G
             // force-synthesis output) into history. Compare to what was
@@ -592,7 +606,8 @@ export function bridgeCoreTurnToAcp(
             }
           },
         },
-      });
+      // 오류·취소로 끝나 onTurnComplete 가 안 불려도 마지막 추론 문단을 내보낸다(#28964 리뷰 FU-1 · 빈 버퍼면 무동작).
+      }).finally(() => reasoningThoughts.flush());
       // ⭐ 인증 거절은 코어 턴이 «던지지 않고» 돌려준다 — 여기서 안 읽으면 서버는 end_turn 을 내고
       //   TUI 엔 «✔ 완료»만 남는다(TUI 결함 #22). 던져서 실패 경로(prompt-failed · 오류 줄)로 보낸다.
       const stopReason = (dispatchResult as { stopReason?: unknown } | null | undefined)?.stopReason;

package/src/acp/reasoning-thought-buffer.ts

@@ -0,0 +1,45 @@
+// TUI-TURN-NARRATION 조각 2 — 추론 요약(reasoning summary)을 화면 한 줄로 낸다.
+//
+// 🩸 왜 있나 (결함 #87 · 2026-10-18): gpt-6 계열 TUI 턴은 도구 사이에 글을 0자 낸다
+//   (`llm.stream consume-end` `textChars=0`). 그런데 추론 요약은 라운드마다 24~37자씩 «온다»
+//   (`reasoningChars`). `core-turn-bridge` 의 `onReasoning` 이 debug.log 로만 남기고
+//   화면으로 안 보내서, 사용자는 «무엇을 하는지» 한 줄도 못 봤다.
+//   대시보드는 이미 `agent_thought_chunk` ⊕ `_meta.reasoning` 을 흐린 💭 줄로 그린다
+//   (`dashboard/chat/acp-chat.ts`) — 빠진 것은 «주는 자리» 하나였다.
+//
+// ⭐ 델타를 그대로 흘리지 않고 «문단» 단위로 모은다 — 델타마다 보내면 한 생각이 여러 줄로 찢긴다.
+//   문단 경계 = 다음 `summary_part_added` · 도구 호출 · 답 글 시작 · 턴 끝.
+
+export type ReasoningEvent =
+  | { kind: 'summary_part_added'; summaryIndex?: number }
+  | { kind: 'summary_delta'; delta: string; summaryIndex?: number };
+
+export interface ReasoningThoughtBuffer {
+  onEvent(event: ReasoningEvent): void;
+  /** 모은 문단을 내보낸다(비었으면 아무것도 안 한다). */
+  flush(): void;
+}
+
+/** 요약 문단은 짧다(실측 24~37자). 폭주 방어로만 자른다. */
+const MAX_THOUGHT_CHARS = 400;
+
+export function createReasoningThoughtBuffer(emit: (text: string) => void): ReasoningThoughtBuffer {
+  let buf = '';
+  const flush = (): void => {
+    const text = buf.trim();
+    buf = '';
+    if (text.length === 0) return;
+    emit(text.length > MAX_THOUGHT_CHARS ? `${text.slice(0, MAX_THOUGHT_CHARS)}…` : text);
+  };
+  return {
+    onEvent(event) {
+      if (event.kind === 'summary_part_added') {
+        flush();
+        return;
+      }
+      // 모으는 단계에서도 상한을 지킨다 — 문단 경계 없이 긴 스트림이 와도 버퍼가 무한히 크지 않게.
+      if (buf.length <= MAX_THOUGHT_CHARS) buf += event.delta.slice(0, MAX_THOUGHT_CHARS + 1 - buf.length);
+    },
+    flush,
+  };
+}

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 {