elanous 0.2.29 → 0.2.32

package/scripts/tsc-incremental-cache.ts

@@ -0,0 +1,86 @@
+/** Opt-in compiler graph cache for an exclusive, stable remote gate checkout. */
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { hostname } from 'node:os';
+import { isAbsolute, join } from 'node:path';
+import { normalizedDiagnosticSet } from './tsc-incremental-diagnostics.js';
+
+export interface CachedTscRun { out: string; ran: boolean; why?: string; exitCode?: number }
+type Reference = { schema: 1; key: string; out: string; exitCode: number; decision: boolean; head?: string };
+export interface IncrementalCacheInput<T extends CachedTscRun> {
+  cwd: string;
+  base: string;
+  head?: string;
+  changed: ReadonlySet<string>;
+  config: string;
+  command: string;
+  cacheDir: string;
+  run: (command: string) => T;
+  decision: (result: T) => boolean;
+  log: (message: string) => void;
+}
+
+function compilerOutcome(result: CachedTscRun): 'clean' | 'diagnostics' | 'unmeasured' {
+  if (!result.ran) return 'unmeasured';
+  if (result.exitCode === 0) return 'clean';
+  return result.exitCode === 1 || result.exitCode === 2 ? 'diagnostics' : 'unmeasured';
+}
+
+function equivalent<T extends CachedTscRun>(current: T, baseline: T, decide: (result: T) => boolean): boolean {
+  const a = normalizedDiagnosticSet(current.out);
+  const b = normalizedDiagnosticSet(baseline.out);
+  return a !== null && a === b && compilerOutcome(current) !== 'unmeasured'
+    && compilerOutcome(current) === compilerOutcome(baseline) && decide(current) === decide(baseline);
+}
+
+export function incrementalCacheKey(input: Pick<IncrementalCacheInput<CachedTscRun>, 'cwd' | 'base' | 'changed' | 'config'>): string {
+  const files = [input.config, 'tsconfig.json', 'tsconfig.gate.json', 'tsconfig.pwa-env.json', 'apps/pwa/tsconfig.json', 'bun.lock', 'node_modules/typescript/package.json'];
+  const hash = createHash('sha256');
+  for (const field of [hostname(), input.cwd, input.base, ...[...input.changed].sort()]) hash.update(field + '\0');
+  for (const file of files) {
+    hash.update(file + '\0');
+    try { hash.update(readFileSync(join(input.cwd, file))); }
+    catch { hash.update('<missing>'); }
+    hash.update('\0');
+  }
+  return hash.digest('hex');
+}
+
+/** A cache hit is accepted only when the prior cold reference still has the same diagnostic set and gate decision. */
+export function runIncrementalCachedTsc<T extends CachedTscRun>(input: IncrementalCacheInput<T>): T {
+  if (!isAbsolute(input.cacheDir) || !/^[-\w./]+$/.test(input.cacheDir) || !/^[0-9a-f]{40}$/.test(input.base)) return input.run(input.command);
+  const key = incrementalCacheKey(input);
+  try { mkdirSync(input.cacheDir, { recursive: true, mode: 0o700 }); }
+  catch (cause) {
+    input.log(`[tsc-cache] unavailable key=${key.slice(0, 12)} reason=${cause instanceof Error ? cause.message : String(cause)}; cold`);
+    return input.run(input.command);
+  }
+  const buildInfo = join(input.cacheDir, `${key}.tsbuildinfo`);
+  const metaFile = join(input.cacheDir, `${key}.json`);
+  let reference: Reference | null = null;
+  try {
+    const parsed = JSON.parse(readFileSync(metaFile, 'utf8')) as Reference;
+    if (parsed.schema === 1 && parsed.key === key && typeof parsed.out === 'string'
+      && Number.isInteger(parsed.exitCode) && typeof parsed.decision === 'boolean' && existsSync(buildInfo)) reference = parsed;
+  } catch { /* missing or damaged cache is a cold miss */ }
+  const incremental = input.run(`${input.command} --incremental --tsBuildInfoFile '${buildInfo}'`);
+  const prior = reference ? { out: reference.out, ran: true, exitCode: reference.exitCode } as T : null;
+  if (prior && equivalent(incremental, prior, input.decision) && input.decision(prior) === reference!.decision) {
+    input.log(`[tsc-cache] hit key=${key.slice(0, 12)} warmRc=${incremental.exitCode} coldRc=${prior.exitCode} warmGate=${input.decision(incremental) ? 'PASS' : 'FAIL'} coldGate=${reference!.decision ? 'PASS' : 'FAIL'}`);
+    return incremental;
+  }
+  const cold = input.run(input.command);
+  const matched = equivalent(incremental, cold, input.decision);
+  input.log(`[tsc-cache] ${reference ? 'mismatch-cold' : 'miss-cold'} key=${key.slice(0, 12)} warmRc=${incremental.exitCode ?? 'unknown'} coldRc=${cold.exitCode ?? 'unknown'} warmGate=${incremental.ran ? input.decision(incremental) ? 'PASS' : 'FAIL' : 'unmeasured'} coldGate=${cold.ran ? input.decision(cold) ? 'PASS' : 'FAIL' : 'unmeasured'} normalized=${matched ? 'same' : 'different'}`);
+  if (matched && cold.exitCode !== undefined) {
+    const next: Reference = { schema: 1, key, out: cold.out, exitCode: cold.exitCode, decision: input.decision(cold), head: input.head };
+    const temp = `${metaFile}.${process.pid}.tmp`;
+    try { writeFileSync(temp, JSON.stringify(next), { mode: 0o600 }); renameSync(temp, metaFile); }
+    catch {
+      for (const path of [temp, metaFile, buildInfo]) { try { rmSync(path, { force: true }); } catch { /* next run must cold-check damaged cache */ } }
+    }
+  } else {
+    for (const path of [metaFile, buildInfo]) { try { rmSync(path, { force: true }); } catch { /* invalid metadata remains a cold miss */ } }
+  }
+  return cold;
+}

