elanous 0.2.36 → 0.2.38

package/src/acp/core-turn-bridge.ts

@@ -53,6 +53,7 @@ import type { AcpServerOptions, AcpTurnContext } from './server.js';
 import { acpToolDenialResult } from './tool-approval.js';
 import { readOriginSessionMeta } from './origin-session-meta.js';
 import { isFactQuestion } from './fact-question.js';
+import { resolveSessionSurfaceProfile } from '../session-runtime/index.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';
@@ -306,8 +307,11 @@ export function bridgeCoreTurnToAcp(
       // 사실 질문 예산은 «단일 턴» 전용이다 — goal loop 와 겹치면 예산을 다 쓴 뒤에도 루프가 계속 재촉해
       // 매 continuation 이 «Tool budget reached» 로 거부되고, 모델은 그것을 도구 장애로 읽어 blocked 를 남긴다
       // (10-14 13:48 운영 TUI OP: route short-question·goalLoop ⊕ factQuestion → 소진 뒤 헛호출 7회).
+      const surfaceProfile = resolveSessionSurfaceProfile({ userText: turnCtx.userText });
       const factShaped = isFactQuestion(turnCtx.userText);
-      const factQuestion = factShaped && !armGoalLoop;
+      // A quick research/turn lookup still keeps the fact budget. Only the
+      // multi-source research/agent route needs enough rounds to compare axes.
+      const factQuestion = factShaped && !armGoalLoop && surfaceProfile.id !== 'research/agent';
       if (factShaped && armGoalLoop) {
         try { debug.log('chat.turn', 'fact-budget-skipped', { reason: 'goal-loop-armed', route: route.route }); }
         catch { /* observation cannot interrupt a turn */ }
@@ -420,6 +424,7 @@ export function bridgeCoreTurnToAcp(
         sessionId: turnCtx.sessionId,
         ...(originSessionId ? { originSessionId } : {}),
         ...(turnCtx.userText ? { userText: turnCtx.userText } : {}),
+        surfaceProfile,
         messages: turnMessages,
         tools,
         dispatchTool,
@@ -429,6 +434,12 @@ export function bridgeCoreTurnToAcp(
         ...(maxToolTurns !== undefined ? { maxToolTurns } : {}),
         ...((!factQuestion || explicitMaxToolTurns !== undefined) && deps.budgetGrant !== undefined ? { budgetGrant: deps.budgetGrant } : {}),
         callbacks: {
+          onGoalInterim: (text) => {
+            void turnCtx.pushSessionUpdate(
+              { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: '' } },
+              { goalInterim: text },
+            );
+          },
           onText: (delta, full) => {
             // ⛔ 검증 보충이 붙은 최종 답의 재방출(`onText('', 답+보충)`)은 흘리지 않는다 — 빈 청크를 TUI 는
             //   «확정(commit)»으로 읽어 이미 그린 답을 굳히고, 아래 onTurnComplete 재표면화가 같은 답을

package/src/acp/stderr-summary.ts

@@ -0,0 +1,49 @@
+export interface AcpStderrSummary {
+  kind: string;
+  count: number;
+}
+
+const MAX_KINDS_PER_WINDOW = 8;
+const OTHER_KIND = 'other stderr messages';
+
+function classify(line: string): string {
+  const clean = line.replace(/\u001b\[[0-?]*[ -/]*[@-~]/g, '').trim();
+  if (/Skipping MCP tool\b/i.test(clean)) {
+    return clean
+      .replace(/\bserver=\S+/gi, 'server=*')
+      .replace(/\btool=\S+/gi, 'tool=*')
+      .replace(/tool name .+? is invalid/i, 'tool name <name> is invalid')
+      .slice(0, 240);
+  }
+  return clean.slice(0, 240);
+}
+
+/** Collect stderr into bounded, one-second UI summaries while callers retain raw lines in debug logs. */
+export function createAcpStderrSummarizer(
+  report: (summary: AcpStderrSummary) => void,
+  intervalMs = 1_000,
+): { push(line: string): void; flush(): void } {
+  const pending = new Map<string, number>();
+  let timer: ReturnType<typeof setTimeout> | undefined;
+
+  const flush = (): void => {
+    if (timer) clearTimeout(timer);
+    timer = undefined;
+    for (const [kind, count] of pending) report({ kind, count });
+    pending.clear();
+  };
+
+  return {
+    push(line): void {
+      const kind = classify(line);
+      if (!kind) return;
+      const key = pending.has(kind) || pending.size < MAX_KINDS_PER_WINDOW ? kind : OTHER_KIND;
+      pending.set(key, (pending.get(key) ?? 0) + 1);
+      if (!timer) {
+        timer = setTimeout(flush, intervalMs);
+        timer.unref?.();
+      }
+    },
+    flush,
+  };
+}

package/src/agent/monad-agent-turn.ts

@@ -172,6 +172,7 @@ export function makeElanousAgentRunTurn(cfg: UserConfig, surface: SessionSource,
           provider: cfg.llm.provider,
           configuredModel: cfg.llm.model,
           text: opts.userText,
+          surface,
           explicitModel: llmOpts?.model,
           routePolicy: cfg.llm.routePolicy,
         });

package/src/agent/run-context.ts

@@ -122,7 +122,7 @@ export function childLlmSelectionEnv(selection?: ChildLlmSelection): Record<stri
     };
   }
   // ⛔⭐ 상속 갈래도 local 이면 «주소»를 같이 넘긴다(BACKLOG B12 · 2026-09-25).
-  //   🩸 부모 env `ELANOUS_LLM_PROVIDER=local` ⊕ `LOCAL_LLM_URL=<node-b 경유 프록시>` 로 띄웠는데 자식엔 provider·model 만 가고
+  //   🩸 부모 env `ELANOUS_LLM_PROVIDER=local` ⊕ `LOCAL_LLM_URL=<원격 프록시>` 로 띄웠는데 자식엔 provider·model 만 가고
   //     주소가 빠져, 자식이 노드 캐시로 «호스트» LM Studio(127.0.0.1:1234)에 붙었다 — 준 엔드포인트가 조용히 무시됐다.
   const inheritedProvider = process.env.ELANOUS_LLM_PROVIDER?.trim();
   return {

package/src/agent/task-notification.ts

@@ -287,9 +287,11 @@ function formatDuration(ms: number): string {
  *  can `if (rendered) messages.unshift(...)` without branching on length. */
 export function renderTaskNotificationsXml(
   items: readonly PendingTaskNotification[],
+  options: { statusReceipt?: boolean } = {},
 ): string {
   if (items.length === 0) return '';
-  const lines: string[] = ['<task-notification>'];
+  const receiptAttrs = options.statusReceipt ? ' kind="status-receipt" request="none"' : '';
+  const lines: string[] = [`<task-notification${receiptAttrs}>`];
   for (const p of items) {
     const attrs = [
       `id="${escapeXml(p.taskId)}"`,

package/src/agent/terminal-surface.ts

@@ -25,6 +25,7 @@ import type { LLMOpts, LLMToolSpec } from '../llm.js';
 import type { FileSink } from '../channel/file-sink.js';
 import { PTY_SHELL_TOOL_NAMES } from '../boot/daemon-tools/pty-shell.js';
 import { killNonDetached as killNonDetachedPty } from '../pty-shell/registry.js';
+import { getCurrentPtyId } from './pty-identity.js';
 
 /** ① Conditional tool-budget grant for driving a headless terminal /
  *  coding agent. Keeps the tight per-family cap for ordinary turns
@@ -184,3 +185,219 @@ export function buildTerminalCapableTurn(base: TerminalCapableBase): TerminalCap
     [TERMINAL_CAPABLE_TURN_BRAND]: true,
   };
 }
+
+// ---------------------------------------------------------------------------
+// ⑤ TUI self-nest guard (TUI-NO-SELF-NEST · #27)
+//
+// A TUI turn already runs INSIDE a PTY owned by the outer TUI (the seat
+// shell). Spawning `eln` / `elanous` again from there nests a second TUI in
+// the same terminal: the two alt-screens and input loops overwrite each other
+// and the operator loses the seat ("screens fighting"). The guard refuses
+// exactly that one command shape and answers with guidance; every other
+// command (bash, `eln pty list`, `eln msg post`, …) keeps its current
+// behaviour, and the existing harness-write-boundary ledger path is
+// untouched — the reject is returned in the same `{ output }` envelope the
+// PtyShell dispatch already uses (precedent: skills/tools/pty.ts
+// dispatchPtyShellSend's reject-with-guidance).
+// ---------------------------------------------------------------------------
+
+/** Stable marker the reject message starts with — tests and the operator
+ *  read this; changing it is a behaviour change, not a wording tweak. */
+export const TUI_SELF_NEST_REJECT_MARKER = '[TUI 자기중첩 거부]';
+
+/** Binaries that ARE the elanous TUI (or its launcher). */
+const ELANOUS_TUI_BINARIES = new Set(['eln', 'elanous']);
+
+/** Subcommands that open an interactive TUI surface. A bare invocation
+ *  (`eln`) is the default TUI. Anything else keeps running as-is. */
+const ELANOUS_TUI_SUBCOMMANDS = new Set(['', 'tui', 'chat', 'dashboard', 'nexus']);
+
+/** Interpreter wrappers that can launch the TUI entry file. */
+const ELANOUS_LAUNCHER_BINARIES = new Set(['bun', 'node', 'bunx']);
+
+const ELANOUS_ENTRY_FILES = new Set(['elanous', 'elanous.mjs', 'elanous.cjs']);
+
+/** Global flags that consume the NEXT token as their value — without this
+ *  list `eln --config-dir /tmp/x dashboard` would read `/tmp/x` as the
+ *  subcommand. */
+const VALUE_TAKING_FLAGS = new Set([
+  '--config-dir',
+  '--state-dir',
+  '--cwd',
+  '--role-llm',
+  '--child-llm-provider',
+  '--child-llm-model',
+  '--model',
+  '--provider',
+  '--seat',
+  '--name',
+  '--session',
+  '--since',
+  '--grep',
+]);
+
+/** Flags that only ask for information (version / help). A call carrying one
+ *  of these never opens an interactive surface, so it is NOT a TUI launch:
+ *  refusing `eln --version` or `eln chat --help` inside a TUI would break a
+ *  non-interactive command — a false positive is an accident, not a guard. */
+const INFORMATIONAL_FLAGS = new Set(['--help', '-h', '--version', '-V']);
+
+function basenameOf(token: string): string {
+  const parts = token.split(/[\\/]/);
+  return (parts[parts.length - 1] ?? '').toLowerCase();
+}
+
+export type TuiCommandKind = 'elanous-tui-launch' | 'other';
+
+export interface TuiLaunchLook {
+  kind: TuiCommandKind;
+  /** Subcommand that opened the TUI ('' for a bare `eln`). */
+  subcommand: string | null;
+}
+
+/** Pure classifier: is this argv an elanous/eln TUI launch?
+ *
+ *  Accepts the direct form (`eln`, `/usr/local/bin/eln chat`) and the
+ *  interpreter form (`bun bin/elanous.mjs dashboard`). Leading flags are
+ *  skipped, but a flag's VALUE is never mistaken for the subcommand — an
+ *  unknown shape simply classifies as `other` (a false negative is safe;
+ *  a false positive would break unrelated commands). A call carrying an
+ *  informational flag (`--version` / `--help` / `-h` / `-V`) is `other` too,
+ *  whether the flag sits alone (`eln --version`) or after a TUI subcommand
+ *  (`eln chat --help`): it prints and exits, it never opens the surface. */
+export function classifyTuiLaunch(argv: readonly string[]): TuiLaunchLook {
+  if (argv.length === 0) return { kind: 'other', subcommand: null };
+  const head = basenameOf(argv[0] ?? '');
+
+  let rest: string[];
+  if (ELANOUS_TUI_BINARIES.has(head)) {
+    rest = argv.slice(1);
+  } else if (ELANOUS_LAUNCHER_BINARIES.has(head)) {
+    const entryIdx = argv.findIndex((tok, i) => i > 0 && ELANOUS_ENTRY_FILES.has(basenameOf(tok)));
+    if (entryIdx === -1) return { kind: 'other', subcommand: null };
+    rest = argv.slice(entryIdx + 1);
+  } else {
+    return { kind: 'other', subcommand: null };
+  }
+
+  const sub = firstPositional(rest);
+  if (!ELANOUS_TUI_SUBCOMMANDS.has(sub)) return { kind: 'other', subcommand: sub };
+  // 정보성 플래그가 붙은 호출(`eln --version`·`eln --help`·`eln chat --help`)은
+  // 기동이 아니라 출력 요청이다 — 대화형 표면을 열지 않으므로 `other` 로 보낸다.
+  if (asksForInformation(rest)) return { kind: 'other', subcommand: sub === '' ? null : sub };
+  return { kind: 'elanous-tui-launch', subcommand: sub };
+}
+
+/** True when the tokens ask for version/help output. The value of a
+ *  value-taking flag is skipped so `--grep --help` stays a value. */
+function asksForInformation(tokens: readonly string[]): boolean {
+  for (let i = 0; i < tokens.length; i += 1) {
+    const token = tokens[i] ?? '';
+    if (VALUE_TAKING_FLAGS.has(token)) {
+      i += 1;
+      continue;
+    }
+    if (INFORMATIONAL_FLAGS.has(token)) return true;
+  }
+  return false;
+}
+
+/** First non-flag token, skipping the value of a value-taking flag. */
+function firstPositional(tokens: readonly string[]): string {
+  for (let i = 0; i < tokens.length; i += 1) {
+    const token = tokens[i] ?? '';
+    if (token.startsWith('-')) {
+      if (VALUE_TAKING_FLAGS.has(token)) i += 1;
+      continue;
+    }
+    return token;
+  }
+  return '';
+}
+
+export interface TuiNestEnv {
+  parentPtyId: string | null;
+  nestDepth: number;
+}
+
+/** Read "am I already a TUI PTY child?" material from the same sources
+ *  src/pty-shell/registry.ts uses for a child's identity:
+ *  `ELANOUS_PARENT_PTY_ID` ?? `getCurrentPtyId()`, and `ELANOUS_NEST_DEPTH`. */
+export function readTuiNestEnv(env: NodeJS.ProcessEnv = process.env): TuiNestEnv {
+  let parentPtyId = env.ELANOUS_PARENT_PTY_ID?.trim() || null;
+  if (!parentPtyId) {
+    try {
+      parentPtyId = getCurrentPtyId() ?? null;
+    } catch {
+      parentPtyId = null;
+    }
+  }
+  const rawDepth = env.ELANOUS_NEST_DEPTH?.trim();
+  const parsedDepth = rawDepth === undefined || rawDepth === '' ? 0 : Number.parseInt(rawDepth, 10);
+  const nestDepth = Number.isFinite(parsedDepth) && parsedDepth > 0 ? parsedDepth : 0;
+  return { parentPtyId, nestDepth };
+}
+
+export type TuiSelfNestReason = 'already-inside-tui';
+
+export interface TuiSelfNestDecision {
+  reject: boolean;
+  reason: TuiSelfNestReason | null;
+  command: TuiCommandKind;
+  subcommand: string | null;
+  parentPtyId: string | null;
+  nestDepth: number;
+  /** Reject + guidance text; null when the command is allowed through. */
+  output: string | null;
+}
+
+function buildTuiSelfNestGuidance(input: {
+  argv: readonly string[];
+  parentPtyId: string | null;
+  nestDepth: number;
+}): string {
+  const shown = input.argv.join(' ');
+  const identity = [
+    input.parentPtyId ? `parent pty ${input.parentPtyId}` : 'parent pty 없음',
+    `nest depth ${input.nestDepth}`,
+  ].join(' · ');
+  return [
+    `${TUI_SELF_NEST_REJECT_MARKER} 이미 TUI PTY 안입니다 (${identity}).`,
+    `여기서 '${shown}' 를 다시 띄우면 두 TUI 화면·입력 루프가 서로를 덮어써 조작이 불가능해집니다.`,
+    '- 이미 열린 TUI 세션에서 계속하세요: elanous pty list → elanous pty snapshot <id> / elanous pty send <id> ...',
+    '- 새 TUI 가 정말 필요하면 이 PTY 밖(운영 터미널)에서 기동하세요.',
+    '- 도구 세션에서 셸이 필요하면 TUI 가 아니라 일반 셸을 여세요: PtyShellStart { cmd: "bash" }.',
+  ].join('\n');
+}
+
+/** Pure decision function: reject `eln`/`elanous` TUI launches when this
+ *  process already lives inside a TUI PTY (parent pty id or nest depth ≥ 1).
+ *  Everything else is allowed through with `reject: false`. */
+export function decideTuiSelfNest(
+  argv: readonly string[],
+  env: NodeJS.ProcessEnv = process.env,
+): TuiSelfNestDecision {
+  const look = classifyTuiLaunch(argv);
+  const nest = readTuiNestEnv(env);
+  const insideTui = Boolean(nest.parentPtyId) || nest.nestDepth >= 1;
+  if (look.kind !== 'elanous-tui-launch' || !insideTui) {
+    return {
+      reject: false,
+      reason: null,
+      command: look.kind,
+      subcommand: look.subcommand,
+      parentPtyId: nest.parentPtyId,
+      nestDepth: nest.nestDepth,
+      output: null,
+    };
+  }
+  return {
+    reject: true,
+    reason: 'already-inside-tui',
+    command: look.kind,
+    subcommand: look.subcommand,
+    parentPtyId: nest.parentPtyId,
+    nestDepth: nest.nestDepth,
+    output: buildTuiSelfNestGuidance({ argv, parentPtyId: nest.parentPtyId, nestDepth: nest.nestDepth }),
+  };
+}

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

@@ -655,6 +655,7 @@ export function buildReviewPrompt(
     '  - WARN = ships but has non-blocking concerns.',
     '  - PASS = correct and sound (a watch item is still fine).',
     'Then optionally a line "MUST-FIX:" followed by blocker findings (one per line, "- " prefix),',
+    'If there are no blockers, leave MUST-FIX empty; do not put “없음”, “결함 없음”, “none”, or any explanatory no-finding sentence in that list.',
     'then optionally a line "SHOULD-FIX:" followed by non-blocker findings ("- " prefix). Keep each finding one concise line.',
     'Then optionally a line "REQUIREMENTS:" followed by repository context you need to inspect before making a determination ("- " prefix). This is observational only and does not change the verdict.',
   ].join('\n');
@@ -689,14 +690,17 @@ const NO_FINDING_REMARK = new RegExp([
   String.raw`^(?:(?:블로커|차단)\s*)?(?:수준의?\s*)?(?:결함|문제|이슈|지적|블로커)(?:은|는|이|가)?\s*(?:발견되지\s*않(?:음|았(?:다|습니다)?)|없(?:음|다|습니다))[.。]?$`,
   // REVIEW-MUSTFIX-NONE-PARSE — `(없음 — 이 조각 범위에서는 차단 결함 없음)` 꼬리.
   String.raw`^(?:이\s*)?(?:조각\s*)?범위(?:에서는|에서|엔)?\s*(?:블로커|차단)(?:\s*(?:수준의?\s*)?(?:결함|문제|이슈|지적))?\s*없(?:음|다|습니다)[.。]?$`,
-  String.raw`^(?:no|zero)\s+(?:blocking\s+)?(?:blockers?|issues?|problems?|findings?|must-?fix(?:es)?)(?:\s+found)?\.?$`,
+  String.raw`^이\s*조각에서\s*확인된\s*코어\s*결함\s*없음\s*[—–-]\s*명시\s*intent\s*기준\s*mustFix\s*는\s*비움$`,
+  String.raw`^이\s*조각에서\s*검증된\s*(?:차단\s*)?결함은\s*발견되지\s*않음(?:\s*\(mustFix\s*\[\]\))?$`,
+  String.raw`^코드\s*경로\s*자체는\s*결함\s*없음[.。]?$`,
+  String.raw`^(?:no|zero)\s+(?:blocking\s+)?(?:blockers?|defects?|issues?|problems?|findings?|must-?fix(?:es)?)(?:\s+found)?\.?$`,
   String.raw`^nothing\s+(?:blocking|to\s+fix)\.?$`,
   // REVIEW-MUSTFIX-NONE-SENTINEL — `(없음 — 수용기준 충족)` · `(none — acceptance criteria met)` (GLM 실측 6건). «미충족» 은 ^ 앵커로 안 맞는다.
   String.raw`^수용\s*기준(?:을|이)?\s*(?:(?:모두|전부)\s*)?충족(?:함|됨|했다|합니다)?[.。]?$`,
   String.raw`^(?:all\s+)?acceptance\s+criteria\s+(?:are\s+)?(?:all\s+)?met\.?$`,
 ].join('|'), 'i');
-// Unbracketed free text is more ambiguous; fold only explicit blocker-absence statements.
-const UNBRACKETED_NO_FINDING_REMARK = /^(?:(?:블로커|차단)\s*)?(?:수준의?\s*)?(?:결함|문제|이슈|지적|블로커)(?:은|는|이|가)?\s*(?:발견되지\s*않(?:음|았(?:다|습니다)?)|없(?:음|다|습니다))[.。]?$/i;
+// Whole-item no-finding statements are safe to fold. Any additional clause is kept fail-closed.
+const UNBRACKETED_NO_FINDING_REMARK = /^(?:(?:블로커|차단|코어|실제)\s*)?(?:수준의?\s*)?(?:결함|문제|이슈|지적|블로커|findings?|defects?|issues?|problems?|blockers?)(?:은|는|이|가)?\s*(?:발견되지\s*않(?:음|았(?:다|습니다)?)|없(?:음|다|습니다)|not\s+found|none\s+found)[.。]?$/i;
 // OP #3173 — 설명은 의미 추정하지 않는다. 실측으로 무소견임을 확인한 문장만 등록한다.
 // 문법 밖 `없음 — 설명`은 실제 결함일 수 있으므로 mustFix에 남긴다.
 const LONG_BRACKETED_SENTINEL = new RegExp(String.raw`^[([（【]\s*(?:[-—–]+\s*)?${NONE_WORD}\s*[—–\-:·]\s*([\s\S]+?)\s*[)\]）】]$`, 'i');
@@ -752,8 +756,12 @@ export function isNoneSentinelFinding(finding: string): boolean {
   const markerText = text.replace(/^[—–-]+\s*|\s*[—–-]+$/g, '').trim();
   const unbracketedNone = new RegExp(String.raw`^${NONE_WORD}\s*[—–\-:·]\s*(.+)$`, 'i').exec(markerText);
   if (unbracketedNone && UNBRACKETED_NO_FINDING_REMARK.test(unbracketedNone[1]!.trim())) return true;
+  if (UNBRACKETED_NO_FINDING_REMARK.test(markerText)) return true;
   const leadingNone = /^[（(]\s*(?:없음|none)\s*[）)]\s+(.+)$/i.exec(markerText);
   if (leadingNone && KNOWN_NO_FINDING_REMARKS.has(leadingNone[1]!.trim())) return true;
+  if (NO_FINDING_REMARK.test(markerText)) return true;
+  const bracketedRemark = BRACKETED_PLACEHOLDER.exec(markerText);
+  if (bracketedRemark && NO_FINDING_REMARK.test(bracketedRemark[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) {

package/src/agent-substrate/review-observation.ts

@@ -15,6 +15,7 @@
 // 순수 함수로 둔 이유: 절단 정책(무엇을 얼마나 남기나)이 **회귀 테스트 대상**이기 때문이다.
 // 로그가 폭주하면 관측 자체가 못 쓰게 되고, 너무 줄이면 감사가 안 된다 — 그 균형을 테스트로 고정한다.
 
+import { createHash } from 'node:crypto';
 import { redactSecretText } from '../debug/log.js';
 import { isScopeRevertMustFix, type ReviewResult } from './pr-reviewer.js';
 
@@ -31,6 +32,8 @@ interface ReviewObservationInput {
   readonly model: string;
   /** 리뷰에 준 의도(수용기준). 원문은 길어 **길이만** 남긴다 — 무엇을 기준으로 판정했나의 지표. */
   readonly intent: string;
+  /** Deterministic content-free fingerprint of the intent actually applied to the reviewer. */
+  readonly intentFingerprint?: string;
   /** Null when the CLI refused to run the engine because the fetched diff was knowingly stale. */
   readonly review: ReviewResult | null;
   readonly durationMs: number;
@@ -109,6 +112,8 @@ interface ReviewObservation {
   /** 상한을 넘겨 생략된 항목 수(0 이 아니면 로그가 전부가 아님을 알린다). */
   readonly omitted: number;
   readonly intentChars: number;
+  /** Content-free deterministic fingerprint of the intent actually applied to the reviewer. */
+  readonly intentFingerprint?: string;
   readonly durationMs: number;
   readonly diffTruncated?: boolean;
   readonly diffShownChars?: number;
@@ -161,6 +166,10 @@ function clip(items: readonly string[]): string[] {
  * 생략분은 `omitted` 로 **개수를 남긴다** — "로그에 8건뿐"을 "8건이 전부"로 오독하지 않게(정직 표기).
  * intent 는 **길이만** 남긴다(원문은 호출자 셸 히스토리·PR 본문에 있고, 로그 비대를 막는다).
  */
+export function reviewIntentFingerprint(intent: string): string {
+  return `sha256:${createHash('sha256').update(intent, 'utf8').digest('hex')}`;
+}
+
 export function buildReviewObservation(input: ReviewObservationInput): ReviewObservation {
   const { review } = input;
   const mustFix = review?.mustFix ?? [];
@@ -205,6 +214,7 @@ export function buildReviewObservation(input: ReviewObservationInput): ReviewObs
     shouldFixItems: clip(shouldFix),
     omitted: mustFix.length + shouldFix.length - shown,
     intentChars: input.intent.length,
+    ...(input.intentFingerprint ? { intentFingerprint: input.intentFingerprint } : {}),
     durationMs: input.durationMs,
     ...(input.diffTruncated !== undefined ? { diffTruncated: input.diffTruncated } : {}),
     ...(input.diffShownChars !== undefined ? { diffShownChars: input.diffShownChars } : {}),