elanous 0.2.31 → 0.2.34

package/src/acp/tool-trace.ts

@@ -1,4 +1,4 @@
-import { appendMessage } from '../session/index.js';
+import { appendMessage, onSessionCreated } from '../session/index.js';
 // ⛔ 메시지 «모양»은 `session/chat.ts` 가 갖는다 — 여기서 베끼지 않는다.
 //   같은 계약을 두 벌로 두면 한쪽만 자라고, 그때 「어느 표면의 기록인가」가 갈린다.
 import { buildToolTraceMessage } from '../session/chat.js';
@@ -24,9 +24,13 @@ import { debug } from '../debug/log.js';
  *  Goodhart 시험이었다. ⇒ 주입 가능한 함수로 떼어 **실행으로** 문다. */
 /** ⛔ 이 저장소 «밖»으로 열지 않는다 — 소비처가 이 파일과 그 시험뿐이다(리뷰 must-fix:
  *  쓰이지 않는 공개 표면). 시험은 리터럴로 넘기므로 이름을 export 할 필요가 없다. */
+type TraceMessage = ReturnType<typeof buildToolTraceMessage>;
+type AppendFn = (sessionId: string, msg: TraceMessage) => unknown;
+type FailureObserver = (info: { sessionId: string; tool: string; id: string; reason: string }) => void;
+
 interface AcpToolTraceDeps {
   /** 시험 주입점. 기본은 실제 세션 저장소. */
-  readonly append?: (sessionId: string, msg: ReturnType<typeof buildToolTraceMessage>) => unknown;
+  readonly append?: AppendFn;
   /** ⛔⭐ 메시지 «모양»을 만드는 자리 — 기본은 `session/chat.ts` 의 공유 빌더.
    *
    *  📏 무인 리뷰 must-fix(PR #11120): 산출 필드(`role`/`toolName`/…)만 검사하면
@@ -35,7 +39,166 @@ interface AcpToolTraceDeps {
    *  ⇒ 주입점으로 열어 **「공유 빌더를 쓴다」를 시험이 «실행으로» 확인**할 수 있게 한다. */
   readonly buildMessage?: typeof buildToolTraceMessage;
   /** 실패를 «이름으로» 남기는 자리. 기본은 관측 로그. */
-  readonly observeFailure?: (info: { sessionId: string; tool: string; id: string; reason: string }) => void;
+  readonly observeFailure?: FailureObserver;
+  /** 지연·회수·상한을 남기는 자리(`trace-persist-deferred|flushed|dropped`). 기본은 관측 로그. */
+  readonly observe?: (event: TraceDeferEvent, data: Record<string, unknown>) => void;
+  /** 「세션이 원장에 생겼다」를 듣는 자리. 기본은 `session/index.ts` 의 `onSessionCreated`. */
+  readonly subscribeSessionCreated?: (listener: (meta: { readonly id: string }) => void) => () => void;
+}
+
+type TraceDeferEvent = 'trace-persist-deferred' | 'trace-persist-flushed' | 'trace-persist-dropped';
+
+/** ⛔⭐⭐ **「세션이 아직 원장에 없다」는 실패가 아니라 «순서»다 — 지연 기록한다.**
+ *
+ *  📏 2026-10-16 실측(TUI 결함 #30·#64 · `eln logs --category acp.tool` 12h):
+ *    `trace-persist-failed «session not found: elanous-session-ndusg6»` 7건이 **13:12:03~15Z 한 턴**에 몰렸고,
+ *    그 세션 파일의 첫 줄은 **13:12:48Z**(턴 «끝»)였다.
+ *  🔑 원인(호출부): ACP 서버는 세션 id 를 «메모리에만» 민팅하고(`acpServerRegisterSession` · `server.ts`),
+ *    원장 채택은 **턴이 «끝난 뒤»** 에 일어난다 — `persistCompletedTuiAcpTurn`(서버 · origin 메타가 있을 때) 또는
+ *    대시보드의 `adoptChatSession`(SESSION-RESUME-ISOLATED · 턴 완료 뒤). 그런데 툴 흔적은 «턴 도중»
+ *    `pushToolResult` → 이 함수에서 쓴다. ⇒ ***새 세션의 «첫 턴» 도구 흔적은 전부 잃었다***
+ *    (`/session new`·ACP 갱신마다 새 id 라 첫 턴이 반복된다).
+ *  ⇒ 그 오류면 메시지를 세션별로 붙잡아 두고, 세션이 원장에 생기는 순간(`onSessionCreated`) 또는
+ *    같은 세션의 다음 호출 때 «원래 시각(ts) 그대로» 붙인다. 경고는 세션당 «한 번»(지연) ⊕ 회수 때 «수»로.
+ *  ⛔ 출처(`source`)를 짐작해 여기서 세션을 «만들지» 않는다 — 같은 ACP 경로를 PWA 도 타므로
+ *    TUI 로 낙인찍으면 남의 세션 속성을 틀리게 박는다. 만드는 일은 원래 주인(턴 완료 채택)에게 둔다. */
+/*  ⚠️ 상한은 «메모리 바닥»만 지킨다 — 영영 채택되지 않는 세션(턴 도중 종료)이 쌓이지 않게.
+ *    세션당 100 을 넘으면 그 뒤 흔적은 버리고, 세션 32 를 넘으면 가장 오래 기다린 세션을 통째로 버린다.
+ *    어느 쪽이든 `trace-persist-dropped` 를 «한 줄» 남길 뿐 버린 «수»를 세거나 간격을 두지 않는다
+ *    (버림 계수·보고 방식은 연결 골 `ASK-ACP-TRACE-EVICTION-ACCOUNTING` 이 정한다).
+ *    축출된 id 가 다시 오면 「한 번」 경고부터 다시 시작한다 — id 는 base36 무작위 6자라 드물다. */
+const MAX_PENDING_PER_SESSION = 100;
+const MAX_PENDING_SESSIONS = 32;
+const SESSION_NOT_FOUND = /^session not found: /;
+
+interface PendingSession {
+  readonly entries: Array<{
+    readonly append: AppendFn;
+    readonly msg: TraceMessage;
+    readonly tool: string;
+    readonly id: string;
+    readonly observeFailure: FailureObserver | undefined;
+  }>;
+  /** 세션당 상한에 한 번 닿았나 — `trace-persist-dropped` 를 세션당 한 줄만 남기려고. */
+  capped: boolean;
+  readonly observe: (event: TraceDeferEvent, data: Record<string, unknown>) => void;
+}
+
+const pendingBySession = new Map<string, PendingSession>();
+let unsubscribeCreated: (() => void) | null = null;
+
+const defaultObserve = (event: TraceDeferEvent, data: Record<string, unknown>): void => {
+  debug.log('acp.tool', event, data);
+};
+
+const safeObserve = (fn: () => void): void => {
+  // ⛔ 관측 자체가 던져도 턴을 깨지 않는다 — 그러면 fail-soft 가 무의미해진다.
+  try { fn(); } catch { /* 관측은 마지막 방어선이다 */ }
+};
+
+const errorReason = (err: unknown): string =>
+  err instanceof Error ? err.message.slice(0, 200) : String(err).slice(0, 200);
+
+function observeFailureOf(
+  sessionId: string,
+  call: { readonly tool: string; readonly id: string },
+  reason: string,
+  observeFailure: FailureObserver | undefined,
+): void {
+  const observe = observeFailure
+    ?? ((info) => { debug.log('acp.tool', 'trace-persist-failed', info); });
+  safeObserve(() => observe({ sessionId, tool: call.tool, id: call.id, reason }));
+}
+
+/** 붙잡아 둔 흔적을 원래 순서대로 붙인다. 세션이 여전히 없으면 그대로 둔다(`'missing'`). */
+function flushPending(sessionId: string): 'missing' | 'flushed' | 'none' {
+  const p = pendingBySession.get(sessionId);
+  if (!p) return 'none';
+  let flushed = 0;
+  let failed = 0;
+  while (p.entries.length > 0) {
+    const entry = p.entries[0]!;
+    try {
+      entry.append(sessionId, entry.msg);
+      flushed += 1;
+    } catch (err) {
+      const reason = errorReason(err);
+      // ⛔ 회수 «도중» 세션이 사라져도(이미 몇 행을 붙인 뒤라도) 그 행과 나머지는 «지연» 그대로 둔다 — 실패가 아니다.
+      if (SESSION_NOT_FOUND.test(reason)) {
+        // ⭐ 그때까지 붙인 행 수는 «지금» 남긴다 — 다음 회수 보고는 그 뒤의 행만 센다.
+        if (flushed > 0 || failed > 0) {
+          safeObserve(() => p.observe('trace-persist-flushed', { sessionId, flushed, failed, partial: true }));
+        }
+        return 'missing';
+      }
+      failed += 1;
+      // ⛔ 회수 중 실패도 «같은» `trace-persist-failed` 로 — `flushed.failed` 합계에만 묻으면 실패가 안 보인다.
+      observeFailureOf(sessionId, { tool: entry.tool, id: entry.id }, reason, entry.observeFailure);
+    }
+    p.entries.shift();
+  }
+  pendingBySession.delete(sessionId);
+  safeObserve(() => p.observe('trace-persist-flushed', { sessionId, flushed, failed }));
+  if (pendingBySession.size === 0 && unsubscribeCreated) {
+    const off = unsubscribeCreated;
+    unsubscribeCreated = null;
+    try { off(); } catch { /* 구독 해제 실패는 무해 — 다음 지연이 다시 건다 */ }
+  }
+  return 'flushed';
+}
+
+function deferTrace(
+  sessionId: string,
+  call: { readonly id: string; readonly name: string },
+  append: AppendFn,
+  msg: TraceMessage,
+  reason: string,
+  deps: AcpToolTraceDeps,
+): void {
+  let p = pendingBySession.get(sessionId);
+  if (!p) {
+    if (pendingBySession.size >= MAX_PENDING_SESSIONS) {
+      // 가장 오래 기다린 세션부터 버린다 — 원장에 영영 안 생긴 세션(턴 도중 종료)이 쌓이지 않게.
+      const [oldestId, oldest] = pendingBySession.entries().next().value as [string, PendingSession];
+      pendingBySession.delete(oldestId);
+      safeObserve(() => oldest.observe('trace-persist-dropped', { sessionId: oldestId, reason: 'pending-session-cap' }));
+    }
+    p = { entries: [], capped: false, observe: deps.observe ?? defaultObserve };
+    pendingBySession.set(sessionId, p);
+    // ⭐ 경고는 세션당 «한 번» — 호출마다 같은 줄을 찍던 것이 결함 #64 의 다른 반쪽이다.
+    safeObserve(() => p!.observe('trace-persist-deferred', { sessionId, tool: call.name, id: call.id, reason }));
+  }
+  if (p.entries.length < MAX_PENDING_PER_SESSION) {
+    p.entries.push({ append, msg, tool: call.name, id: call.id, observeFailure: deps.observeFailure });
+  } else if (!p.capped) {
+    p.capped = true;
+    safeObserve(() => p!.observe('trace-persist-dropped', {
+      sessionId, tool: call.name, id: call.id, reason: 'pending-per-session-cap',
+    }));
+  }
+  if (!unsubscribeCreated) {
+    const subscribe = deps.subscribeSessionCreated ?? onSessionCreated;
+    try {
+      unsubscribeCreated = subscribe((meta) => {
+        if (!pendingBySession.has(meta.id)) return;
+        // ⭐ 채택 «직후» 같은 동기 구간에서 user/assistant 가 이어 붙는다(`persistCompletedTuiAcpTurn`).
+        //   마이크로태스크로 미뤄 그 뒤에 붙인다 — 그래야 「마지막 user 뒤의 tool 행」(다음 턴 관찰)이 산다.
+        queueMicrotask(() => { try { flushPending(meta.id); } catch { /* fail-soft */ } });
+      });
+    } catch { unsubscribeCreated = null; }
+  }
+}
+
+/** 시험 전용 — 모듈 상태(지연 큐·구독)를 비운다. */
+export function _resetAcpToolTraceStateForTest(): void {
+  pendingBySession.clear();
+  if (unsubscribeCreated) { try { unsubscribeCreated(); } catch { /* 무해 */ } }
+  unsubscribeCreated = null;
+}
+
+/** 시험·관측용 — 세션별로 붙잡아 둔 흔적 수. */
+export function pendingAcpToolTraceCount(sessionId: string): number {
+  return pendingBySession.get(sessionId)?.entries.length ?? 0;
 }
 
 /** 한 번의 툴 호출을 감사 기록으로 남긴다.
@@ -44,8 +207,9 @@ interface AcpToolTraceDeps {
  *    (`session/chat.ts` 가 세운 규율).
  *  ⚠️ **그러나 «조용히 삼키지 않는다»** — 실패하면 이름을 대고 관측에 남긴다.
  *    ***조용한 실패야말로 16차가 내내 잡던 형태고, 이 PR 초판이 또 만들었다.***
+ *  ⭐ 「세션이 아직 원장에 없다」면 지연 기록한다(위 `MAX_PENDING_*` 주석) — 이때도 `false` 다.
  *
- *  @returns 저장을 시도해 «성공»했으면 `true`. ⛔ 「안 했다」와 「했는데 실패했다」는 다른 값이다. */
+ *  @returns 지금 저장에 «성공»했으면 `true`. ⛔ 「안 했다」와 「했는데 실패했다」·「미뤘다」는 다른 값이다. */
 export function persistAcpToolTrace(
   sessionId: string,
   call: { readonly id: string; readonly name: string; readonly result?: unknown },
@@ -56,14 +220,25 @@ export function persistAcpToolTrace(
   // ⛔ 모양은 «공유 빌더»가 만든다 — 여기서 손으로 조립하지 않는다(계약을 두 벌로 두지 않는다).
   const build = deps.buildMessage ?? buildToolTraceMessage;
   try {
-    append(sessionId, build(call.name, args, call.result));
-    return true;
+    const msg = build(call.name, args, call.result);
+    // 앞서 미뤄 둔 흔적이 있으면 먼저 붙인다(순서 보존). 여전히 세션이 없으면 이것도 뒤에 줄 세운다.
+    if (pendingBySession.has(sessionId) && flushPending(sessionId) === 'missing') {
+      deferTrace(sessionId, call, append, msg, 'session not found (pending)', deps);
+      return false;
+    }
+    try {
+      append(sessionId, msg);
+      return true;
+    } catch (err) {
+      const reason = errorReason(err);
+      if (SESSION_NOT_FOUND.test(reason)) {
+        deferTrace(sessionId, call, append, msg, reason, deps);
+        return false;
+      }
+      throw err;
+    }
   } catch (err) {
-    const reason = err instanceof Error ? err.message.slice(0, 200) : String(err).slice(0, 200);
-    const observe = deps.observeFailure
-      ?? ((info) => { debug.log('acp.tool', 'trace-persist-failed', info); });
-    // ⛔ 관측 자체가 던져도 턴을 깨지 않는다 — 그러면 fail-soft 가 무의미해진다.
-    try { observe({ sessionId, tool: call.name, id: call.id, reason }); } catch { /* 관측은 마지막 방어선이다 */ }
+    observeFailureOf(sessionId, { tool: call.name, id: call.id }, errorReason(err), deps.observeFailure);
     return false;
   }
 }

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

@@ -0,0 +1,156 @@
+// ── TUI 자기인지 ambient 캐시 — 턴 시작이 이벤트 루프를 막지 않게 (TUI-TYPING-LAG · 2026-10-14) ──
+//
+// 실측(격리 TUI · bun --cpu-prof): 턴마다 `elanousSelfAmbientBaseParts()`(ops 스캔·crontab·`ps`)가
+// 메인 스레드에서 동기로 돌았고, 한 턴에 «두 번»(대시보드 preamble ⊕ ACP buildTurnMessages) 돌아
+// 그 동안 키 입력이 0.4~9s 멈췄다. 이 캐시는 «요청과 무관한» 부분만 담는다:
+//   · 신선(< FRESH_MS) → 그대로 쓴다.
+//   · 오래됨(< STALE_MAX_MS) → 그대로 쓰고 워커에서 다시 잰다(다음 턴용).
+//   · 없음/너무 오래됨 → 종전대로 동기 계산(첫 턴 내용 보존). TUI 는 부팅 때 데우고 5s 주기
+//     틱(`refreshSelfAmbientCache({}, { ifOlderThanMs })` · src/dashboard/index.ts)으로 계속 데워
+//     두므로, 워커가 실패(백오프)하지 않는 한 오래 쉰 뒤 첫 턴도 이 길로 안 온다.
+// 관측 = `self-ambient.cache` (hit · stale-hit · sync · worker-refreshed · worker-failed).
+
+import { isMainThread, parentPort, workerData, Worker } from 'node:worker_threads';
+import { debug } from '../debug/log.js';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { setElanousConfigDir } from '../elanous-config-dir.js';
+import { elanousSelfAmbientBaseParts } from './self-ambient.js';
+
+export const SELF_AMBIENT_FRESH_MS = 30_000;
+export const SELF_AMBIENT_STALE_MAX_MS = 10 * 60_000;
+const WORKER_TIMEOUT_MS = 60_000;
+
+interface CacheEntry { at: number; version: number; parts: string[] }
+
+export interface SelfAmbientCacheDeps {
+  now?: () => number;
+  computeSync?: () => string[];
+  computeInWorker?: (stateRoot: string | undefined, selectedRoot: string) => Promise<string[]>;
+  universeKey?: () => { stateRoot: string | undefined; selectedRoot: string };
+  log?: (category: string, event: string, data: Record<string, unknown>) => void;
+}
+
+const entries = new Map<string, CacheEntry>();
+/** Monotonic store sequence — orders async worker stores against synchronous ones.
+ *  A millisecond `at` clock ties within the same millisecond and let a worker's older
+ *  result overwrite a newer synchronous computation; the version never ties. */
+let storeSeq = 0;
+const inFlight = new Map<string, Promise<void>>();
+/** A failed worker is not retried (by ticks or stale turn reads) for this long; the turn path keeps
+ *  serving the stale entry, or falls back to sync once it is too old. */
+const WORKER_FAILURE_BACKOFF_MS = 60_000;
+const lastFailureAt = new Map<string, number>();
+
+function resolveDeps(deps: SelfAmbientCacheDeps): Required<SelfAmbientCacheDeps> {
+  return {
+    now: deps.now ?? Date.now,
+    computeSync: deps.computeSync ?? elanousSelfAmbientBaseParts,
+    computeInWorker: deps.computeInWorker ?? computeBasePartsInWorker,
+    universeKey: deps.universeKey ?? (() => ({ stateRoot: process.env.ELANOUS_STATE_DIR, selectedRoot: effectiveInstanceRoot() })),
+    log: deps.log ?? ((category, event, data) => debug.log(category, event, data)),
+  };
+}
+
+/** Start (or join) a background refresh. Resolves when the cache has been updated or the refresh failed.
+ *  `ifOlderThanMs` turns it into a keep-warm tick: a younger entry is left alone. */
+export function refreshSelfAmbientCache(deps: SelfAmbientCacheDeps = {}, opts: { ifOlderThanMs?: number } = {}): Promise<void> {
+  const d = resolveDeps(deps);
+  const { stateRoot, selectedRoot } = d.universeKey();
+  const key = JSON.stringify([selectedRoot, stateRoot ?? null]);
+  const cached = entries.get(key);
+  if (cached && opts.ifOlderThanMs !== undefined && d.now() - cached.at < opts.ifOlderThanMs) return Promise.resolve();
+  if (d.now() - (lastFailureAt.get(key) ?? -Infinity) < WORKER_FAILURE_BACKOFF_MS) return Promise.resolve();
+  const running = inFlight.get(key);
+  if (running) return running;
+  const startedAt = d.now();
+  const startedVersion = storeSeq;
+  // A worker that fails to even start (sync throw) is the same fail-soft failure as one that rejects.
+  let started: Promise<string[]>;
+  try { started = d.computeInWorker(stateRoot, selectedRoot); }
+  catch (error) { started = Promise.reject(error); }
+  const refresh = started
+    .then((parts) => {
+      // A newer entry (e.g. a synchronous first-turn computation that overlapped this worker) is kept.
+      // Judged by the monotonic store version, not the millisecond clock: a store that landed in the
+      // same millisecond as this worker's start is still newer.
+      const current = entries.get(key);
+      if (current && current.version > startedVersion) return;
+      entries.set(key, { at: startedAt, version: ++storeSeq, parts });
+      d.log('self-ambient.cache', 'worker-refreshed', { ms: d.now() - startedAt, parts: parts.length });
+    }, (error: unknown) => {
+      lastFailureAt.set(key, d.now());
+      d.log('self-ambient.cache', 'worker-failed', { ms: d.now() - startedAt, reason: error instanceof Error ? error.message : String(error) });
+    })
+    .finally(() => { inFlight.delete(key); });
+  inFlight.set(key, refresh);
+  return refresh;
+}
+
+/** Request-independent ambient parts for the TUI turn preamble, served from the cache when possible. */
+export function cachedSelfAmbientBaseParts(deps: SelfAmbientCacheDeps = {}): string[] {
+  const d = resolveDeps(deps);
+  const { stateRoot, selectedRoot } = d.universeKey();
+  const key = JSON.stringify([selectedRoot, stateRoot ?? null]);
+  const at = d.now();
+  const cached = entries.get(key);
+  const ageMs = cached ? at - cached.at : null;
+  if (cached && ageMs! < SELF_AMBIENT_FRESH_MS) {
+    d.log('self-ambient.cache', 'hit', { ageMs });
+    return [...cached.parts];
+  }
+  if (cached && ageMs! < SELF_AMBIENT_STALE_MAX_MS) {
+    d.log('self-ambient.cache', 'stale-hit', { ageMs });
+    void refreshSelfAmbientCache(deps);
+    return [...cached.parts];
+  }
+  const parts = d.computeSync();
+  entries.set(key, { at, version: ++storeSeq, parts });
+  d.log('self-ambient.cache', 'sync', { ms: d.now() - at, ageMs, parts: parts.length });
+  return [...parts];
+}
+
+export function _resetSelfAmbientCacheForTest(): void {
+  storeSeq = 0;
+  entries.clear();
+  inFlight.clear();
+  lastFailureAt.clear();
+}
+
+function computeBasePartsInWorker(stateRoot: string | undefined, selectedRoot: string): Promise<string[]> {
+  const worker = new Worker(new URL(import.meta.url), { workerData: { kind: 'self-ambient' } });
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const timeout = setTimeout(() => finish(new Error(`self-ambient worker timed out after ${WORKER_TIMEOUT_MS}ms`)), WORKER_TIMEOUT_MS);
+    // A background warm-up must never keep a finished CLI or test process alive.
+    timeout.unref?.();
+    worker.unref?.();
+    const finish = (error?: Error, parts?: string[]): void => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      void worker.terminate();
+      if (error) reject(error);
+      else resolve(parts!);
+    };
+    worker.on('message', (message: { parts?: string[]; error?: string }) => {
+      if (message.error) finish(new Error(message.error));
+      else if (message.parts) finish(undefined, message.parts);
+    });
+    worker.on('error', error => finish(error instanceof Error ? error : new Error(String(error))));
+    worker.on('exit', code => { if (!settled) finish(new Error(`self-ambient worker exited before answering: ${code}`)); });
+    // Pin the caller's universe: a programmatic config override is not inherited by workers.
+    worker.postMessage({ stateRoot, selectedRoot });
+  });
+}
+
+const selfAmbientWorkerPort = parentPort;
+if (!isMainThread && selfAmbientWorkerPort && workerData?.kind === 'self-ambient') {
+  selfAmbientWorkerPort.on('message', ({ stateRoot, selectedRoot }: { stateRoot?: string; selectedRoot: string }) => {
+    try {
+      if (stateRoot === undefined) delete process.env.ELANOUS_STATE_DIR;
+      else process.env.ELANOUS_STATE_DIR = stateRoot;
+      setElanousConfigDir(selectedRoot);
+      selfAmbientWorkerPort.postMessage({ parts: elanousSelfAmbientBaseParts() });
+    } catch (error) { selfAmbientWorkerPort.postMessage({ error: error instanceof Error ? error.message : String(error) }); }
+  });
+}

