elanous 0.2.27 → 0.2.29

package/scripts/usage-rollup.ts

@@ -10,10 +10,14 @@
 import { spawnSync } from 'node:child_process';
 
 export interface UsageRow { site: string; provider: string; model: string; calls: number; inputTokens: number; outputTokens: number; cacheReadInputTokens: number; cacheCreationInputTokens: number; cacheCreationUnmeasuredCalls: number; usdKnown: number; unknownCostCalls: number; includedCalls: number; apiEquivalentUsd: number;
+  /** Preserve only metadata observed on the source usage row. */
+  role?: string; stage?: string; account?: string;
   /** OR-BYOK-COST — BYOK 호출 수 ⊕ 그중 상류 청구액 합(알려진 것만) ⊕ 상류를 모르는 호출 수. BYOK 를 본 행에만 있다(종전 행 바이트 불변). */
   byokCalls?: number; byokUpstreamUsd?: number; byokUpstreamUnknownCalls?: number }
 
-type UsageData = { site?: string; provider?: string; billingProvider?: string; model?: string; inputTokens?: number; outputTokens?: number; cacheReadInputTokens?: number; cacheCreationInputTokens?: number; cost?: { kind?: string; usd?: number }; podRollupKey?: string; partial?: boolean; partialSeq?: number; partialAt?: string };
+type UsageData = { site?: string; provider?: string; billingProvider?: string; model?: string; role?: unknown; stage?: unknown; account?: unknown; inputTokens?: number; outputTokens?: number; cacheReadInputTokens?: number; cacheCreationInputTokens?: number; cost?: { kind?: string; usd?: number }; podRollupKey?: string; partial?: boolean; partialSeq?: number; partialAt?: string };
+
+const observedTag = (value: unknown): string | undefined => typeof value === 'string' && value.trim() ? value : undefined;
 
 /** 재방출 행 dedup 에 필요한 칸만 — 호스트 소비처(bench-report · `elanous usage`)도 같은 규칙을 쓴다. */
 export type PodRollupKeyed = { podRollupKey?: unknown; partial?: unknown; partialSeq?: unknown; partialAt?: unknown };