package/scripts/tsc-incremental-diagnostics.ts

@@ -0,0 +1,76 @@
+/** Diagnostic comparison for the incremental compiler. Only union member order is ignored. */
+
+function atomAt(value: string, start: number): { text: string; end: number } | null {
+  if (value[start] === '"') {
+    const end = value.indexOf('"', start + 1);
+    return end < 0 ? null : { text: value.slice(start, end + 1), end: end + 1 };
+  }
+  const name = /^[A-Za-z_$][\w$]*/.exec(value.slice(start));
+  if (!name) return null;
+  let end = start + name[0].length;
+  if (value[end] === '<') {
+    let depth = 1;
+    let cursor = end + 1;
+    let quoted = false;
+    for (; cursor < value.length; cursor++) {
+      if (value[cursor] === '"' && value[cursor - 1] !== '\\') quoted = !quoted;
+      if (quoted) continue;
+      if (value[cursor] === '<') depth++;
+      else if (value[cursor] === '>' && --depth === 0) break;
+    }
+    if (depth === 0) end = cursor + 1;
+  }
+  const raw = value.slice(start, end);
+  return { text: raw.includes(' | ') && raw.includes('<') && raw.endsWith('>')
+    ? `${name[0]}<${normalizeUnionAtoms(raw.slice(name[0].length + 1, -1))}>` : raw, end };
+}
+
+function normalizeUnionAtoms(line: string): string {
+  let result = '';
+  for (let i = 0; i < line.length;) {
+    const first = atomAt(line, i);
+    if (!first || line.slice(first.end, first.end + 3) !== ' | ') {
+      if (first) { result += first.text; i = first.end; }
+      else { result += line[i]!; i++; }
+      continue;
+    }
+    const parts = [first.text];
+    let end = first.end;
+    while (line.slice(end, end + 3) === ' | ') {
+      const next = atomAt(line, end + 3);
+      if (!next) break;
+      parts.push(next.text);
+      end = next.end;
+    }
+    result += parts.sort().join(' | ');
+    i = end;
+  }
+  return result;
+}
+
+function normalizeDiagnosticLine(line: string): string {
+  // The observed reorder is a TypeScript union containing quoted literal members.
+  // Bare quoted prose such as 'a | b' may be a string value, so keep it byte-exact.
+  return line.replace(/'([^'\n]*\|[^'\n]*)'/g, (quoted, type: string) => type.includes('"') ? `'${normalizeUnionAtoms(type)}'` : quoted);
+}
+
+/** Include continuation lines; the existing gate parser reads only TS header lines. */
+export function normalizedDiagnosticSet(output: string): string | null {
+  const blocks: string[] = [];
+  const other: string[] = [];
+  let block: string[] | null = null;
+  for (const line of output.split(/\r?\n/)) {
+    if (/^.+?\.[cm]?tsx?\(\d+,\d+\): error TS\d+:/.test(line)) {
+      if (block) blocks.push(block.map(normalizeDiagnosticLine).join('\n'));
+      block = [line];
+    } else if (block && /^\s/.test(line)) block.push(line);
+    else {
+      if (block) blocks.push(block.map(normalizeDiagnosticLine).join('\n'));
+      block = null;
+      if (line.trim()) other.push(line);
+    }
+  }
+  if (block) blocks.push(block.map(normalizeDiagnosticLine).join('\n'));
+  if (/error TS\d+/.test(output) && blocks.length === 0) return null;
+  return JSON.stringify({ blocks: blocks.sort(), other });
+}