package/src/agent/self-ambient.ts

@@ -184,11 +184,18 @@ export function investigationRecallAmbient(taskText: string): string {
 /** 자기인지 ambient — 최근 자기 구현/변경 + 최근 자율행동 + 자율 시스템 이상 + 미션 사건 사실
  *  (+ taskText 주면 조사문맥 관련 회상·축B). 매 턴 fresh · 각각 fail-soft(없음이면 빈 문자열). */
 export function elanousSelfAmbientParts(taskText?: string): string[] {
+  const parts = elanousSelfAmbientBaseParts();
+  if (taskText) { try { parts.push(investigationRecallAmbient(taskText)); } catch { /* fail-soft */ } }
+  return parts.filter(Boolean);
+}
+
+/** The request-independent ambient parts (store scans · `ps` · crontab). Split out so the
+ *  TUI can compute them off its event loop (`self-ambient-cache.ts`). */
+export function elanousSelfAmbientBaseParts(): string[] {
   const parts: string[] = [];
   try { parts.push(recentSelfChangesContext()); } catch { /* fail-soft */ }
   try { parts.push(recentAutonomyContext()); } catch { /* fail-soft */ }
   try { parts.push(opsHealthContext()); } catch { /* fail-soft */ }
   try { parts.push(missionIncidentAmbient()); } catch { /* fail-soft */ }
-  if (taskText) { try { parts.push(investigationRecallAmbient(taskText)); } catch { /* fail-soft */ } }
   return parts.filter(Boolean);
 }

package/src/agent/task-notification.ts

@@ -113,6 +113,11 @@ export class TaskNotificationQueue {
     return this.queue.length;
   }
 
+  /** Is this task's notification still queued (not yet drained into a turn)? */
+  has(taskId: string): boolean {
+    return this.queue.some((n) => n.taskId === taskId);
+  }
+
   /** Forget everything — tests use this for isolation. Listeners are
    *  preserved: clear() empties queue + seen, not the wake wiring. */
   clear(): void {

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

@@ -55,6 +55,9 @@ export interface AcpReviewerOpts {
  */
 export const DEFAULT_REVIEW_BACKEND = 'codex';
 
+/** Stable failureReason prefix carried through reviewPullRequest's fail-soft result. */
+export const GROK_ACP_REVIEW_TIMEOUT = 'ACP_REVIEW_TIMEOUT:grok:';
+
 // ACP ToolKind(zToolKind) 중 read-only(부작용 없음) — 리뷰어에게 허가할 계열.
 const READONLY_TOOL_KINDS = new Set(['read', 'search', 'fetch', 'think', 'switch_mode']);
 // 명시적 변경/실행 계열 — 리뷰(read-only)에선 절대 불허.
@@ -84,7 +87,7 @@ const TOOL_REVIEW_PREAMBLE = [
  *  - model 지정 시 selectSessionModel 로 tier 고정(picked 관측).
  *  - ⭐auto-allow permission approver — 리뷰어의 read-only 툴콜을 무조건 허가(대표 지시)해 Read 반복거부
  *    정체를 원천제거. 각 허가는 debug.log 로 각인(제1원칙 관측 관문 — 자동승인은 관측되는 결정).
- *  - timeout: 초과 시 cancel→throw. 오류/타임아웃은 각인 후 rethrow → reviewPullRequest 가 fail-soft
+ *  - timeout: 초과 시 실패를 확정하고 cancel·stop. 오류/타임아웃은 각인 후 rethrow → reviewPullRequest 가 fail-soft
  *    (reviewed=false)로 흡수, CLI 가 reviewed=false 를 "리뷰 실패"로 표면화(부분결과 오판 pass 방지). */
 export function makeAcpReviewLLM(opts: AcpReviewerOpts): (prompt: string, images?: readonly ReviewImage[]) => Promise<string> {
   return async (prompt: string, images?: readonly ReviewImage[]): Promise<string> => {
@@ -117,8 +120,13 @@ export function makeAcpReviewLLM(opts: AcpReviewerOpts): (prompt: string, images
       model: opts.model ?? '(default)',
       promptChars: prompt.length,
     });
+    const startedAt = Date.now();
+    let phase = 'spawn';
+    let phaseStartedAt = startedAt;
+    const enterPhase = (next: string): void => { phase = next; phaseStartedAt = Date.now(); };
     let allowed = 0;
     let denied = 0;
+    const observedToolCalls = new Set<string>();
     let capabilitiesObserved = false;
     const agentOpts: Omit<AcpAgentOpts, 'backendId'> = {
       cwd: opts.cwd,
@@ -149,10 +157,12 @@ export function makeAcpReviewLLM(opts: AcpReviewerOpts): (prompt: string, images
     };
     // A review owns its manager and subprocess: the global manager caches
     // chat agents, whose callbacks and lifecycle must not be mutated here.
-    const reviewManager = injected || opts.backendSpec ? undefined : new AcpAgentManager();
+    // 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 reviewManager = directAgent ? undefined : new AcpAgentManager();
     let agent: AcpAgent | undefined;
     let text = '';
-    let timedOut = false;
     let timer: ReturnType<typeof setTimeout> | undefined;
     const handshakeTimeoutMs = opts.handshakeTimeoutMs ?? Math.min(timeoutMs, 60_000);
     const handshakeDeadline = Date.now() + handshakeTimeoutMs;
@@ -165,9 +175,16 @@ export function makeAcpReviewLLM(opts: AcpReviewerOpts): (prompt: string, images
     })]).finally(() => { if (handshakeTimer) clearTimeout(handshakeTimer); });
     try {
       if (opts.createAgent) agent = opts.createAgent({ backendId: requestedBackend, ...agentOpts });
-      else if (opts.backendSpec) agent = new AcpAgent({ backendId: requestedBackend, ...agentOpts });
-      else agent = await withinHandshake(reviewManager!.getAgent(requestedBackend, agentOpts));
-      if (injected || opts.backendSpec) await withinHandshake(agent.start());
+      else if (directAgent) agent = new AcpAgent({ backendId: requestedBackend, ...agentOpts });
+      else {
+        // getAgent owns both spawn and initialize; neither step is independently observable here.
+        enterPhase('spawn-initialize');
+        agent = await withinHandshake(reviewManager!.getAgent(requestedBackend, agentOpts));
+      }
+      if (directAgent) {
+        enterPhase(injected ? 'initialize' : 'spawn-initialize');
+        await withinHandshake(agent.start());
+      }
       if (!capabilitiesObserved) {
         try {
           debug.log('acp-review', 'capabilities', {
@@ -181,12 +198,14 @@ export function makeAcpReviewLLM(opts: AcpReviewerOpts): (prompt: string, images
           // Observability must not interrupt a review.
         }
       }
+      enterPhase('session-new');
       const sid = await withinHandshake(agent.newSession());
       if (opts.model) {
+        enterPhase('model-select');
         const picked = await withinHandshake(agent.selectSessionModel(sid, opts.model));
         debug.log('acp-review', 'model', { requested: opts.model, picked: picked?.name ?? null, backend });
       }
-      timer = setTimeout(() => { timedOut = true; agent!.cancel(sid).catch(() => { /* noop */ }); }, timeoutMs);
+      enterPhase('prompt');
       // ⭐⭐ `P4b` 멀티미디어 — 이미지를 «별도 ContentBlock» 으로 싣는다.
       //   ⛔ 광고를 «먼저 본다** — 백엔드가 image 를 안 받는다고 말하면 안 보낸다. 보내 봐야
       //      거절이 이 층보다 훨씬 읽기 어려운 자리에서 나고, 그 거절은 리뷰 실패로 보인다.
@@ -211,23 +230,44 @@ export function makeAcpReviewLLM(opts: AcpReviewerOpts): (prompt: string, images
           // Observation must not prevent the review from running.
         }
       }
-      await agent.prompt(sid, [{ type: 'text', text: TOOL_REVIEW_PREAMBLE + prompt }, ...imageBlocks], (u) => {
+      const promptAttempt = agent.prompt(sid, [{ type: 'text', text: TOOL_REVIEW_PREAMBLE + prompt }, ...imageBlocks], (u) => {
+        if (u.sessionUpdate === 'tool_call' || u.sessionUpdate === 'tool_call_update') {
+          observedToolCalls.add(u.toolCallId);
+        }
         if (u.sessionUpdate === 'agent_message_chunk') {
           const c = u.content;
           if (c.type === 'text' && c.text) text += c.text;
         }
       });
-      if (timedOut) throw new Error(`ACP 리뷰 타임아웃(${timeoutMs}ms·툴콜 ${allowed})`);
+      // Do not rely on cancel causing prompt() to settle: a stalled ACP child may never answer it.
+      await Promise.race([promptAttempt, new Promise<never>((_, reject) => {
+        timer = setTimeout(() => {
+          // Commit the timeout before cancel can settle prompt with a partial response.
+          reject(new Error(backend === 'grok'
+            ? `${GROK_ACP_REVIEW_TIMEOUT} ${timeoutMs}ms·툴콜 ${observedToolCalls.size}`
+            : `ACP 리뷰 타임아웃(${timeoutMs}ms·툴콜 ${allowed})`));
+          void agent!.cancel(sid).catch(() => { /* noop */ });
+        }, timeoutMs);
+      })]);
     } catch (e) {
-      debug.log('acp-review', 'error', { backend, model: opts.model ?? '(default)', message: (e as Error).message }, { level: 'error' });
-      throw e;
+      const message = (e as Error).message;
+      const handshakeTimeout = message.startsWith('ACP handshake timeout (');
+      const failure = backend === 'grok' && handshakeTimeout
+        ? new Error(`${GROK_ACP_REVIEW_TIMEOUT} ${message}`) : e;
+      const timeout = message.startsWith(GROK_ACP_REVIEW_TIMEOUT) || message.startsWith('ACP 리뷰 타임아웃(') || handshakeTimeout;
+      debug.log('acp-review', 'error', {
+        backend, provider: backend, model: opts.model ?? '(default)', message: (failure as Error).message,
+        phase, elapsedMs: Date.now() - startedAt, phaseElapsedMs: Date.now() - phaseStartedAt,
+        toolCalls: observedToolCalls.size, allowed, denied, ...(timeout ? { classification: phase === 'prompt' && observedToolCalls.size === 0 ? 'pre-tool-timeout' : 'acp-timeout' } : {}),
+      }, { level: 'error' });
+      throw failure;
     } finally {
       if (timer) clearTimeout(timer);
       // Both paths are review-owned: injected agents retain their direct
       // cleanup seam, while the per-review manager releases its agents and
       // process hooks. An injected agent is external to the manager.
       try {
-        if (injected || opts.backendSpec) await agent?.stop();
+        if (directAgent) await agent?.stop();
         else await reviewManager!.dispose();
       } catch (e) {
         debug.log('acp-review', 'stop-fail', { backend, message: (e as Error).message }, { level: 'error' });

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

@@ -656,7 +656,7 @@ const BARE_SENTINEL = new RegExp(String.raw`^${NONE_WORD}\s*[.。]?$`, 'i');
 // 괄호 전체만 검사한다. 중간에 "no blockers" 가 있어도 뒤에 지적이 이어지면 버리지 않는다.
 const BRACKETED_PLACEHOLDER = /^[（(]\s*([\s\S]*?)\s*[）)]$/;
 const PLACEHOLDER_ONLY = /^(?:없음|해당\s*없음|none|n\/a|no\s+blockers?)$/i;
-const PLACEHOLDER_END = /(?:블로커|차단)\s*없음$|no\s+blockers?$/i;
+const PLACEHOLDER_END = /(?:블로커|차단)(?:\s*(?:수준의?\s*)?(?:결함|문제|이슈|지적))?\s*없음$|no\s+blockers?$/i;
 function isBracketedPlaceholder(text: string): boolean {
   const bracketed = BRACKETED_PLACEHOLDER.exec(text);
   if (!bracketed) return false;
@@ -670,6 +670,8 @@ const BRACKETED_SENTINEL = new RegExp(String.raw`^[([（【]\s*${NONE_WORD}(?:\s
 // ⭐ 설명 «전체»가 「지적 없음」 한 문장일 때만 — 일부만 맞아도 접으면 `(none: no blockers are checked because …)` 같은 지적이 사라진다.
 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`^nothing\s+(?:blocking|to\s+fix)\.?$`,
   // REVIEW-MUSTFIX-NONE-SENTINEL — `(없음 — 수용기준 충족)` · `(none — acceptance criteria met)` (GLM 실측 6건). «미충족» 은 ^ 앵커로 안 맞는다.

package/src/agent-substrate/review-finding-key.ts

@@ -1,8 +1,10 @@
 import { createHash } from 'node:crypto';
+import { spawnSync } from 'node:child_process';
 
 export const REVIEW_FINDING_KEY_VERSION = 'reviewFindingKey-v1';
 export const MAX_CITED_REVIEW_SYMBOL_CHARS = 256;
 const CITED_REVIEW_SYMBOL_HASH_CHARS = 16;
+const CITED_PATH_EXTENSION = /\.(?:ts|tsx|js|jsx|mjs|cjs|json|md|yaml|yml|sh|py|toml|css|go|sql|rs|rb|java|kt|swift|c|h|cpp|hpp|graphql|proto)$/;
 
 export interface CitedReviewSymbol {
   hash: string;
@@ -18,6 +20,57 @@ export interface ReviewFindingKeyOverlap {
   overlapRatio: number | undefined;
 }
 
+export type CitedReviewPathStatus = 'present' | 'missing' | 'unreadable';
+
+export interface ReviewFindingPathHeadCheck {
+  head: string;
+  status: 'verified' | 'path-missing' | 'unreadable' | 'no-cited-path';
+  paths: Array<{ path: string; status: CitedReviewPathStatus }>;
+}
+
+/** Only file-shaped citations are checked; symbols such as `terminal.id` are not paths. */
+export function citedReviewPaths(finding: string): string[] {
+  return [...new Set(fullCitedReviewSymbols(finding)
+    .map((symbol) => symbol.replace(/^\.\//, '').replace(/:\d+(?::\d+)?$/, ''))
+    .filter((symbol) => !symbol.startsWith('/')
+      && !symbol.includes('\\')
+      && !symbol.includes('://')
+      && /^[A-Za-z0-9_.@+/-]+$/.test(symbol)
+      && !symbol.split('/').some((part) => part === '..' || part === '')
+      && (symbol.includes('/') || CITED_PATH_EXTENSION.test(symbol))))];
+}
+
+/** Check cited paths against the supplied exact commit, never the worktree's current HEAD. */
+export function checkCitedReviewPathsAtHead(finding: string, repo: string, head: string): ReviewFindingPathHeadCheck {
+  const paths = citedReviewPaths(finding);
+  if (paths.length === 0) return { head, status: 'no-cited-path', paths: [] };
+  if (!/^[0-9a-f]{40}$/i.test(head)) {
+    return { head, status: 'unreadable', paths: paths.map((path) => ({ path, status: 'unreadable' })) };
+  }
+  const commitType = spawnSync('git', ['-C', repo, 'cat-file', '-t', head], { encoding: 'utf8' });
+  if (commitType.error || commitType.status !== 0 || commitType.stdout?.trim() !== 'commit') {
+    return { head, status: 'unreadable', paths: paths.map((path) => ({ path, status: 'unreadable' })) };
+  }
+  const checked = paths.map((path): { path: string; status: CitedReviewPathStatus } => {
+    const result = spawnSync('git', ['--literal-pathspecs', '-C', repo, 'ls-tree', '-r', '-z', '--full-tree', head, '--', path], {
+      encoding: 'utf8', maxBuffer: 1024 * 1024,
+    });
+    if (result.error || result.status !== 0) return { path, status: 'unreadable' };
+    const output = typeof result.stdout === 'string' ? result.stdout : '';
+    const present = output.split('\0').some((entry) => {
+      const separator = entry.indexOf('\t');
+      return separator >= 0 && entry.slice(separator + 1) === path;
+    });
+    return { path, status: present ? 'present' : 'missing' };
+  });
+  return {
+    head,
+    status: checked.some(({ status }) => status === 'unreadable') ? 'unreadable'
+      : checked.some(({ status }) => status === 'missing') ? 'path-missing' : 'verified',
+    paths: checked,
+  };
+}
+
 interface ReviewFindingKey {
   key: string;
   source: 'symbol' | 'prose';