@@ -68,8 +72,12 @@ export function rollup(lines: readonly string[]): { rows: UsageRow[]; truncated:
   const entries = dedupePodRollupRows(parsed);
   for (const d of entries) {
     const provider = d.billingProvider ?? d.provider ?? '?';   // ⭐ 과금 주체 우선(B10)
-    const key = `${d.site ?? '?'}|${provider}|${d.model ?? '?'}`;
-    const row = by.get(key) ?? { site: d.site ?? '?', provider, model: d.model ?? '?', calls: 0, inputTokens: 0, outputTokens: 0, cacheReadInputTokens: 0, cacheCreationInputTokens: 0, cacheCreationUnmeasuredCalls: 0, usdKnown: 0, unknownCostCalls: 0, includedCalls: 0, apiEquivalentUsd: 0 };
+    const role = observedTag(d.role), stage = observedTag(d.stage), account = observedTag(d.account);
+    // A site/model bucket can contain different roles or accounts. Keeping those
+    // dimensions separate is required before the host can report who used a model.
+    const key = JSON.stringify([d.site ?? '?', provider, d.model ?? '?', role ?? null, stage ?? null, account ?? null]);
+    const row = by.get(key) ?? { site: d.site ?? '?', provider, model: d.model ?? '?', calls: 0, inputTokens: 0, outputTokens: 0, cacheReadInputTokens: 0, cacheCreationInputTokens: 0, cacheCreationUnmeasuredCalls: 0, usdKnown: 0, unknownCostCalls: 0, includedCalls: 0, apiEquivalentUsd: 0,
+      ...(role !== undefined ? { role } : {}), ...(stage !== undefined ? { stage } : {}), ...(account !== undefined ? { account } : {}) };
     row.calls++;
     row.inputTokens += Number(d.inputTokens ?? 0);
     row.outputTokens += Number(d.outputTokens ?? 0);

package/scripts/ux-sim.ts

@@ -16,6 +16,7 @@
 //   bun scripts/ux-sim.ts --fault cred-expiry # 결함 주입: grok 구독 만료 임박 × 갱신 결과 → 디스패처·발사 판정
 //   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 잠금 → 로그 배치 버퍼·복구
 //
 // ⛔ 이 CLI 는 «실제 위젯 render()» 를 부른다 — 흉내 렌더러가 아니다.
 import { simRenderLogFrame } from '../src/ux-sim/render-frame.js';
@@ -71,7 +72,12 @@ if (argv.includes('--fault')) {
     console.log(renderPoolCap(poolCapSweep()).join('\n'));
     process.exit(0);
   }
-  console.error(`⛔ 모르는 결함이다: ${fault ?? '(없음)'} — 아는 것: cred-expiry · pod-death · pool-cap`);
+  if (fault === 'sqlite-busy') {
+    const { simSqliteBusy, renderSqliteBusy } = await import('../src/ux-sim/fault-sqlite-busy.js');
+    console.log(renderSqliteBusy(simSqliteBusy()).join('\n'));
+    process.exit(0);
+  }
+  console.error(`⛔ 모르는 결함이다: ${fault ?? '(없음)'} — 아는 것: cred-expiry · pod-death · pool-cap · sqlite-busy`);
   process.exit(2);
 }
 

package/scripts/verify-kpack6-live.ts

@@ -0,0 +1,230 @@
+// KPACK6 — 선택 실행 운영 스모크 (읽기 전용)
+//
+// #25780 으로 두 공개 표본 팩의 서명 설치·CLI KnowledgeQuery·그래프 검색 인용은 착지했다.
+// 이 스크립트는 그 다음 칸이다: 설치된 두 팩에 대해 실제 CLI 채팅 LLM 답변이
+// 팩 출처(`slug@version#cardId`)를 인용하는지 확인한다.
+//
+//   팩 미설치 / LLM 호출 불가 / 스토어 오류  → 미측정 (실패 아님)
+//   답변은 왔으나 팩 출처 인용 없음          → 실패
+//   두 팩 모두 인용 답변 실물 확보 전까지    → green 금지
+//
+// 실행: KPACK6_LIVE=1 bun scripts/verify-kpack6-live.ts
+// CLI 명령은 KPACK6_AGENT_CMD 로 바꿀 수 있다(기본 `bun bin/elanous.mjs agent --new --json`).
+
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { listInstalledPacks, queryInstalledPack } from '../src/knowledge/query.js';
+
+export const KPACK6_TARGET_SLUGS = ['semiconductor-process-public', 'b2b-sales-public'] as const;
+
+export type Kpack6PackStatus =
+  | 'pack-not-installed'
+  | 'pack-unreadable'
+  | 'llm-unavailable'
+  | 'llm-timeout'
+  | 'cli-contract-error'
+  | 'citation-missing'
+  | 'cited';
+
+export type Kpack6PackResult = {
+  slug: string;
+  packId: string | null;
+  status: Kpack6PackStatus;
+  measured: boolean;
+  question?: string;
+  reply?: string;
+  ref?: string;
+  reason?: string;
+};
+
+export type Kpack6SmokeStatus = 'green' | 'fail' | 'not-measured' | 'skipped';
+
+export type Kpack6SmokeReport = {
+  status: Kpack6SmokeStatus;
+  reason?: string;
+  packs: Kpack6PackResult[];
+  generatedAt: string;
+};
+
+export type Kpack6Deps = {
+  installedPacks?: () => Array<{ id: string; title: string }>;
+  queryTopCard?: (packId: string) => { id: string; title: string; ref: string };
+  ask?: (question: string) => Promise<{ reply: string }>;
+  env?: Record<string, string | undefined>;
+};
+
+const REPO_ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
+
+function escapeRegExp(text: string): string {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+/** 설치된 팩에서 조회한 바로 그 카드의 ref만 인용으로 인정한다. */
+export function packCitationIn(reply: string, expectedRef: string): string | null {
+  const exactRef = new RegExp(`(?<![\\w./@#-])${escapeRegExp(expectedRef)}(?=$|[^\\w./@#-])`);
+  return exactRef.test(reply) ? expectedRef : null;
+}
+
+function defaultQueryTopCard(packId: string): { id: string; title: string; ref: string } {
+  const hits = queryInstalledPack(packId, '');
+  if (hits.length === 0) throw new Error(`팩에 카드가 없다: ${packId}`);
+  return { id: hits[0].id, title: hits[0].title, ref: hits[0].ref };
+}
+
+export class Kpack6CliContractError extends Error {}
+export class Kpack6LlmTimeoutError extends Error {}
+
+function isProviderUnavailable(stderr: string): boolean {
+  return /No LLM provider available|usage_limit_reached|(?:^|\W)429(?:\W|$)/i.test(stderr);
+}
+
+export async function askViaCli(question: string, env: Record<string, string | undefined>): Promise<{ reply: string }> {
+  const argv = (env.KPACK6_AGENT_CMD ?? 'bun bin/elanous.mjs agent --new --json').split(/\s+/);
+  const timeoutMs = Number(env.KPACK6_TIMEOUT_MS ?? 180_000);
+  return await new Promise((resolve, reject) => {
+    const child = spawn(argv[0], [...argv.slice(1), question], {
+      cwd: REPO_ROOT, env: { ...process.env, ...env }, stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    let stdout = '';
+    let stderr = '';
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      child.kill('SIGKILL');
+    }, timeoutMs);
+    child.stdout.on('data', (chunk) => { stdout += String(chunk); });
+    child.stderr.on('data', (chunk) => { stderr += String(chunk); });
+    child.on('error', (err) => {
+      clearTimeout(timer);
+      reject(new Kpack6CliContractError(`agent CLI 실행 실패 — ${err.message}`));
+    });
+    child.on('close', (code) => {
+      clearTimeout(timer);
+      if (timedOut) {
+        reject(new Kpack6LlmTimeoutError(`agent CLI LLM 응답 시간 초과 (${timeoutMs}ms)`));
+        return;
+      }
+      const jsonLine = stdout.split('\n').filter((line) => line.trim().startsWith('{')).pop();
+      if (code !== 0) {
+        const message = `agent CLI exit=${code} stderr=${stderr.slice(0, 300)}`;
+        reject(isProviderUnavailable(stderr) ? new Error(message) : new Kpack6CliContractError(message));
+        return;
+      }
+      if (!jsonLine) {
+        reject(new Kpack6CliContractError('agent CLI 성공 출력에 JSON 객체가 없다'));
+        return;
+      }
+      try {
+        const parsed = JSON.parse(jsonLine) as { reply?: unknown };
+        if (typeof parsed.reply !== 'string' || parsed.reply.trim() === '') {
+          reject(new Kpack6CliContractError('agent CLI 응답에 reply 문자열이 없다'));
+          return;
+        }
+        resolve({ reply: parsed.reply });
+      } catch (err) {
+        reject(err instanceof Kpack6CliContractError
+          ? err : new Kpack6CliContractError(`agent CLI 출력 JSON 파싱 실패 — ${(err as Error).message}`));
+      }
+    });
+  });
+}
+
+export function kpack6ExitCode(report: Kpack6SmokeReport): number {
+  switch (report.status) {
+    case 'green': return 0;
+    case 'fail': return 1;
+    case 'skipped': return 3;
+    default: return 4;
+  }
+}
+
+export async function runKpack6LiveSmoke(deps: Kpack6Deps = {}): Promise<Kpack6SmokeReport> {
+  const env = deps.env ?? process.env;
+  const generatedAt = new Date().toISOString();
+
+  if (env.KPACK6_LIVE !== '1') {
+    return {
+      status: 'skipped',
+      reason: '선택 실행 스모크다: KPACK6_LIVE=1 없이는 돌지 않는다 (두 팩 인용 답변 실물 1회 전까지 green 금지)',
+      packs: [],
+      generatedAt,
+    };
+  }
+
+  const ask = deps.ask ?? ((question: string) => askViaCli(question, env));
+  let installed: Array<{ id: string; title: string }>;
+  try {
+    installed = deps.installedPacks?.() ?? listInstalledPacks();
+  } catch (err) {
+    return {
+      status: 'not-measured',
+      reason: `KGS 스토어 조회 불가 — ${(err as Error).message}`,
+      packs: KPACK6_TARGET_SLUGS.map((slug) => ({
+        slug, packId: null, status: 'pack-unreadable' as const, measured: false,
+        reason: `스토어 오류: ${(err as Error).message}`,
+      })),
+      generatedAt,
+    };
+  }
+
+  const packs: Kpack6PackResult[] = [];
+  for (const slug of KPACK6_TARGET_SLUGS) {
+    const match = installed.find((pack) => pack.id === slug || pack.id.startsWith(`${slug}@`));
+    if (!match) {
+      packs.push({
+        slug, packId: null, status: 'pack-not-installed', measured: false,
+        reason: 'KGS 스토어에 설치된 팩이 없다 (미측정)',
+      });
+      continue;
+    }
+    const packId = match.id;
+
+    let top: { id: string; title: string; ref: string };
+    try {
+      top = deps.queryTopCard?.(packId) ?? defaultQueryTopCard(packId);
+    } catch (err) {
+      packs.push({
+        slug, packId, status: 'pack-unreadable', measured: false,
+        reason: `설치됐으나 카드 조회 불가 — ${(err as Error).message}`,
+      });
+      continue;
+    }
+
+    const question = `설치된 ${packId} (${match.title}) 팩의 «${top.title}» 카드를 지식 조회 도구로 읽고 요약하라. 답변에 카드 제목을 쓰고, 도구가 반환한 출처를 그대로 인용해 붙여라. 출처를 추측하지 마라.`;
+    let reply: string;
+    try {
+      reply = (await ask(question)).reply;
+    } catch (err) {
+      const contractError = err instanceof Kpack6CliContractError;
+      const timeoutError = err instanceof Kpack6LlmTimeoutError;
+      packs.push({
+        slug, packId, status: contractError ? 'cli-contract-error' : timeoutError ? 'llm-timeout' : 'llm-unavailable',
+        measured: false, question,
+        reason: `${contractError ? 'CLI JSON 계약 오류' : timeoutError ? 'LLM 응답 시간 초과' : 'CLI 채팅 LLM 호출 불가'} — ${(err as Error).message}`,
+      });
+      continue;
+    }
+
+    const ref = packCitationIn(reply, top.ref);
+    if (ref && reply.includes(top.title)) {
+      packs.push({ slug, packId, status: 'cited', measured: true, question, reply, ref });
+    } else {
+      packs.push({
+        slug, packId, status: 'citation-missing', measured: true, question, reply,
+        reason: '답변은 왔으나 조회한 설치 카드의 제목과 정확한 출처 인용이 함께 없다 — 실패',
+      });
+    }
+  }
+
+  const failed = packs.some((pack) => pack.status === 'citation-missing' || pack.status === 'cli-contract-error');
+  const allCited = packs.length > 0 && packs.every((pack) => pack.status === 'cited');
+  const status: Kpack6SmokeStatus = failed ? 'fail' : allCited ? 'green' : 'not-measured';
+  return { status, packs, generatedAt };
+}
+
+if (import.meta.main) {
+  const report = await runKpack6LiveSmoke();
+  console.log(JSON.stringify(report, null, 2));
+  process.exit(kpack6ExitCode(report));
+}

package/src/acp/codex-plugins.ts

@@ -43,6 +43,23 @@ export interface FetchCodexPluginsOpts {
   noCache?: boolean;
 }
 
+/** Read the full inventory for an explicit package import. Unlike the chip projector, this keeps
+ *  the package location and never substitutes a stale cached inventory after an RPC failure. */
+export async function readCodexPluginList(
+  spawn: typeof spawnCodexAppServer = spawnCodexAppServer,
+): Promise<unknown> {
+  const server = spawn({ requestTimeoutMs: 5000 });
+  try {
+    await server.client.request('initialize', {
+      clientInfo: { name: 'elanous', version: '0.x' }, capabilities: { experimentalApi: true },
+    });
+    return await server.client.request<Record<string, never>, unknown>('plugin/list', {});
+  } finally {
+    try { await server.client.close(); }
+    finally { server.child.kill(); }
+  }
+}
+
 /** Uncached inventory probe: distinguish no session / RPC failure from an empty installed list. */
 export async function readCodexPluginsObservation(client: CodexAppServerClient | null | undefined): Promise<
   { status: 'ok'; plugins: ReadonlyArray<CodexPlugin> } | { status: 'unknown'; plugins: readonly [] }

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

@@ -35,7 +35,8 @@
 // Core really can run headless.
 
 import type { LLMMessage, LLMToolSpec, ContentBlock } from '../llm.js';
-import { debug } from '../debug/log.js';
+import { debug, redactSecretText } from '../debug/log.js';
+import { CoreTurnAuthRejectedError } from '../core-turn/auth-rejected-notice.js';
 import {
   runCoreTurn,
   runGoalLoop,
@@ -49,20 +50,25 @@ 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, type TuiChatRoute } from '../core-turn/short-question.js';
+import { classifyTuiChatIntent, formatTuiRouteLine, 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)로 답하라. 출처 링크를 붙여라. 셸·브라우저·파일 도구는 검색 결과로 부족할 때만. 도구 예산에 닿으면 지금까지 근거로 답하고 끝에 «더 찾아볼까요?»를 붙여라.';
 
+// 읽기·분석 keeps every tool (it reads files and state) and only leaves the goal loop.
+type QuickTuiRoute = Exclude<TuiChatRoute, '코딩·구현' | '읽기·분석'>;
+
 // An allowlist, not a denylist: a new repository writer cannot slip into a quick turn.
-const QUICK_TOOLS: Record<Exclude<TuiChatRoute, '코딩·구현'>, readonly string[]> = {
+// memory_recall is read-only and on every quick route: the self-access discipline (agent/self-ambient.ts) tells
+// every turn to recall before judging, so a route without it asked for a tool it could not call (TUI-SEAT-MEMORY-SCOPE).
+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'],
-  '조사': ['WebSearch', 'OmniSearch', 'Grep', 'Glob', 'Read', 'fact_check'],
-  '상시 일': ['schedule_manage', 'schedule_list', 'schedule_create', 'schedule_update', 'session_manage', 'ops_status'],
+  '설정 변경': ['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'],
 };
 
-export function toolsForTuiRoute(tools: readonly LLMToolSpec[], route: Exclude<TuiChatRoute, '코딩·구현'>): LLMToolSpec[] {
+export function toolsForTuiRoute(tools: readonly LLMToolSpec[], route: QuickTuiRoute): LLMToolSpec[] {
   const preferred = QUICK_TOOLS[route];
   return preferred.flatMap((name) => tools.filter((tool) => tool.name === name));
 }
@@ -155,6 +161,10 @@ export function acpApprovalGatedDispatch(
   };
 }
 
+/** 사용자 답에서 뺀 검증 보충을 로그에 남길 때 한 조각의 글자 수 — 로그 저장의 문자열 상한
+ *  (`compactForLog` stringMax 256)보다 작아야 조각이 저장 중에 안 잘린다(리뷰 r4). */
+const FINAL_SUPPLEMENT_LOG_CHUNK = 240;
+
 /** Extract the trailing assistant message text from runCoreTurn's
  *  `newMessages` array. emitTurnComplete (src/llm.ts:3835) appends
  *  `{role:'assistant', content:[{type:'text', text:finalAssistantText}]}`
@@ -223,7 +233,7 @@ export function bridgeCoreTurnToAcp(
             hasAttachments: turnCtx.promptBlocks?.some((block) => block.type !== 'text') ?? false,
           })
         : { route: '코딩·구현' as const, reason: harness ? 'harness' : 'legacy', goalLoop: true };
-      const tools = !route.goalLoop && route.route !== '코딩·구현'
+      const tools = !route.goalLoop && route.route !== '코딩·구현' && route.route !== '읽기·분석'
         ? toolsForTuiRoute(availableTools, route.route)
         : availableTools;
       if (deps.tuiRouting) {
@@ -231,12 +241,27 @@ export function bridgeCoreTurnToAcp(
         // 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) {
-          try { await turnCtx.push(`라우팅: ${route.route}\n`); }
+          try { await turnCtx.push(formatTuiRouteLine(route.route)); }
           catch (error) { debug.log('chat.route', 'push-failed', { route: route.route, error: String(error) }); }
         }
       }
       const modelOverride = deps.resolveModel?.({ sessionId: turnCtx.sessionId, userText: turnCtx.userText });
-      const factQuestion = isFactQuestion(turnCtx.userText);
+      // Tier 2 arming(config-gated·2026-07-19 goal-exec → 아크4 전-family) — llm.goalLoop.enabled
+      // 면 across-turn goal loop(runGoalLoop)로 감싸 목표 완료(update_goal 증거게이트)까지 지속·
+      // continuation 재주입. **family 무관**(runGoalLoop 프롬프트·update_goal 툴 전부 provider-generic·
+      // 백스톱=max-iter·spin·blocked-3strike·context-pressure). 그 외엔 단일 turn(runCoreTurn).
+      // 하드코딩 기본 ON 아님 — config 로 아밍(안전).
+      const goalLoopCfg = getUserConfig().llm.goalLoop;
+      const armGoalLoop = goalLoopCfg?.enabled === true && route.goalLoop;
+      // 사실 질문 예산은 «단일 턴» 전용이다 — goal loop 와 겹치면 예산을 다 쓴 뒤에도 루프가 계속 재촉해
+      // 매 continuation 이 «Tool budget reached» 로 거부되고, 모델은 그것을 도구 장애로 읽어 blocked 를 남긴다
+      // (10-14 13:48 운영 TUI OP: route short-question·goalLoop ⊕ factQuestion → 소진 뒤 헛호출 7회).
+      const factShaped = isFactQuestion(turnCtx.userText);
+      const factQuestion = factShaped && !armGoalLoop;
+      if (factShaped && armGoalLoop) {
+        try { debug.log('chat.turn', 'fact-budget-skipped', { reason: 'goal-loop-armed', route: route.route }); }
+        catch { /* observation cannot interrupt a turn */ }
+      }
       const explicitMaxToolTurns = deps.resolveMaxToolTurns?.({ sessionId: turnCtx.sessionId });
       const maxToolTurns = explicitMaxToolTurns ?? (factQuestion ? getUserConfig().chat.factQuestion.maxToolTurns : undefined);
       const turnMessages: LLMMessage[] = factQuestion
