elanous 0.2.28 → 0.2.31

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

@@ -35,13 +35,16 @@
 // 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,
   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';
@@ -49,20 +52,26 @@ 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, 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)로 답하라. 출처 링크를 붙여라. 셸·브라우저·파일 도구는 검색 결과로 부족할 때만. 도구 예산에 닿으면 지금까지 근거로 답하고 끝에 «더 찾아볼까요?»를 붙여라.';
 
+// 읽기·분석 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'],
+  // 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'],
+  '상시 일': ['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));
 }
@@ -127,6 +136,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
@@ -155,6 +167,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}]}`
@@ -218,25 +234,59 @@ 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 !== '코딩·구현'
+      const tools = !route.goalLoop && route.route !== '코딩·구현' && route.route !== '읽기·분석'
         ? toolsForTuiRoute(availableTools, route.route)
         : 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) {
-          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;
+      // 인지(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회).
+      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 +312,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 });
@@ -285,10 +332,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);
@@ -326,7 +380,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 +392,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 +411,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 +421,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
@@ -434,12 +494,28 @@ 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
+              ? finalSupplement
+              : null;
+            finalSupplement = null;
             const needsReSurface =
-              visibleFinalText !== null
+              supplement === null
+              && visibleFinalText !== null
               && visibleFinalText !== streamedTextSum
               && !synthesisAlreadyStreamed
               && !originalFinalStreamed;
@@ -452,9 +528,38 @@ export function bridgeCoreTurnToAcp(
                   && visibleFinalText.startsWith(streamedTextSum),
                 endsWithStreamedTail: synthesisAlreadyStreamed,
                 needsReSurface,
+                supplementChars: supplement?.supplement.length ?? 0,
               });
             }
-            if (originalFinalStreamed) {
+            if (supplement !== null) {
+              // 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);
+                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 +581,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/ad-pipeline/run.ts

@@ -223,6 +223,8 @@ export interface AdProductionDeps {
   readonly render?: CommandRunner;
   /** Optional calibrated thresholds; omitted thresholds intentionally preserve unmeasured QC findings. */
   readonly qcThresholds?: QcThresholds;
+  /** Platform that decides whether on-screen text OCR (macOS Vision via swiftc) is planned; defaults to `process.platform`. */
+  readonly qcPlatform?: NodeJS.Platform;
 }
 
 export interface AdOutputIdentity {
@@ -828,7 +830,7 @@ async function runQc(
   captionedMasterPath?: string,
 ): Promise<QcResult | undefined> {
   if (!production?.render || !scene || !masterPath) return undefined;
-  const { measurements, unavailableTextRegions } = await measureQc(production, buildQcMeasurementPlan(scene, masterPath));
+  const { measurements, unavailableTextRegions } = await measureQc(production, buildQcMeasurementPlan(scene, masterPath, production.qcPlatform ?? process.platform));
   if (unavailableTextRegions !== undefined) {
     debug.log('ad-pipeline.qc', 'text-regions-unavailable', { reason: unavailableTextRegions });
   }
@@ -851,7 +853,7 @@ async function runQc(
     debug.log('ad-pipeline.qc', 'captioned-master-absent', { reason: !captionedMasterPath ? 'captioned-master-unavailable' : 'no-caption-lines' });
     return baseResult;
   }
-  const captionedPlan = buildQcMeasurementPlan(scene, captionedMasterPath, process.platform, {
+  const captionedPlan = buildQcMeasurementPlan(scene, captionedMasterPath, production.qcPlatform ?? process.platform, {
     textFrameAtSeconds: (line.startMs + line.endMs) / 2000,
   });
   const captionedMeasurement = await measureQc(production, captionedPlan, (step) => step === 'probe' || step.startsWith('text-'));

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/runner.ts

@@ -13,6 +13,9 @@
 // generator terminates instead of hanging.
 
 import {
+  inferProviderFromModel,
+  isModelCompatible,
+  resolveDefaultProvider,
   streamLLMWithTools,
   type LLMMessage,
   type LLMToolSpec,
@@ -20,6 +23,7 @@ import {
 import { debug } from '../debug/log.js';
 import { buildUniversalPreamble } from '../prompt-library/universal-preamble.js';
 import { getModelFamily } from '../models/prompts.js';
+import { resolveModelAlias } from '../intelligence-map/model-alias.js';
 import type {
   AgentDefinition, AgentEvent, AgentSpawnOpts, AgentTask,
 } from './types.js';
@@ -57,6 +61,151 @@ class AsyncEventQueue<T> {
   }
 }
 
+// ── Model resolution (TUI-AGENT-MODEL-FALLBACK · 결함 #34) ──
+//
+// A definition's frontmatter `model:` is a REQUEST, not a guarantee. The
+// runner must check it against the provider the child will actually run
+// on BEFORE handing it to streamLLMWithTools — a codex parent used to
+// request `haiku` verbatim and die (the provider chain re-routed the
+// Claude-family id to Anthropic, 결함 #34, 2026-10-14).
+//
+// `model: undefined` in the result means "inherit the parent": the child
+// then rides streamLLMWithTools's own provider decision
+// (`opts.provider ?? resolveDefaultProvider(opts.model)`), exactly like a
+// spawn with no model hint at all.
+
+/** Why resolveAgentModel returned the model it did. Six distinct exits —
+ *  never collapse them into one value: "fell back to parent" and "sent an
+ *  unrecognized id verbatim" must stay separable in the logs. */
+export type AgentModelResolutionReason =
+  | 'no-definition-model'
+  | 'declared-inherit'
+  | 'definition'
+  | 'incompatible-provider'
+  | 'unknown-model'
+  | 'provider-unknown';
+
+export interface AgentModelResolution {
+  /** Canonical model id; undefined = inherit the parent's model. */
+  model: string | undefined;
+  reason: AgentModelResolutionReason;
+}
+
+/** Injection seams so tests can pin the provider / inference without
+ *  touching user config. Defaults are the production functions. */
+export interface ResolveAgentModelDeps {
+  currentProviderName: () => string;
+  isCompatible: (providerName: string, model: string) => boolean;
+  inferProvider: (model: string) => string | null;
+}
+
+/** Production `currentProviderName` — the provider a model-less spawn
+ *  would run on right now (the parent-configured default). A lookup
+ *  failure is NOT hidden behind a made-up name: it throws, and
+ *  resolveAgentModel turns it into the separate `provider-unknown` exit
+ *  (judging compatibility against a fake name like 'auto' would drop a
+ *  usable definition model to inherit). */
+function productionCurrentProviderName(): string {
+  return resolveDefaultProvider().name;
+}
+
+const defaultResolveAgentModelDeps: ResolveAgentModelDeps = {
+  currentProviderName: productionCurrentProviderName,
+  isCompatible: isModelCompatible,
+  inferProvider: inferProviderFromModel,
+};
+
+/** Resolve a definition model against the provider the child would run
+ *  on RIGHT NOW. Decision order — each step guards the next:
+ *    1. no model → { undefined, 'no-definition-model' }
+ *    2. `inherit` (trimmed, case-insensitive; an inheritance MARKER, not
+ *       a model name) → { undefined, 'declared-inherit' }
+ *    3. resolveModelAlias → canonical id
+ *    4. inferProvider(canonical) === null → { canonical, 'unknown-model' }
+ *       — do NOT fall back: free-form names ride the provider as-is
+ *       (isModelCompatible's "unknown prefix is the provider's problem"
+ *       stance; dropping a local free-form name to inherit is a regression)
+ *    5. isCompatible(currentProviderName, canonical)
+ *       true  → { canonical, 'definition' }
+ *       false → { undefined, 'incompatible-provider' } (parent fallback)
+ *       currentProviderName throws → { undefined, 'provider-unknown' } —
+ *       compatibility cannot be judged, so the definition model is NOT
+ *       sent (sending it could re-route the provider by model name); the
+ *       child inherits the parent model — the goal's «can't call it →
+ *       parent model» intent, kept as its own reason so a lookup failure
+ *       is never confused with a real incompatibility
+ *
+ *  Inference (4) runs BEFORE compatibility (5) because isModelCompatible
+ *  returns true on null inference — checking compatibility first would
+ *  mislabel every unknown model as compatible and the unknown-model exit
+ *  would be unreachable. */
+export function resolveAgentModel(
+  defModel: string | undefined,
+  deps: Partial<ResolveAgentModelDeps> = {},
+): AgentModelResolution {
+  const d: ResolveAgentModelDeps = { ...defaultResolveAgentModelDeps, ...deps };
+  if (defModel === undefined || defModel.trim() === '') {
+    return { model: undefined, reason: 'no-definition-model' };
+  }
+  const trimmed = defModel.trim();
+  if (trimmed.toLowerCase() === 'inherit') {
+    return { model: undefined, reason: 'declared-inherit' };
+  }
+  const canonical = resolveModelAlias(trimmed) ?? trimmed;
+  if (d.inferProvider(canonical) === null) {
+    return { model: canonical, reason: 'unknown-model' };
+  }
+  let providerName: string;
+  try {
+    providerName = d.currentProviderName();
+  } catch {
+    return { model: undefined, reason: 'provider-unknown' };
+  }
+  if (d.isCompatible(providerName, canonical)) {
+    return { model: canonical, reason: 'definition' };
+  }
+  return { model: undefined, reason: 'incompatible-provider' };
+}
+
+/** Resolve + record exactly one `agent.model` observation. Every runtime
+ *  resolution goes through here (runAgent ⊕ a direct buildAgentMessages call
+ *  without a pre-resolved `model`) so «one observation per resolution» holds
+ *  on both paths. incompatible-provider (parent fallback), unknown-model
+ *  (verbatim pass-through of an unrecognizable id) and provider-unknown
+ *  (provider lookup failed, inherited the parent unjudged) are the exits an
+ *  operator must tell apart from a log line alone — they get warn level. */
+function resolveAgentModelObserved(
+  def: Pick<AgentDefinition, 'name' | 'model'>,
+  pinnedProviderName?: string,
+): AgentModelResolution {
+  let providerError: string | undefined;
+  let currentProviderName: string | undefined = pinnedProviderName;
+  const resolution = resolveAgentModel(def.model, {
+    currentProviderName: () => {
+      if (currentProviderName !== undefined) return currentProviderName;
+      try {
+        currentProviderName = productionCurrentProviderName();
+        return currentProviderName;
+      } catch (error) {
+        providerError = error instanceof Error ? error.message : String(error);
+        throw error;
+      }
+    },
+  });
+  debug.log('agent.model', 'resolved', {
+    agent: def.name,
+    declared: def.model,
+    model: resolution.model,
+    reason: resolution.reason,
+    provider: currentProviderName ?? null,
+    ...(providerError !== undefined ? { providerError } : {}),
+  }, resolution.reason === 'incompatible-provider' || resolution.reason === 'unknown-model'
+    || resolution.reason === 'provider-unknown'
+    ? { level: 'warn' as const }
+    : undefined);
+  return resolution;
+}
+
 // ── Helpers ──
 
 /** Assemble the initial message history. The parent's rendered system
@@ -74,7 +223,7 @@ export function buildAgentMessages(
   def: AgentDefinition,
   prompt: string,
   systemPromptPrefix?: string,
-  ctx: { cwd?: string; enabledTools?: readonly string[] } = {},
+  ctx: { cwd?: string; enabledTools?: readonly string[]; model?: string } = {},
 ): LLMMessage[] {
   let effectivePrefix: string | undefined = systemPromptPrefix;
   if (def.omitInheritedContext) {
@@ -108,7 +257,15 @@ export function buildAgentMessages(
   // omitInheritedContext contract stable we honor it strictly.
   let universalPreamble: LLMMessage[] = [];
   if (!def.omitInheritedContext && ctx.cwd) {
-    const agentModelFamily = def.model ? getModelFamily(def.model) : undefined;
+    // TUI-AGENT-MODEL-FALLBACK: the preamble's modelFamily must track the
+    // model the run will actually use. runAgent passes the already-resolved
+    // model (one resolution + one `agent.model` observation per spawn);
+    // direct callers that omit `model` resolve here so a definition model
+    // the current provider can't run never reaches the preamble either.
+    const effectiveModel = 'model' in ctx
+      ? ctx.model
+      : resolveAgentModelObserved(def).model;
+    const agentModelFamily = effectiveModel ? getModelFamily(effectiveModel) : undefined;
     universalPreamble = buildUniversalPreamble({
       cwd: ctx.cwd,
       ...(agentModelFamily !== undefined ? { modelFamily: agentModelFamily } : {}),
@@ -206,6 +363,14 @@ export async function* runAgent(
   // `Agent` → search-vs-spawn split, `TaskCreate` → don't batch).
   const tools = filterAgentTools(opts.tools, task.definition.tools);
 
+  // TUI-AGENT-MODEL-FALLBACK (결함 #34): resolve the definition model
+  // against the provider the child will ACTUALLY run on — the pinned
+  // `opts.provider` when the dispatcher chose one, otherwise the
+  // parent-configured default (what streamLLMWithTools picks for a
+  // model-less spawn). `model: undefined` = inherit: the child then takes
+  // the same provider/model decision path as the parent.
+  const modelResolution = resolveAgentModelObserved(task.definition, opts.provider?.name);
+
   // Build history on the task so callers can inspect it after the run.
   // PFC-S1 P5: pass task.cwd so the slim-context notice (when
   // omitInheritedContext) can name the child's working directory.
@@ -214,6 +379,7 @@ export async function* runAgent(
     task.prompt,
     opts.systemPromptPrefix,
     {
+      model: modelResolution.model,
       ...(task.cwd ? { cwd: task.cwd } : {}),
       ...(tools ? { enabledTools: tools.map(t => t.name) } : {}),
     },
@@ -252,7 +418,7 @@ export async function* runAgent(
       dispatchTool,
     },
     {
-      model: task.definition.model,
+      model: modelResolution.model,
       tools,
       signal: task.controller.signal,
       provider: opts.provider,

package/src/agent/subagent-callable.ts

@@ -132,7 +132,7 @@ export function createGlobalSubagentCallable(
     const done = drainToResult(handle.events, () => ({
       durationMs: Date.now() - startedAt,
       modelId: effectiveDefinition.model,
-    }));
+    }), () => handle.task.controller?.signal.aborted ?? (signal?.aborted === true));
 
     return { address, done };
   };
@@ -154,6 +154,7 @@ async function drainToResult(
     unknown
   >,
   closing: () => { durationMs: number; modelId?: string },
+  signalAborted: () => boolean,
 ): Promise<{
   status: 'completed' | 'failed' | 'cancelled';
   output: string;
@@ -190,7 +191,7 @@ async function drainToResult(
 
   const close = closing();
   const baseModel = close.modelId ? { modelId: close.modelId } : {};
-  if (aborted) {
+  if (aborted || signalAborted()) {
     return { status: 'cancelled', output: accumulated, durationMs: close.durationMs, ...baseModel };
   }
   if (errorMsg !== null) {