elanous 0.2.28 → 0.2.29

package/src/core-turn/short-question.ts

@@ -23,7 +23,31 @@ const TASK = /(?:작업|파일|폴더|디렉터리|레포|저장소|커밋|브
 const PATH_OR_CODE = /(?:https?:\/\/|www\.|[\w.-]+\/[\w./-]+|\.(?:ts|tsx|js|py|md|json|yaml|swift|kt)\b|[`{};=<>])/i;
 const LIVE = /(?:오늘\s*(?:날짜|며칠|무슨\s*요일)|지금\s*몇\s*시|최신|뉴스|속보|주가|시세|환율|날씨|today'?s|latest|news|stock|weather|right now)/i;
 
-export type TuiChatRoute = '조회' | '설정 변경' | '조사' | '상시 일' | '코딩·구현';
+export type TuiChatRoute = '조회' | '설정 변경' | '조사' | '상시 일' | '읽기·분석' | '코딩·구현';
+const TUI_CHAT_ROUTES: readonly TuiChatRoute[] = ['조회', '설정 변경', '조사', '상시 일', '읽기·분석', '코딩·구현'];
+
+// goal loop 밖 턴이 답 앞에 먼저 보내는 «라우팅 줄»(core-turn-bridge) — 형식의 정본은 여기 하나다.
+export function formatTuiRouteLine(route: TuiChatRoute): string {
+  return `라우팅: ${route}\n`;
+}
+// 그 줄 «그대로»인 청크만 참이다 — 모델 출력의 시작으로 세지 않을 때 쓴다(compact-400 재시도 판정 · 0.2.29).
+export function isTuiRouteLine(chunk: string): boolean {
+  return TUI_CHAT_ROUTES.some((route) => chunk === formatTuiRouteLine(route));
+}
+
+// 읽기·분석(goal loop 밖 단일 턴 · 도구 전체) 자리에서도 goal 을 지키는 셋 — «해줘» 없는 쓰기 꼴 · 디버깅 · 목표 명시.
+// 쓰기 낱말은 «동사로 쓰일 때»만 문다(«추가 정보» · «갱신된 칸» · «기록된 결정» 은 읽기다).
+const WRITE_INTENT = /(?:(?:추가|작성|기록|반영|갱신|업데이트|개선|수정|변경|교체|생성|적용|도입|설계|연결|정정)(?=\s*(?:해|하|할|합|좀|$|[.!]))|적어|붙여|넣어|만들|고치|바꾸|올려|채워|\b(?:add|write|append|insert|implement)\b)/i;
+const DEBUG_INTENT = /(?:디버그|디버깅|에러|오류|크래시|깨져|깨짐|안\s*(?:돼|됨|되네|된다)|\b(?:debug|error|crash|broken|fails?|failing)\b)/i;
+const EXPLICIT_GOAL = /(?:^\/goal\b|목표\s*[:：]|\bgoal\s*:)/i;
+const REPO_NOUN = /(?:코드|스크립트|소스|브랜치|서버|파일|레포|저장소|\bPR\b|\b(?:code|script|branch|server|file|repo)\b)/i;
+
+function writeDebugOrGoal(q: string): 'write-intent' | 'debug' | 'explicit-goal' | null {
+  if (WRITE_INTENT.test(q)) return 'write-intent';
+  if (DEBUG_INTENT.test(q)) return 'debug';
+  if (EXPLICIT_GOAL.test(q)) return 'explicit-goal';
+  return null;
+}
 
 export interface TuiChatVerdict {
   route: TuiChatRoute;
@@ -31,8 +55,8 @@ export interface TuiChatVerdict {
   goalLoop: boolean;
 }
 
-/** Request verbs a quick lookup/settings/research/scheduling turn can carry out without the repository. */
-const QUICK_REQUEST_VERBS = /^(?:보여|알려|확인해|찾아|찾아봐|조사해|검색해|정리해|요약해|바꿔|변경해|전환해|설정해|맞춰|수정해|고쳐|만들어|등록해|예약해|추가해|보내)$/;
+/** Request verbs a quick or read-only turn can carry out without writing to the repository. */
+const QUICK_REQUEST_VERBS = /^(?:보여|알려|확인해|찾아|찾아봐|조사해|검색해|정리해|요약해|바꿔|변경해|전환해|설정해|맞춰|수정해|고쳐|만들어|등록해|예약해|추가해|보내|설명해|읽어|읽어봐|살펴|살펴봐|훑어봐|비교해|분석해|검토해|평가해|제안해)$/;
 
 /** True when the verb never appears, or each occurrence directly follows an allowed object. */
 function everyVerbTakes(text: string, verb: RegExp, object: RegExp): boolean {
@@ -42,16 +66,14 @@ function everyVerbTakes(text: string, verb: RegExp, object: RegExp): boolean {
   return true;
 }
 
-/** Uncertain or mixed requests retain the full coding goal-loop and tool surface. */
+/** Write, debug, goal, mixed or attached requests retain the coding goal loop; a plain read question is one full-tool turn. */
 export function classifyTuiChatIntent(text: string, ctx: ShortQuestionContext = {}): TuiChatVerdict {
   const q = text.trim();
   const coding = (reason: string): TuiChatVerdict => ({ route: '코딩·구현', reason, goalLoop: true });
   if (!q || ctx.hasAttachments) return coding(ctx.hasAttachments ? 'attachment' : 'empty');
-  if (/(?:하니스|구현|코딩|코드|스크립트|버그|소스|리팩터|커밋|패치|테스트|시험\s*돌|빌드|배포|브랜치|서버|파일|레포|저장소|\bPR\b|\b(?:implement|coding|code|script|refactor|commit|patch|tests?|build|deploy|branch|server|file|repo)\b)/i.test(q)) return coding('coding');
+  if (/(?:하니스|구현|코딩|버그|리팩터|커밋|패치|테스트|시험\s*돌|빌드|배포|\b(?:implement|coding|refactor|commit|patch|tests?|build|deploy)\b)/i.test(q)) return coding('coding');
   // Destructive or executing verbs in any form (not only «…줘») are never a quick turn.
-  if (/(?:지워|지우|삭제|제거|옮겨|옮기|돌려|실행|설치|되돌려|롤백|재시작|죽여|\b(?:delete|remove|rm|rename|move|run|install|revert|rollback|drop|kill|restart)\b)/i.test(q)) return coding('write-verb');
-  // A file path or code shape means the request touches the repository, whatever else it asks.
-  if (PATH_OR_CODE.test(q)) return coding('path-or-code');
+  if (/(?:지워|지우|삭제|제거|옮겨|옮기|돌려|실행(?!\s*중(?:인)?(?:\s|[?!.~]|$))|설치|되돌려|롤백|재시작|죽여|\b(?:delete|remove|rm|rename|move|run|install|revert|rollback|drop|kill|restart)\b)/i.test(q)) return coding('write-verb');
   // Allowlist, not denylist: every «…줘» request verb must be one a quick turn can do; anything else
   // (지워줘 · 돌려줘 · 옮겨줘 …) keeps the coding goal loop.
   for (const match of q.matchAll(/([가-힣]+?)\s*(?:줘|주세요|줄래|주라)/g)) {
@@ -61,9 +83,17 @@ export function classifyTuiChatIntent(text: string, ctx: ShortQuestionContext =
   // («모델 설정 수정해줘» · «알림 만들어줘» stay quick; «… 그리고 화면 고쳐줘» does not).
   if (!everyVerbTakes(q, /(?:수정|고쳐|바꿔|변경|전환|교체|\b(?:edit|fix|modify|change|switch|replace)\b)/gi, /(?:모델|설정|config|provider|예약|일정|알림|리마인더|스케줄|reminder|schedule)\s*(?:을|를|로|으로)?\s*$/i)) return coding('edit');
   if (!everyVerbTakes(q, /(?:만들어|작성|추가해|생성|등록해|\b(?:create|write|make|add)\b)/gi, /(?:알림|일정|예약|리마인더|스케줄|reminder|schedule)\s*(?:을|를)?\s*$/i)) return coding('create');
+  // Debugging or a stated goal keeps the goal loop even on a quick-route word («오류 로그 요약» · «목표: 상태 요약»).
+  if (DEBUG_INTENT.test(q)) return coding('debug');
+  if (EXPLICIT_GOAL.test(q)) return coding('explicit-goal');
+  // A repository noun, file path or code shape is no quick route; with no write, debug or goal intent it is a read.
+  if (REPO_NOUN.test(q) || PATH_OR_CODE.test(q)) {
+    const intent = writeDebugOrGoal(q);
+    return intent ? coding(intent) : { route: '읽기·분석', reason: 'read-repo', goalLoop: false };
+  }
 
   const routes: Array<{ route: Exclude<TuiChatRoute, '코딩·구현'>; reason: string; pattern: RegExp }> = [
-    { route: '조회', reason: 'lookup', pattern: /(?:결정\s*카드|결정\s*대기|상태|현황|로그|알림\s*(?:왔|있|보여)|\b(?:status|logs?|pending decisions?)\b)/i },
+    { route: '조회', reason: 'lookup', pattern: /(?:결정\s*카드|결정\s*대기|상태|현황|로그|알림\s*(?:왔|있|보여)|돌고\s*있는|진행\s*중|실행\s*중|뭐\s*하고\s*있어|\b(?:status|logs?|pending decisions?|(?<![\w-])running(?![\w-])|in progress)\b)/i },
     { route: '설정 변경', reason: 'settings', pattern: /(?:(?:모델|설정|config|provider).*(?:바꿔|변경|전환|설정해|맞춰|수정|고쳐|써\s*줘|set|change|switch|edit|fix|modify)|(?:바꿔|변경|전환).*(?:모델|설정|config|provider)|답변.*빠른\s*모델)/i },
     { route: '조사', reason: 'research', pattern: /(?:조사|검색|찾아\s*봐|뉴스|업계\s*소식|\b(?:research|search|news)\b)/i },
     { route: '상시 일', reason: 'recurring', pattern: /(?:매일|매주|매달|매\s*아침|[가-힣]+마다|정기적|반복\s*일정|예약|리마인더|\b(?:daily|weekly|every|schedule|remind)\b)/i },
@@ -74,10 +104,13 @@ export function classifyTuiChatIntent(text: string, ctx: ShortQuestionContext =
     && matches.every(({ route }) => route === '상시 일' || route === '조사' || route === '조회')) {
     return { route: '상시 일', reason: matches.length > 1 ? 'recurring-research' : 'recurring', goalLoop: false };
   }
-  if (matches.length !== 1) {
-    if (matches.length) return coding('mixed');
+  if (matches.length > 1) return coding('mixed');
+  if (!matches.length) {
+    // 쓰기·디버깅·목표 의도가 없는 물음은 파일·상태를 읽고 답하는 한 턴이다 — 증거 게이트(update_goal)를 걸지 않는다.
+    const intent = writeDebugOrGoal(q);
+    if (intent) return coding(intent);
     const shortQuestion = classifyShortQuestion(q, ctx);
-    return coding(shortQuestion.fast ? `short-${shortQuestion.reason}` : 'ambiguous');
+    return { route: '읽기·분석', reason: shortQuestion.fast ? `short-${shortQuestion.reason}` : 'read', goalLoop: false };
   }
   const { route, reason } = matches[0]!;
   return { route, reason, goalLoop: false };

package/src/core-turn/types.ts

@@ -79,9 +79,14 @@ export type CoreTurnDispatchTool = (
 /** Events the hosting surface (dashboard chat pane, ACP push pipe,
  *  future web/iphone client) cares about. All optional. */
 export interface CoreTurnCallbacks {
+  /** Actual provider and model selected for this turn, including fallback attempts. */
+  onResolvedProvider?(provider: string, model: string): void;
   /** Streaming text delta — `full` is the accumulated text across the
    *  entire turn (not just the current round). */
   onText?(delta: string, full: string): void;
+  /** The final answer came back enriched with a runtime verification
+   *  supplement — forwarded from `StreamWithToolsHandlers.onFinalAnswerSupplement`. */
+  onFinalAnswerSupplement?(info: { answer: string; supplement: string; finalText: string }): void;
   /** Fires just before a tool call is dispatched. */
   onToolCall?(call: CoreToolCall): void;
   /** Fires once the tool call resolves. */
@@ -157,4 +162,6 @@ export interface CoreTurnContext {
 export interface CoreTurnResult {
   stopReason: CoreTurnStopReason;
   finalText: string;
+  /** `auth_rejected` 일 때만 — 공급자 오류 원문(비밀값 가림). 호스트가 처방 줄에 원문을 붙인다. */
+  errorMessage?: string;
 }

package/src/dashboard/acp-active-model.ts

@@ -0,0 +1,40 @@
+// ── TUI 턴의 실행 모델 결정 (TUI-MODEL-SESSION-SCOPE · 10-14) ──
+//
+// ACP 브리지 `getActiveModel`(dashboard/index.ts) 의 본체. 인라인 클로저였을 때는 시험이 «같은 모양을
+// 재현»할 수밖에 없어, 실제 경로가 깨져도 시험이 초록이었다(1R 리뷰 GOODHART 지적). 함수로 빼서
+// 실물 `/model` 핸들러 → 이 함수 → route-decision 을 그대로 잇는다.
+
+import { debug } from '../debug/log.js';
+import { effectiveReasoningLevel } from '../llm.js';
+import { recordCurrentRouteDecision, resolveRouteDecision, sessionModelPin } from '../llm/route-decision.js';
+import { inspectActiveProvider } from '../provider-summary.js';
+import { getUserConfig } from '../user-config.js';
+
+/** The model the next dashboard turn runs, recorded as the surface's current route decision.
+ *  A `/model` session pin goes in as `explicitModel`, so it beats the Codex tier policy. */
+export function resolveDashboardActiveModel(userText: string): string | null {
+  const cfg = getUserConfig();
+  const pin = sessionModelPin('dashboard', cfg.llm.provider);
+  const decision = resolveRouteDecision({
+    provider: cfg.llm.provider,
+    configuredModel: inspectActiveProvider().model,
+    text: userText,
+    routePolicy: cfg.llm.routePolicy,
+    ...(pin ? { explicitModel: pin.model } : {}),
+  });
+  // Badge truthfulness(2026-07-19 goal-exec) — resolveRouteDecision 의 codex
+  // tier-policy 브랜치는 curated effort(예: balanced=low)를 찍지만, codex provider 는
+  // 그 값을 wire 로 보내지 않는다: 실제 effort 는 effectiveReasoningLevel(cfg)(config
+  // 주도, reasoningLevel 미설정 시 model-default high). 그대로 두면 완료 뱃지가
+  // "terra(low)" 로 떠 사용자가 모델이 약하게 돈다고 오해한다(실제 high). 실제 wire
+  // effort 로 덮어써 뱃지를 진실하게. decision.effort 는 표시 전용이라 라우팅 무영향.
+  const trueEffort = effectiveReasoningLevel(cfg.llm, decision.provider, decision.model);
+  const badgedDecision = trueEffort && trueEffort !== 'off'
+    ? { ...decision, effort: trueEffort }
+    : decision;
+  recordCurrentRouteDecision('dashboard', badgedDecision);
+  if (debug.enabled) debug.log('llm.route-decision', 'dashboard-acp', {
+    provider: decision.provider, model: decision.model, mission: decision.mission, source: decision.source,
+  });
+  return decision.model || null;
+}

package/src/dashboard/auto-compact-runtime.ts

@@ -58,6 +58,7 @@ export interface DashboardAutoCompactRuntimeDeps {
   ) => Promise<CompactPipelineResult>;
   getCompactProvider?: () => CompactProvider;
   setVerifyProbeEnabled?: (enabled: boolean) => void;
+  onPrePassApplied?: () => void;
   sessionId?: string;
 }
 
@@ -88,6 +89,7 @@ export async function runDashboardAutoCompact(
         }
         for (const m of newHistory) deps.chatHistory.push(m);
         if (userMsg) deps.chatHistory.push(userMsg);
+        deps.onPrePassApplied?.();
         deps.debugLog(
           'chat.presentation.auto-compact.pre-pass',
           'applied',

package/src/dashboard/boot-banner.ts

@@ -0,0 +1,80 @@
+import type { NexusShowResult } from '../cli/nexus-show.js';
+import { buildFirstScreenBand, type TuiDaemonLink } from './first-screen-band.js';
+
+/**
+ * Boot banner policy (#28 · 대표 «불필요한 메시지가 많다»).
+ *
+ * `minimal` (default): the first screen keeps the transcript for who/where/what-is-left.
+ * A healthy daemon link, the PWA address and a hitl callback-port shift are held for
+ * `/status`; only a failed daemon link and first-run guidance reach the transcript.
+ * `full`: the historical band, byte-identical.
+ */
+export type BootBannerMode = 'minimal' | 'full';
+
+export function normalizeBootBannerMode(value: unknown): BootBannerMode {
+  return value === 'full' ? 'full' : 'minimal';
+}
+
+/** Rows the minimal banner kept out of the transcript; `/status` reads them. */
+export interface BootBannerHeld {
+  daemon?: string;
+  pwa?: string;
+  hitl?: string;
+}
+
+export function bootBannerStatusLines(held: BootBannerHeld): string[] {
+  return [held.daemon, held.pwa, held.hitl].filter((line): line is string => !!line);
+}
+
+export interface MinimalBootBandInput {
+  readonly history: ReadonlyArray<{ role: string }>;
+  readonly lines: string[];
+  readonly width: number;
+  readonly locale?: 'ko' | 'en';
+  /** First run (onboarding not complete): keep the action/example guidance rows. */
+  readonly guidance: boolean;
+  readonly held: BootBannerHeld;
+  readonly draw: () => void;
+  readonly observe: (data: { daemon: boolean; hasPwa: boolean; hasTailnet: boolean }) => void;
+  readonly observeHeld?: (data: { row: 'daemon' | 'pwa'; status: string }) => void;
+  readonly show: () => Promise<Pick<NexusShowResult, 'status' | 'urls'>>;
+  readonly daemonLink: () => Promise<TuiDaemonLink>;
+  /** Styles the one failure row (the dashboard passes its warning color). */
+  readonly styleFailure?: (line: string) => string;
+}
+
+export function renderMinimalBootBand(input: MinimalBootBandInput): Promise<void> {
+  if (input.history.some((message) => message.role !== 'system')) return Promise.resolve();
+  const observeHeld = (data: { row: 'daemon' | 'pwa'; status: string }): void => {
+    try { input.observeHeld?.(data); } catch { /* observation is best-effort */ }
+  };
+  if (input.guidance) {
+    input.lines.unshift(...buildFirstScreenBand({ width: input.width, daemon: false, locale: input.locale ?? 'en' }).slice(2));
+  }
+  const linkPending = Promise.resolve().then(() => input.daemonLink())
+    .catch((): TuiDaemonLink => ({ status: 'error', stage: 'health' }))
+    .then((link) => {
+      const row = buildFirstScreenBand({ width: input.width, daemon: false, link, locale: input.locale })[0]!;
+      // /status «연결:» is the remote attach, not this write-daemon probe — the held row says it there.
+      if (link.status === 'connected' || link.status === 'checking') {
+        input.held.daemon = row;
+        observeHeld({ row: 'daemon', status: link.status });
+        return;
+      }
+      input.lines.push(input.styleFailure ? input.styleFailure(row) : row);
+      try { input.draw(); } catch { /* screen may have closed */ }
+    });
+  const observe = (data: { daemon: boolean; hasPwa: boolean; hasTailnet: boolean }): void => {
+    try { input.observe(data); } catch { /* observation cannot interrupt the transcript */ }
+  };
+  const pwaPending = Promise.resolve().then(input.show).then((result) => {
+    const daemon = result.status !== 'absent';
+    const pwa = result.urls?.pwa;
+    observe({ daemon, hasPwa: !!pwa, hasTailnet: !!pwa?.tailnet });
+    input.held.pwa = buildFirstScreenBand({ width: Number.MAX_SAFE_INTEGER, daemon, pwa, locale: input.locale })[1]!;
+    observeHeld({ row: 'pwa', status: pwa ? 'address' : result.status });
+  }).catch(() => {
+    observe({ daemon: false, hasPwa: false, hasTailnet: false });
+  });
+  return Promise.all([linkPending, pwaPending]).then(() => {});
+}

package/src/dashboard/dashboard-status-lines.ts

@@ -1,3 +1,11 @@
+import { seatStatusNow } from '../context-bus/context-now.js';
+import { seatsNowLine } from '../context-bus/context-now-surfaces.js';
+
+/** Shared by the live /status path and its rendering test. */
+export function readDashboardSeatsNow(now = Date.now()): string | null {
+  return seatsNowLine(seatStatusNow(new Date(now)), now);
+}
+
 export interface DashboardStatusLinesInput {
   readonly provider?: string | null;
   readonly model?: string | null;
@@ -6,6 +14,8 @@ export interface DashboardStatusLinesInput {
   readonly daemonConnected: boolean;
   readonly accountName?: string | null;
   readonly seatsNow?: string | null;
+  /** Boot rows the minimal first screen held back (PWA address · hitl port shift). */
+  readonly bootHeld?: readonly string[];
   readonly sessionSurfaceLines: readonly string[];
   readonly view: string;
   readonly focus: string;
@@ -53,6 +63,7 @@ export function buildDashboardStatusLines(input: DashboardStatusLinesInput): str
     connectionLine(address, input.daemonConnected),
     `계정: ${input.accountName?.trim() === 'default' ? '기본' : known(input.accountName)}`,
     ...(input.seatsNow ? [input.seatsNow] : []),
+    ...(input.bootHeld ?? []),
     '',
     DASHBOARD_STATUS_DETAIL_HEADING,
     ...input.sessionSurfaceLines.map(line => `  ${line}`),

package/src/dashboard/detail-viewer-runtime.ts

@@ -6,11 +6,15 @@ export interface DashboardDetailViewerSnapshot {
 export interface DashboardDetailViewerRuntimeDeps {
   setOpen: (open: boolean) => void;
   requestRender: () => void;
+  /** 그리기 «전에» 현재 내용을 위젯에 싣는다 — 채팅 단독 화면은 그리드 투영이 안 돌아 팝업이 비었다. */
+  project?: (snapshot: DashboardDetailViewerSnapshot) => void;
 }
 
 export interface DashboardDetailViewerRuntime {
   snapshot(): DashboardDetailViewerSnapshot;
   set(title: string, lines: string[]): void;
+  /** 내용만 바꾸고 팝업은 열지 않는다 — `/detail open` 으로 볼 원문(실패 지문 원문 등). */
+  stage(title: string, lines: string[]): void;
   clear(): void;
   close(): void;
 }
@@ -20,6 +24,10 @@ export function createDashboardDetailViewerRuntime(
 ): DashboardDetailViewerRuntime {
   let title = '';
   let lines: string[] = [];
+  const render = (): void => {
+    deps.project?.({ title, lines: [...lines] });
+    deps.requestRender();
+  };
 
   return {
     snapshot: () => ({ title, lines: [...lines] }),
@@ -27,12 +35,17 @@ export function createDashboardDetailViewerRuntime(
       title = nextTitle;
       lines = [...nextLines];
       deps.setOpen(true);
-      deps.requestRender();
+      render();
+    },
+    stage(nextTitle, nextLines) {
+      title = nextTitle;
+      lines = [...nextLines];
+      render();
     },
     clear() {
       title = '';
       lines = [];
-      deps.requestRender();
+      render();
     },
     close() {
       deps.setOpen(false);

package/src/dashboard/event-loop-stall-monitor.ts

@@ -1,4 +1,5 @@
 import { stripAnsi } from '../tui.js';
+import { matchFailureEvent, recordFailureSignatureMatch } from '../self-health/signatures.js';
 
 export interface EventLoopStallContext {
   streamingInFlight: boolean;
@@ -40,6 +41,9 @@ export function startEventLoopStallMonitor({
     previousTickAt = tickAt;
     if (lagMs >= thresholdMs) {
       log('tui.event-loop', 'stall', { lagMs, ...getContext() });
+      // 긴 정지(결함 #1·#14)는 실패 지문으로도 센다 — L3 자기 건강이 `tui.failure-signature` 로 읽는다.
+      const signature = matchFailureEvent({ category: 'tui.event-loop', event: 'stall', data: { lagMs } });
+      if (signature) recordFailureSignatureMatch(signature, 'event-loop', log);
     }
   }, intervalMs);
   timer.unref?.();

package/src/dashboard/goal-loop-thinking.ts

@@ -0,0 +1,16 @@
+// 대시보드 /goal 반복의 진행 표시 손잡이(TUI 결함 #5 · 10-14).
+//
+// 반복마다 그 턴의 finalizeTurn 이 손잡이를 stop() 한다. 다음 반복이 같은 손잡이를 다시 쓰면
+// 표시가 없거나(멈춘 손잡이) 멈춘 «Thinking…» 프레임이 이력에 남는다. 그래서 «다음 반복이 실제로
+// 시작될 때만» 새 손잡이를 단다 — 루프가 끝난 뒤에 달면 아무도 stop() 하지 않는 표시가 남는다.
+
+import type { ThinkingHandle } from '../thinking-line.js';
+
+/** 반복 `iteration`(0부터)의 손잡이. 0 은 입력 직후 단 표시를 그대로, 그 뒤는 새로 단다. */
+export function goalLoopIterationThinking(
+  iteration: number,
+  current: ThinkingHandle,
+  start: () => ThinkingHandle,
+): ThinkingHandle {
+  return iteration === 0 ? current : start();
+}

package/src/dashboard/hitl-boot.ts

@@ -12,6 +12,8 @@ export interface DashboardHitlBootDeps {
   debugLog: (scope: string, message: string) => void;
   isPushcutConfigured: () => boolean;
   pushWarningLine: (message: string) => void;
+  /** Minimal boot banner: hold the port-shift notice for `/status` instead of the transcript. */
+  holdWarningLine?: (message: string) => void;
   draw: () => void;
   registerBeforeExit: (cb: () => void) => void;
   warnConsole: (message: string) => void;
@@ -25,10 +27,13 @@ export function bootDashboardHitl(
     onPortShift: (info) => {
       deps.debugLog('hitl.port.shift', `${info.wanted} → ${info.actual}`);
       if (!deps.isPushcutConfigured()) return;
-      deps.pushWarningLine(
-        `[hitl] callback port ${info.wanted} was busy — bound ${info.actual} instead. `
-        + `Update your Pushcut Shortcut URL: http://127.0.0.1:${info.actual}`,
-      );
+      const message = `[hitl] callback port ${info.wanted} was busy — bound ${info.actual} instead. `
+        + `Update your Pushcut Shortcut URL: http://127.0.0.1:${info.actual}`;
+      if (deps.holdWarningLine) {
+        deps.holdWarningLine(message);
+        return;
+      }
+      deps.pushWarningLine(message);
       try { deps.draw(); } catch { /* ignore */ }
     },
   }).catch((err) => {