@@ -262,15 +287,12 @@ export function bridgeCoreTurnToAcp(
       // `delta=''` (synthesizedText lost to ACP). The dashboard never
       // saw the substantive answer — only the streamed narration.
       let streamedTextSum = '';
-      // Tier 2 arming(config-gated·2026-07-19 goal-exec → 아크4 전-family) — llm.goalLoop.enabled
-      // 면 across-turn goal loop(runGoalLoop)로 감싸 목표 완료(update_goal 증거게이트)까지 지속·
-      // continuation 재주입. **family 무관**(runGoalLoop 프롬프트·update_goal 툴 전부 provider-generic·
-      // 백스톱=max-iter·spin·blocked-3strike·context-pressure). 그 외엔 단일 turn(runCoreTurn).
-      // 하드코딩 기본 ON 아님 — config 로 아밍(안전). turnFamily 는 관측용으로만 유지.
-      const goalLoopCfg = getUserConfig().llm.goalLoop;
+      // 런타임이 최종 답 꼬리에 붙인 검증 보충(변경 파일·검증 최신성·루프 마감 상태 — goal loop 내부 판정).
+      // 사용자 답에서는 빼고 로그로 보낸다(TUI 결함 #25). 코어 턴이 끝날 때마다(goal loop 반복 경계) 비운다.
+      let finalSupplement: { answer: string; supplement: string; finalText: string } | null = null;
+      // turnFamily 는 관측용으로만 유지(goal loop 아밍 판정은 위 사실 질문 판정 앞에서 한다).
       const turnModel = modelOverride ?? getUserConfig().llm.model;
       const turnFamily = getModelFamily(turnModel);
-      const armGoalLoop = goalLoopCfg?.enabled === true && route.goalLoop;
       if (armGoalLoop) {
         // 관측 — 어느 family/모델에서 across-turn goal-loop 가 아밍됐나(전-family 개방 검증).
         debug.log('goal.loop', 'arm', { family: turnFamily, model: turnModel });
@@ -326,7 +348,7 @@ export function bridgeCoreTurnToAcp(
             return approvedDispatch(name, args, dispatchCtx);
           }
         : approvedDispatch;
-      await runTurnDispatch({
+      const dispatchResult = await runTurnDispatch({
         sessionId: turnCtx.sessionId,
         ...(originSessionId ? { originSessionId } : {}),
         ...(turnCtx.userText ? { userText: turnCtx.userText } : {}),
@@ -338,7 +360,11 @@ export function bridgeCoreTurnToAcp(
         ...(maxToolTurns !== undefined ? { maxToolTurns } : {}),
         ...((!factQuestion || explicitMaxToolTurns !== undefined) && deps.budgetGrant !== undefined ? { budgetGrant: deps.budgetGrant } : {}),
         callbacks: {
-          onText: (delta) => {
+          onText: (delta, full) => {
+            // ⛔ 검증 보충이 붙은 최종 답의 재방출(`onText('', 답+보충)`)은 흘리지 않는다 — 빈 청크를 TUI 는
+            //   «확정(commit)»으로 읽어 이미 그린 답을 굳히고, 아래 onTurnComplete 재표면화가 같은 답을
+            //   «한 번 더» 그렸다(TUI 결함 #25 · 10-14 18:36 OPT). 답 표시는 onTurnComplete 가 정한다.
+            if (delta === '' && finalSupplement !== null && full === finalSupplement.finalText) return;
             // Fire-and-forget: ACP `push` is async but the core-turn
             // contract is synchronous onText. Chunks are delivered in
             // order because `sessionUpdate` is serialized per-
@@ -353,6 +379,7 @@ export function bridgeCoreTurnToAcp(
           // callers see today. Fire-and-forget for the same reason
           // onText is: callbacks are synchronous, `turnCtx.push*` is
           // async, ordering is preserved by the SDK.
+          onFinalAnswerSupplement: (info) => { finalSupplement = info; },
           onToolCall: (call) => {
             if (!factQuestion || maxToolTurns === undefined || maxToolTurns <= 0) {
               toolCallCount += 1;
@@ -362,7 +389,8 @@ export function bridgeCoreTurnToAcp(
             void turnCtx.pushToolCall(call);
           },
           onToolResult: (call) => { void turnCtx.pushToolResult(call); },
-          onUsage: (usage) => { void turnCtx.pushUsage(usage); },
+          // 턴 모델(라우팅 결과)을 실어 보낸다 — 대시보드 턴 지표가 설정 모델로 ctx·단가를 잡지 않게.
+          onUsage: (usage) => { void turnCtx.pushUsage({ ...usage, model: usage.model ?? turnModel }); },
           // Codex Responses API reasoning summary stream. Currently
           // surfaced via forensic only (debug.log) — acts as the
           // "did the model actually emit reasoning?" verification
@@ -438,8 +466,15 @@ export function bridgeCoreTurnToAcp(
               visibleFinalText !== null
               && visibleFinalText.length > 0
               && streamedTextSum.endsWith(visibleFinalText);
+            // ⭐ 최종 답 = 모델 답 ⊕ 런타임 검증 보충이면 사용자에겐 «모델 답»만 보인다 — 보충은 로그로(#25).
+            //   대화 이력(completedMessages)엔 그대로 남아 다음 턴 맥락은 바뀌지 않는다.
+            const supplement = finalSupplement !== null && finalAssistantText === finalSupplement.finalText
+              ? finalSupplement
+              : null;
+            finalSupplement = null;
             const needsReSurface =
-              visibleFinalText !== null
+              supplement === null
+              && visibleFinalText !== null
               && visibleFinalText !== streamedTextSum
               && !synthesisAlreadyStreamed
               && !originalFinalStreamed;
@@ -452,9 +487,34 @@ export function bridgeCoreTurnToAcp(
                   && visibleFinalText.startsWith(streamedTextSum),
                 endsWithStreamedTail: synthesisAlreadyStreamed,
                 needsReSurface,
+                supplementChars: supplement?.supplement.length ?? 0,
               });
             }
-            if (originalFinalStreamed) {
+            if (supplement !== null) {
+              const answerStreamed = supplement.answer.length > 0 && streamedTextSum.trimEnd().endsWith(supplement.answer);
+              try {
+                // 보충 «전체»를 남긴다 — 한 행이 저장 전에 잘리지 않게 조각(part/parts)으로 나눈다(리뷰 r3·r4).
+                const redacted = redactSecretText(supplement.supplement);
+                const parts = Math.max(1, Math.ceil(redacted.length / FINAL_SUPPLEMENT_LOG_CHUNK));
+                for (let part = 0; part < parts; part += 1) {
+                  debug.log('acp.turn', 'final-supplement-withheld', {
+                    sessionId: turnCtx.sessionId,
+                    answerChars: supplement.answer.length,
+                    answerStreamed,
+                    supplementChars: supplement.supplement.length,
+                    part: part + 1,
+                    parts,
+                    supplement: redacted.slice(part * FINAL_SUPPLEMENT_LOG_CHUNK, (part + 1) * FINAL_SUPPLEMENT_LOG_CHUNK),
+                  });
+                }
+              } catch { /* observation cannot interrupt a turn */ }
+              if (!answerStreamed && supplement.answer.length > 0) {
+                void turnCtx.push('');
+                void turnCtx.push(needsFollowup ? `${supplement.answer}${followupSuffix}` : supplement.answer);
+              } else if (needsFollowup) {
+                void turnCtx.push(followupSuffix);
+              }
+            } else if (originalFinalStreamed) {
               void turnCtx.push(followupSuffix);
             } else if (needsReSurface) {
               // Emit a clear-then-replace pair so clients that follow
@@ -476,6 +536,22 @@ export function bridgeCoreTurnToAcp(
           },
         },
       });
+      // ⭐ 인증 거절은 코어 턴이 «던지지 않고» 돌려준다 — 여기서 안 읽으면 서버는 end_turn 을 내고
+      //   TUI 엔 «✔ 완료»만 남는다(TUI 결함 #22). 던져서 실패 경로(prompt-failed · 오류 줄)로 보낸다.
+      const stopReason = (dispatchResult as { stopReason?: unknown } | null | undefined)?.stopReason;
+      if (stopReason === 'auth_rejected') {
+        const rawError = (dispatchResult as { errorMessage?: unknown }).errorMessage;
+        const error = new CoreTurnAuthRejectedError(typeof rawError === 'string' ? rawError : undefined);
+        try {
+          debug.log('acp.turn', 'auth-rejected', {
+            sessionId: turnCtx.sessionId,
+            model: turnModel,
+            goalLoop: armGoalLoop,
+            error: error.rawMessage.slice(0, 300),
+          }, { level: 'warn' });
+        } catch { /* observation cannot interrupt a turn */ }
+        throw error;
+      }
     } finally {
       clearInterval(poll);
     }

package/src/acp/elanous-extensions.ts

@@ -79,6 +79,8 @@ export interface ElanousUiUsagePayload {
   /** Opaque correlation id. Dashboard uses `turn:<epoch>` per turn. */
   id: string;
   provider?: 'anthropic' | 'openai';
+  /** 그 턴이 실제로 요청한 모델(라우팅 결과 — 설정 모델과 다를 수 있다). */
+  model?: string;
   inputTokens?: number;
   outputTokens?: number;
   cacheReadInputTokens?: number;

package/src/acp/server.ts

@@ -837,6 +837,7 @@ export interface AcpTurnContext {
    *  didn't advertise `elanous.ui.usage` in its ClientCapabilities. */
   pushUsage: (usage: {
     provider?: 'anthropic' | 'openai';
+    model?: string;
     inputTokens?: number;
     outputTokens?: number;
     cacheReadInputTokens?: number;
@@ -1837,6 +1838,7 @@ function wireAcpConnection(
         const payload: ElanousUiUsagePayload = {
           id: `turn:${Date.now()}`,
           ...(usage.provider !== undefined ? { provider: usage.provider } : {}),
+          ...(usage.model !== undefined ? { model: usage.model } : {}),
           ...(usage.inputTokens !== undefined ? { inputTokens: usage.inputTokens } : {}),
           ...(usage.outputTokens !== undefined ? { outputTokens: usage.outputTokens } : {}),
           ...(usage.cacheReadInputTokens !== undefined

package/src/agent/ref-grounding.ts

@@ -18,6 +18,23 @@ import { debug } from '../debug/log.js';
 /** 로컬 참조 루트(기본 ~/source/ref). 다른 환경엔 없으면 무동작(graceful). */
 export const DEFAULT_REFERENCE_ROOTS = [join(homedir(), 'source', 'ref')];
 
+// 대표 2026-10-14 — 비공개 소스(Claude Code 사본) 통로 차단. Claude Code 는 공개 계약(code.claude.com)만 본다.
+// ref 루트 아래 디렉터리가 실존해도 이 이름이면 그라운딩·조회 대상에서 뺀다(대소문자·`_`/`-` 변형 포함).
+const NON_PUBLIC_REFERENCE_PATTERN = /^claude[-_]?code[-_]?(?:fork|src|source|leak|leaked)$/i;
+
+/** 공개 계약이 아닌 참조 사본 이름인가. `owner/repo` 꼴이면 마지막 칸으로 본다. */
+export function isNonPublicReferenceName(name: string): boolean {
+  const last = name.trim().replace(/\/+$/, '').split('/').pop() ?? '';
+  return NON_PUBLIC_REFERENCE_PATTERN.test(last);
+}
+
+/** 거부 판정 ⊕ 관측 한 줄. 거부면 true. */
+export function denyNonPublicReference(name: string): boolean {
+  if (!isNonPublicReferenceName(name)) return false;
+  try { debug.log('ref.grounding', 'denied', { name, reason: 'non-public-source' }); } catch { /* fail-soft */ }
+  return true;
+}
+
 function expandTilde(p: string): string {
   return p.startsWith('~') ? join(homedir(), p.slice(1)) : p;
 }
@@ -91,6 +108,7 @@ export function localRefGroundingDigest(taskText: string, roots: string[] = DEFA
     if (!existsSync(root)) continue;
     for (const token of tokens) {
       if (seen.has(token)) continue;
+      if (denyNonPublicReference(token)) { seen.add(token); continue; }
       try {
         const path = join(root, token);
         if (statSync(path).isDirectory()) { found.push({ path, root, token }); seen.add(token); }

package/src/agent/task-notification.ts

@@ -223,7 +223,8 @@ function escapeXml(s: string): string {
   return s
     .replace(/&/g, '&')
     .replace(/</g, '&lt;')
-    .replace(/>/g, '&gt;');
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;');
 }
 
 function formatDuration(ms: number): string {

package/src/agent-mission/in-agent-plugin.ts

@@ -2,7 +2,8 @@ import type { PtyHandle } from '../pty-shell/registry.js';
 import { classifierFrameLines } from '../capture/frame-state-detect.js';
 import { emitDecision, type DecisionEvent } from '../live/detail-switch.js';
 import { debug } from '../debug/log.js';
-import { streamLLM, type LLMMessage } from '../llm.js';
+import * as llm from '../llm.js';
+import { resolveRoleLlm } from '../user-config.js';
 
 export interface PluginRequest { agent: 'codex' | 'claude'; plugin: string; marketplace: string }
 export type PluginResult = { outcome: 'installed' } | { outcome: 'escalate'; reason: 'plugins-disabled' | 'unknown-menu' | 'timeout' | 'wrong-target' | 'credentials' };
@@ -103,11 +104,15 @@ export async function installPluginInsideAgent(request: PluginRequest, pty: Pick
       ? ['[credential screen]']
       : lines(screen).slice(-10).map(line => line.slice(0, 160));
   const brain = deps.brain ?? (async (screen: string, target: string) => {
-    const messages: LLMMessage[] = [
+    const messages: llm.LLMMessage[] = [
       { role: 'system', content: 'You navigate a plugin menu using only up/down/tab/enter/wait/unknown. Return exactly one of those words. Do not choose enter unless the requested plugin@marketplace is visibly selected. Never enter credentials.' },
       { role: 'user', content: `Target: ${target}\nScreen:\n${screen.slice(-3500)}` },
     ];
-    const answer = (await streamLLM(messages, () => {}, { maxTokens: 20 })).trim().toLowerCase();
+    const resolved = resolveRoleLlm('classify');
+    const provider = llm.PROVIDERS[resolved.provider];
+    if (!provider) throw new Error(`Unknown classify provider: ${resolved.provider}`);
+    debug.log('llm.role-pin', 'resolved', { site: 'in-agent-plugin', role: 'classify', model: resolved.model, provider: resolved.provider, source: resolved.source });
+    const answer = (await llm.streamLLM(messages, () => {}, { model: resolved.model, provider, usageRole: 'classify', maxTokens: 20 })).trim().toLowerCase();
     return /^(up|down|tab|enter|wait)$/.test(answer) ? answer as 'up' | 'down' | 'tab' | 'enter' | 'wait' : 'unknown';
   });
   const target = `${request.plugin}@${request.marketplace}`;