package/scripts/tsc-main-safety-net.ts

@@ -3,7 +3,7 @@ import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { debug } from '../src/debug/log.js';
 import { effectiveInstanceRoot } from '../src/instance/resolve.js';
-import { GATE_REMOTE_DEFAULTS, isValidGateHost, resolveGateRemoteSettings, runOnRemote, type ExecResult, type RemoteRunOptions, type RemoteRunOutcome } from '../src/self-implement/gate-remote.js';
+import { GATE_REMOTE_DEFAULTS, gateRemoteHostCap, isValidGateHost, resolveGateRemoteSettings, runOnRemote, type ExecResult, type RemoteRunOptions, type RemoteRunOutcome } from '../src/self-implement/gate-remote.js';
 import { getUserConfig } from '../src/user-config.js';
 import { parseTypecheckErrors, tscEnv } from '../src/typecheck-ratchet.js';
 import { compareDiagnostics, normalizeDiagnostics, type NormalizedDiagnostic } from './tsc-baseline-comparison.js';
@@ -143,7 +143,7 @@ export async function runSafetyNet(repo: string, argv: readonly string[] = [], d
       diagnostics = diagnosticsOf(result, worktree);
       if (!diagnostics) reason = 'local tsc did not produce a complete measurement';
     } else {
-      const result = remote({ repo: worktree, host, mirror: settings.mirror, hostCap: settings.hostCap, argv: TSC_ARGV });
+      const result = remote({ repo: worktree, host, mirror: settings.mirror, hostCap: gateRemoteHostCap(settings, host), argv: TSC_ARGV });
       if (result.kind === 'ran') {
         if (result.commit !== commit) throw new Error('remote measured a different commit');
         diagnostics = diagnosticsOf({ rc: result.rc, stdout: result.stdout.toString('utf8'), stderr: result.stderr.toString('utf8') }, worktree);

package/src/acp/client.ts

@@ -692,6 +692,7 @@ export class AcpAgent {
     sessionId: SessionId;
     cwd?: string;
     mcpServers?: McpServer[];
+    _meta?: Record<string, unknown>;
   }): Promise<LoadSessionResponse> {
     if (!this.connection) throw new Error('AcpAgent not started');
     if (!this.peerCapabilities?.loadSession) {
@@ -701,6 +702,7 @@ export class AcpAgent {
       sessionId: req.sessionId,
       cwd: req.cwd ?? this.cwd,
       mcpServers: req.mcpServers ?? [],
+      ...(req._meta ? { _meta: req._meta } : {}),
     });
   }
 
@@ -764,13 +766,14 @@ export class AcpAgent {
 
   /** Begin a new session in the configured cwd. Returns the agent-
    *  assigned sessionId — caller stores this for follow-up turns. */
-  async newSession(): Promise<SessionId> {
+  async newSession(meta?: Record<string, unknown>): Promise<SessionId> {
     if (!this.connection) throw new Error('AcpAgent not started');
     let response;
     try {
       response = await this.connection.newSession({
         cwd: this.cwd,
         mcpServers: [],
+        ...(meta ? { _meta: meta } : {}),
       });
     } catch (error) {
       if (this.spec.id === 'claude'

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

@@ -43,6 +43,8 @@ import {
   type CoreTurnContext,
   type CoreTurnDispatchTool,
 } from '../core-turn/index.js';
+import { stripGoalRepeatReadbackPreface } from '../core-turn/run-goal-loop.js';
+import { parseSeatTurnCapConfig, resolveSeatTurnCap } from '../core-turn/seat-turn-cap.js';
 import { getUserConfig } from '../user-config.js';
 import { getModelFamily } from '../models/prompts.js';
 import { resolveModelContextWindow } from '../models/context-window.js';
@@ -50,7 +52,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 { classifyTuiChatIntent, formatTuiRouteLine, type TuiChatRoute } from '../core-turn/short-question.js';
+import { classifyTuiChatIntent, formatTuiRouteLine, isSeatOpsDirective, type TuiChatRoute } from '../core-turn/short-question.js';
 import { HARNESS_ROLE_ENV } from '../harness/harness-space.js';
 
 const FACT_QUESTION_INSTRUCTION = '사실·최신 정보 질문이다. WebSearch 를 1~2회 쓰고 검색 결과(제목·스니펫·URL)로 답하라. 출처 링크를 붙여라. 셸·브라우저·파일 도구는 검색 결과로 부족할 때만. 도구 예산에 닿으면 지금까지 근거로 답하고 끝에 «더 찾아볼까요?»를 붙여라.';
@@ -64,8 +66,10 @@ type QuickTuiRoute = Exclude<TuiChatRoute, '코딩·구현' | '읽기·분석'>;
 const QUICK_TOOLS: Record<QuickTuiRoute, readonly string[]> = {
   '조회': ['decisions_pending', 'ops_seats', 'ops_status', 'release_status', 'logs_query', 'context_now', 'memory_recall', 'Read'],
   '설정 변경': ['DashboardConfigGet', 'DashboardConfigSet', 'LlmListAvailableModels', 'prompt_getRuntimeConfig', 'prompt_setRuntimeConfig', 'view_getConfig', 'view_applyRuntimeConfig', 'view_saveConfig', 'memory_recall'],
-  '조사': ['WebSearch', 'OmniSearch', 'Grep', 'Glob', 'Read', 'fact_check', 'memory_recall'],
-  '상시 일': ['schedule_manage', 'schedule_list', 'schedule_create', 'schedule_update', 'session_manage', 'ops_status', 'memory_recall'],
+  // MsgList is a read-only ledger listing (never acks); MsgPost · MsgAck · RunShell · Bash stay out (TUI-QUICK-ROUTE-EXPLICIT-CMD).
+  '조사': ['WebSearch', 'OmniSearch', 'Grep', 'Glob', 'Read', 'fact_check', 'memory_recall', 'MsgList', 'Agent'],
+  // ScheduleWakeup (H5) wakes this TUI in-process; schedule_manage is OS cron — both belong to «상시 일».
+  '상시 일': ['schedule_manage', 'schedule_list', 'schedule_create', 'schedule_update', 'ScheduleWakeup', 'session_manage', 'ops_status', 'memory_recall'],
 };
 
 export function toolsForTuiRoute(tools: readonly LLMToolSpec[], route: QuickTuiRoute): LLMToolSpec[] {
@@ -133,6 +137,9 @@ export interface CoreTurnBridgeDeps {
   abortPollMs?: number;
   /** Only the in-process dashboard session opts into TUI routing; daemon ACP stays unchanged. */
   tuiRouting?: boolean;
+  /** TUI-H1-SEAT-GOALLOOP — the seat this TUI works for (`detectSeatTui`), read per turn. null/absent = a human
+   *  conversation TUI (routing unchanged). A seat TUI sends operational directives to the goal loop. */
+  resolveSeat?: () => string | null;
 }
 
 /** Default abort-poll cadence. 50ms = 20 Hz: responsive without
@@ -228,16 +235,24 @@ export function bridgeCoreTurnToAcp(
       // Only a goal-driven harness child (explicit executor role — dev-harness · self-implement surfaces) keeps every
       // turn on the goal loop. A human TUI inside a harness space (one-word `dev --elanous`, `--hold`) is routed (UX 10-07).
       const harness = process.env[HARNESS_ROLE_ENV]?.trim() === 'executor';
+      // seatKnown=false: no resolver (or it threw) — routed as a human TUI, but the log keeps «unknown», not «not a seat».
+      let seat: string | null = null;
+      let seatKnown = false;
+      if (deps.tuiRouting && !harness && deps.resolveSeat) {
+        try { seat = deps.resolveSeat(); seatKnown = true; }
+        catch (error) { debug.log('chat.route', 'seat-unresolved', { error: String(error) }, { level: 'warn' }); }
+      }
       const route = deps.tuiRouting && !harness
         ? classifyTuiChatIntent(turnCtx.userText, {
             hasAttachments: turnCtx.promptBlocks?.some((block) => block.type !== 'text') ?? false,
+            seat: seat !== null,
           })
         : { route: '코딩·구현' as const, reason: harness ? 'harness' : 'legacy', goalLoop: true };
       const tools = !route.goalLoop && route.route !== '코딩·구현' && route.route !== '읽기·분석'
-        ? toolsForTuiRoute(availableTools, route.route)
+        ? toolsForTuiRoute(availableTools, route.route) // bridgeCoreTurnToAcp applies route allowlists here.
         : availableTools;
       if (deps.tuiRouting) {
-        debug.log('chat.route', 'decided', { route: route.route, reason: route.reason, goalLoop: route.goalLoop });
+        debug.log('chat.route', 'decided', { route: route.route, reason: route.reason, goalLoop: route.goalLoop, seat, seatKnown });
         // Only a quick route is announced: a coding turn's transcript stays exactly as before (preservation).
         // Awaited so the route line precedes the answer; a failed write is observed, not fatal to the turn.
         if (!route.goalLoop) {
@@ -253,6 +268,17 @@ export function bridgeCoreTurnToAcp(
       // 하드코딩 기본 ON 아님 — config 로 아밍(안전).
       const goalLoopCfg = getUserConfig().llm.goalLoop;
       const armGoalLoop = goalLoopCfg?.enabled === true && route.goalLoop;
+      // 인지(TUI-H1-SEAT-GOALLOOP) — 자리 TUI 의 운영 지시가 그래도 단일 턴이면(예: llm.goalLoop 꺼짐) 경고로 남긴다.
+      // 빠른 짧은 물음(short-*)은 자리에서도 «의도적» 단일 턴이라 경고에서 뺀다(«다음 행이 뭐야?»).
+      if (deps.tuiRouting && seat !== null && !armGoalLoop && !route.reason.startsWith('short-')
+        && isSeatOpsDirective(turnCtx.userText)) {
+        try {
+          debug.log('chat.route', 'seat-ops-single-turn', {
+            seat, route: route.route, reason: route.reason, goalLoop: route.goalLoop,
+            goalLoopEnabled: goalLoopCfg?.enabled === true,
+          }, { level: 'warn' });
+        } catch { /* observation cannot interrupt a turn */ }
+      }
       // 사실 질문 예산은 «단일 턴» 전용이다 — goal loop 와 겹치면 예산을 다 쓴 뒤에도 루프가 계속 재촉해
       // 매 continuation 이 «Tool budget reached» 로 거부되고, 모델은 그것을 도구 장애로 읽어 blocked 를 남긴다
       // (10-14 13:48 운영 TUI OP: route short-question·goalLoop ⊕ factQuestion → 소진 뒤 헛호출 7회).
@@ -292,6 +318,7 @@ export function bridgeCoreTurnToAcp(
       let finalSupplement: { answer: string; supplement: string; finalText: string } | null = null;
       // turnFamily 는 관측용으로만 유지(goal loop 아밍 판정은 위 사실 질문 판정 앞에서 한다).
       const turnModel = modelOverride ?? getUserConfig().llm.model;
+      let resolvedRoute: { provider: string; model: string } | null = null;
       const turnFamily = getModelFamily(turnModel);
       if (armGoalLoop) {
         // 관측 — 어느 family/모델에서 across-turn goal-loop 가 아밍됐나(전-family 개방 검증).
@@ -307,10 +334,17 @@ export function bridgeCoreTurnToAcp(
           safeguard: 'context-pressure-bail',
         });
       }
+      // TUI-SEAT-TURN-CAP — 자리 판정으로 goal loop 에 온 턴만 core 턴 상한·«할 일 0» 판정을 받는다(사람 TUI·하니스 자식 0).
+      const seatTurnCap = armGoalLoop && seat !== null && route.reason.startsWith('seat-')
+        ? { seat, ...resolveSeatTurnCap(parseSeatTurnCapConfig(getUserConfig().chat?.seatTurnCap)) }
+        : undefined;
       const runTurnDispatch = (c: CoreTurnContext): Promise<unknown> =>
         armGoalLoop
           ? runGoalLoop(c, {
               ...(goalLoopCfg?.maxIterations !== undefined ? { maxIterations: goalLoopCfg.maxIterations } : {}),
+              // #29 처방 — 자리 판정으로 goal loop 에 «되돌아온» 턴만 빈 evidence 완료를 답으로 받는다.
+              ...(route.reason.startsWith('seat-') ? { lenientCompletionEvidence: true } : {}),
+              ...(seatTurnCap !== undefined ? { seatTurnCap } : {}),
               ...(goalCtxWindow > 0 ? { contextTokenLimit: goalCtxWindow } : {}),
             })
           : runCoreTurn(c);
@@ -389,8 +423,18 @@ export function bridgeCoreTurnToAcp(
             void turnCtx.pushToolCall(call);
           },
           onToolResult: (call) => { void turnCtx.pushToolResult(call); },
+          // 실제로 응답한 공급자·모델을 기억한다 — 폴백 체인이 넘기면(예 codex → grok) 턴 모델(turnModel)과 달라진다.
+          //   streamLLMWithTools 가 스트림을 (다시) 열 때마다 부른다 → 사용량 직전 값 = 그 사용량을 낸 쪽.
+          onResolvedProvider: (provider, model) => { resolvedRoute = { provider, model }; },
           // 턴 모델(라우팅 결과)을 실어 보낸다 — 대시보드 턴 지표가 설정 모델로 ctx·단가를 잡지 않게.
-          onUsage: (usage) => { void turnCtx.pushUsage({ ...usage, model: usage.model ?? turnModel }); },
+          //   ⭐ 폴백이면 «넘어간» 모델·공급자를 싣는다(TUI-MODEL-BADGE-ACTUAL · 완료 배지가 읽는다 · 상태줄·/model 은 후속 TUI-MODEL-BADGE-SOURCE).
+          onUsage: (usage) => {
+            void turnCtx.pushUsage({
+              ...usage,
+              model: usage.model ?? resolvedRoute?.model ?? turnModel,
+              ...(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
@@ -462,10 +506,19 @@ export function bridgeCoreTurnToAcp(
             const visibleFinalText = needsFollowup ? extractLastAssistantText(completedMessages) : finalAssistantText;
             const originalFinalStreamed = needsFollowup && finalAssistantText !== null
               && streamedTextSum.endsWith(finalAssistantText);
+            // TUI-GOAL-REPEAT-ANSWER — 골 루프가 «인사 + 같은 답» 재방출을 화면에서 가리면(원장은 그대로)
+            // 브리지의 스트림 합계에는 그 답이 없다. 그대로 보면 «마지막 답을 못 그렸다»고 재표면화로 다시
+            // 그린다 — 이전 답이 이미 화면에 있는데도. 인사를 뗀 답 부분이 스트림 꼬리에 있으면 «그렸다»로
+            // 본다(골 루프 경로에서만 — 다른 경로의 판정은 그대로).
+            const goalRepeatStrippedFinalText = armGoalLoop && visibleFinalText !== null
+              ? stripGoalRepeatReadbackPreface(visibleFinalText)
+              : visibleFinalText;
             const synthesisAlreadyStreamed =
               visibleFinalText !== null
               && visibleFinalText.length > 0
-              && streamedTextSum.endsWith(visibleFinalText);
+              && (streamedTextSum.endsWith(visibleFinalText)
+                || (goalRepeatStrippedFinalText !== null && goalRepeatStrippedFinalText.length > 0
+                  && streamedTextSum.endsWith(goalRepeatStrippedFinalText)));
             // ⭐ 최종 답 = 모델 답 ⊕ 런타임 검증 보충이면 사용자에겐 «모델 답»만 보인다 — 보충은 로그로(#25).
             //   대화 이력(completedMessages)엔 그대로 남아 다음 턴 맥락은 바뀌지 않는다.
             const supplement = finalSupplement !== null && finalAssistantText === finalSupplement.finalText
@@ -491,7 +544,11 @@ export function bridgeCoreTurnToAcp(
               });
             }
             if (supplement !== null) {
-              const answerStreamed = supplement.answer.length > 0 && streamedTextSum.trimEnd().endsWith(supplement.answer);
+              // TUI-GOAL-REPEAT-ANSWER — 위와 같은 이유: 인사를 뗀 답 부분이 스트림 꼬리에 있으면 그렸다(골 루프만).
+              const answerStreamed = supplement.answer.length > 0
+                && (streamedTextSum.trimEnd().endsWith(supplement.answer)
+                  || (armGoalLoop
+                    && streamedTextSum.trimEnd().endsWith(stripGoalRepeatReadbackPreface(supplement.answer))));
               try {
                 // 보충 «전체»를 남긴다 — 한 행이 저장 전에 잘리지 않게 조각(part/parts)으로 나눈다(리뷰 r3·r4).
                 const redacted = redactSecretText(supplement.supplement);

package/src/acp/elanous-extensions.ts

@@ -81,6 +81,9 @@ export interface ElanousUiUsagePayload {
   provider?: 'anthropic' | 'openai';
   /** 그 턴이 실제로 요청한 모델(라우팅 결과 — 설정 모델과 다를 수 있다). */
   model?: string;
+  /** 이 사용량을 낸 «실제» 공급자(폴백 체인이 넘겼으면 넘어간 쪽 · 예 `grok`). `provider` 는 과금 계열 축이라 따로 둔다
+   *  (TUI-MODEL-BADGE-ACTUAL · 10-16). */
+  routeProvider?: string;
   inputTokens?: number;
   outputTokens?: number;
   cacheReadInputTokens?: number;

package/src/acp/server.ts

@@ -838,6 +838,8 @@ export interface AcpTurnContext {
   pushUsage: (usage: {
     provider?: 'anthropic' | 'openai';
     model?: string;
+    /** 실제로 응답한 공급자(폴백이면 넘어간 쪽). */
+    routeProvider?: string;
     inputTokens?: number;
     outputTokens?: number;
     cacheReadInputTokens?: number;
@@ -1839,6 +1841,7 @@ function wireAcpConnection(
           id: `turn:${Date.now()}`,
           ...(usage.provider !== undefined ? { provider: usage.provider } : {}),
           ...(usage.model !== undefined ? { model: usage.model } : {}),
+          ...(usage.routeProvider !== undefined ? { routeProvider: usage.routeProvider } : {}),
           ...(usage.inputTokens !== undefined ? { inputTokens: usage.inputTokens } : {}),
           ...(usage.outputTokens !== undefined ? { outputTokens: usage.outputTokens } : {}),
           ...(usage.cacheReadInputTokens !== undefined

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;
   }
 }