elanous 0.2.22 → 0.2.24

package/src/dashboard/first-screen-band.ts

@@ -1,6 +1,111 @@
+import { debug } from '../debug/log.js';
+import { resolveCurrentInstance } from '../instance/current.js';
+import { resolveDaemonEndpoint, type DaemonEndpoint } from '../nexus/daemon-endpoint.js';
+
+export type TuiDaemonLink =
+  | { readonly status: 'checking' }
+  | { readonly status: 'connected'; readonly address: string }
+  | { readonly status: 'absent' | 'unhealthy'; readonly startCommand: string }
+  | { readonly status: 'error'; readonly stage: 'endpoint' | 'health' | 'identity' };
+
+export interface TuiDaemonLinkDeps {
+  readonly endpoint?: () => Pick<DaemonEndpoint, 'baseUrl' | 'healthUrl' | 'source'> | null;
+  readonly probe?: (url: string, init: RequestInit) => Promise<Response>;
+  readonly universe?: () => 'test' | 'prod';
+  /** An explicitly chosen test root (`--test=<root>` / parent stamp); bare `--test` cannot name it. */
+  readonly testRoot?: () => string | undefined;
+  readonly observe?: (data: {
+    status: TuiDaemonLink['status'];
+    stage: 'endpoint' | 'health' | 'identity';
+    universe: 'test' | 'prod' | 'unknown';
+    source: 'registry' | 'lifecycle' | 'none';
+  }) => void;
+}
+
+// C0/C1 controls incl. ESC (ANSI sequences), newline and DEL.
+const CONTROL_CHARS = /[\u0000-\u001f\u007f-\u009f]/;
+
+function shellQuote(value: string): string {
+  return /^[A-Za-z0-9_./:=@%+-]+$/.test(value) ? value : `'${value.replaceAll("'", `'\\''`)}'`;
+}
+
+/** Probe the write target in this universe only; never use a watch/production fallback. */
+export async function resolveTuiDaemonLink(deps: TuiDaemonLinkDeps = {}): Promise<TuiDaemonLink> {
+  const universe = deps.universe ?? (() => resolveCurrentInstance().kind === 'test' ? 'test' : 'prod');
+  const observe = deps.observe ?? ((data) => debug.log('dashboard.tui-daemon-link', 'resolved', data));
+  let kind: 'test' | 'prod' | 'unknown' = 'unknown';
+  let source: 'registry' | 'lifecycle' | 'none' = 'none';
+  const finish = (result: TuiDaemonLink, stage: 'endpoint' | 'health' | 'identity'): TuiDaemonLink => {
+    try { observe({ status: result.status, stage, universe: kind, source }); } catch { /* observation is fail-soft */ }
+    return result;
+  };
+  try {
+    kind = universe();
+  } catch {
+    return finish({ status: 'error', stage: 'identity' }, 'identity');
+  }
+  let explicitRoot: string | undefined;
+  if (kind === 'test') {
+    try {
+      // An injected identity comes with its own root (or none); only the real identity reads the real root.
+      explicitRoot = (deps.testRoot ?? (deps.universe ? () => undefined : () => {
+        const resolution = resolveCurrentInstance();
+        return resolution.layer === 'explicit-flag' || resolution.layer === 'parent-stamp' ? resolution.root : undefined;
+      }))();
+    } catch {
+      return finish({ status: 'error', stage: 'identity' }, 'identity');
+    }
+  }
+  // The start command must name *this* universe: a custom test root is passed as one literal shell argument.
+  // A root with control characters cannot be shown safely (it would rewrite the screen): name no command at all.
+  const startCommand = kind === 'test'
+    ? explicitRoot ? (CONTROL_CHARS.test(explicitRoot) ? '' : `elanous --test=${shellQuote(explicitRoot)} nexus run --hmr`) : 'elanous --test nexus run --hmr'
+    : 'elanous nexus run --hmr';
+  let endpoint: ReturnType<NonNullable<TuiDaemonLinkDeps['endpoint']>>;
+  try {
+    endpoint = (deps.endpoint ?? (() => resolveDaemonEndpoint({ purpose: 'write' })))();
+    if (!endpoint) return finish({ status: 'absent', startCommand }, 'endpoint');
+    source = endpoint.source;
+  } catch {
+    return finish({ status: 'error', stage: 'endpoint' }, 'endpoint');
+  }
+  let address: string;
+  let healthAddress: string;
+  try {
+    const url = new URL(endpoint.baseUrl);
+    const healthUrl = new URL(endpoint.healthUrl);
+    if (!['http:', 'https:'].includes(url.protocol) || !url.hostname || url.username || url.password
+      || url.pathname !== '/' || url.search || url.hash || healthUrl.origin !== url.origin
+      || healthUrl.username || healthUrl.password || healthUrl.pathname !== '/v1/health'
+      || healthUrl.search || healthUrl.hash) {
+      return finish({ status: 'error', stage: 'endpoint' }, 'endpoint');
+    }
+    address = url.origin;
+    healthAddress = `${address}/v1/health`;
+  } catch {
+    return finish({ status: 'error', stage: 'endpoint' }, 'endpoint');
+  }
+  try {
+    const response = await (deps.probe ?? fetch)(healthAddress, { signal: AbortSignal.timeout(1500) });
+    if (!response.ok) return finish({ status: 'unhealthy', startCommand }, 'health');
+    const body: unknown = await response.json();
+    if (!body || typeof body !== 'object' || !('ok' in body) || body.ok !== true) {
+      return finish({ status: 'unhealthy', startCommand }, 'health');
+    }
+    // «Connected» is a claim about *this* universe: the daemon must state its universe and it must match.
+    if (!('testUniverse' in body) || typeof body.testUniverse !== 'boolean' || body.testUniverse !== (kind === 'test')) {
+      return finish({ status: 'error', stage: 'identity' }, 'identity');
+    }
+    return finish({ status: 'connected', address }, 'health');
+  } catch {
+    return finish({ status: 'error', stage: 'health' }, 'health');
+  }
+}
+
 export interface FirstScreenBandInput {
   readonly width: number;
   readonly daemon: boolean;
+  readonly link?: TuiDaemonLink;
   readonly pwa?: {
     readonly tailnet?: string | null;
     readonly lan?: string | null;
@@ -8,6 +113,31 @@ export interface FirstScreenBandInput {
   };
 }
 
+// The link row contains Hangul (two terminal cells per syllable); count display cells, not UTF-16 units.
+function cellWidth(text: string): number {
+  let width = 0;
+  for (const char of text) {
+    const point = char.codePointAt(0)!;
+    if (point >= 0x1100 && (point <= 0x115f || point >= 0x2329 && point <= 0x232a
+      || point >= 0x2e80 && point <= 0xa4cf || point >= 0xac00 && point <= 0xd7a3
+      || point >= 0xf900 && point <= 0xfaff || point >= 0xfe10 && point <= 0xfe6f
+      || point >= 0xff01 && point <= 0xff60 || point >= 0xffe0 && point <= 0xffe6
+      || point >= 0x1f000 && point <= 0x1ffff)) width += 2;
+    else if (point >= 0x300 && point <= 0x36f || point >= 0xfe00 && point <= 0xfe0f) continue;
+    else width++;
+  }
+  return width;
+}
+
+function fitCells(text: string, limit: number): string {
+  let result = '';
+  for (const char of text) {
+    if (cellWidth(result + char) > limit) break;
+    result += char;
+  }
+  return result;
+}
+
 /** A startup transcript band; never includes credentials or a partial address. */
 export function buildFirstScreenBand(input: FirstScreenBandInput): string[] {
   const width = Number.isFinite(input.width) ? Math.max(0, Math.floor(input.width)) : 0;
@@ -27,8 +157,28 @@ export function buildFirstScreenBand(input: FirstScreenBandInput): string[] {
   const fallback = input.pwa === undefined ? 'PWA: not checked' : 'PWA: unavailable';
   const addressLine = address ? `PWA: ${address}` : fallback;
 
+  const daemonLine = (() => {
+    const link = input.link;
+    if (!link) return `elanous | daemon: ${input.daemon ? 'online' : 'offline'}`;
+    if (link.status === 'checking') return 'elanous | 데몬: 확인 중';
+    if (link.status === 'connected') {
+      let address: string;
+      try {
+        const url = new URL(link.address);
+        address = ['http:', 'https:'].includes(url.protocol) && url.hostname ? url.origin : '';
+      } catch { address = ''; }
+      const line = `elanous | 데몬: 연결됨${address ? ` (${address})` : ''}`;
+      return cellWidth(line) <= width ? line : 'elanous | 데몬: 연결됨';
+    }
+    if (link.status === 'error') return `elanous | 데몬: ${link.stage} 조회 오류`;
+    const bare = `elanous | 데몬: ${link.status === 'absent' ? '없음' : '응답 없음'}`;
+    if (!link.startCommand || CONTROL_CHARS.test(link.startCommand)) return bare;
+    const line = `${bare} · 시작: ${link.startCommand}`;
+    return cellWidth(line) <= width ? line : bare;
+  })();
+
   return [
-    fit(`elanous | daemon: ${input.daemon ? 'online' : 'offline'}`),
+    input.link ? fitCells(daemonLine, width) : fit(daemonLine),
     addressLine.length <= width ? addressLine : fit(address ? 'PWA: address available' : fallback),
     fit('Type a message to begin | /help for commands'),
   ];

package/src/dashboard/index.ts

@@ -6,285 +6,31 @@
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
 import { join } from 'path';
 import { fileURLToPath } from 'node:url';
-import { createStaleInstallCheck, readCurrentInstalledCommit, readDashboardBootCommit, STALE_INSTALL_CHECK_INTERVAL_MS, versionedDashboardInstallDir } from './stale-install-check.js';
+import { createStaleInstallCheck, formatStaleInstallNotice, readCurrentInstalledCommit, readDashboardBootCommit, STALE_INSTALL_CHECK_INTERVAL_MS, versionedDashboardInstallDir } from './stale-install-check.js';
 import { spawn, spawnSync } from 'node:child_process';
 import { $ } from 'bun';
 import { LOCAL_SKILLS_DIR, SERVICE_NAMES, DATA_DIR, OBSIDIAN_VAULT } from '../config.js';
 import { dispatchDashboardSessionRuntimeTool } from './session-runtime-dispatch.js';
-import { buildAdRunSetup } from '../ad-pipeline/ad-run-setup.js';
 import { nextChatScrollOffset } from '../chat/log-scroll-key.js';
-import type { CommandRunner } from '../ad-pipeline/higgsfield-backend.js';
-import type { ShootRunOptions } from '../ad-pipeline/shoot-run.js';
-import type { QcThresholds } from '../ad-pipeline/qc.js';
-import { elanousStateRoot } from '../autopilot/state-paths.js';
 import { suggestProjectForFolder } from '../project/project-store.js';
 import { createProjectSuggester } from '../project/project-suggestion.js';
-
-const dashboardDefaultShootRunOptions: Required<Pick<ShootRunOptions, 'pollIntervalMs' | 'maxPollsPerJob' | 'submitStaggerMs'>> = {
-  pollIntervalMs: 3_000,
-  // 2026-09-12 seedance_2_0 measured 330–400s; 174 polls = 522s, leaving 402s after six 20s staggers.
-  maxPollsPerJob: 174,
-  submitStaggerMs: 20_000,
-};
-
-/**
- * ⛔ `src/ad-pipeline/ad-run-setup.ts` 의 `optionalProductionInputs` «사본»이다 — 그 목록은 export 가 아니다.
- * 여기서 다시 세는 이유: 이 파일이 `buildAdRunSetup` «뒤»에 `assemblyMaterials` 를 덧붙이므로,
- * 그 함수가 «입력» 기준으로 낸 목록은 최종 `production` 과 어긋난다(`#17880`).
- * ⚠️ 사본이라 «늙는다» — `src/dashboard/index.test.ts` 가 권위 목록과 같은지 단언한다.
- */
-export const dashboardOptionalProductionInputs = [
-  'assembly',
-  'assemblyMaterials',
-  'captionFontPath',
-  'musicBedPath',
-  'qcThresholds',
-  'voiceover',
-  'soundtrack',
-  'referenceAssets',
-  'shootRunOptions',
-  'ground',
-  'invariants',
-] as const;
-
-export interface DashboardAdAssetPreset {
-  readonly captionFontPath?: string;
-  readonly musicBedPath?: string;
-  readonly referenceAssets?: Readonly<Record<string, string[]>>;
-  readonly shootRunOptions?: ShootRunOptions;
-  readonly qcThresholds?: QcThresholds;
-}
-
-/** Operator-owned, instance-scoped optional asset preset; never a repository asset path. */
-export function dashboardAdAssetPresetPath(stateRoot = elanousStateRoot()): string {
-  return join(stateRoot, 'ad-assets.json');
-}
-
-/** Reads optional operator-owned asset paths without inventing local defaults. */
-export function loadDashboardAdAssetPreset(path: string): DashboardAdAssetPreset {
-  let raw: string;
-  try {
-    raw = readFileSync(path, 'utf8');
-  } catch (error) {
-    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return {};
-    throw new Error(`dashboard ad asset preset unreadable at ${path}: ${error instanceof Error ? error.message : String(error)}`);
-  }
-
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(raw);
-  } catch (error) {
-    throw new Error(`dashboard ad asset preset malformed at ${path}: ${error instanceof Error ? error.message : String(error)}`);
-  }
-  if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
-    throw new Error(`dashboard ad asset preset malformed at ${path}: expected an object`);
-  }
-
-  const preset = parsed as Record<string, unknown>;
-  for (const key of ['captionFontPath', 'musicBedPath'] as const) {
-    if (preset[key] !== undefined && typeof preset[key] !== 'string') {
-      throw new Error(`dashboard ad asset preset malformed at ${path}: ${key} must be a string`);
-    }
-  }
-  if (preset.referenceAssets !== undefined && (
-    preset.referenceAssets === null
-    || typeof preset.referenceAssets !== 'object'
-    || Array.isArray(preset.referenceAssets)
-    || Object.values(preset.referenceAssets).some((value) => !Array.isArray(value) || value.some((entry) => typeof entry !== 'string'))
-  )) {
-    throw new Error(`dashboard ad asset preset malformed at ${path}: referenceAssets must be a record of string arrays`);
-  }
-  if (preset.shootRunOptions !== undefined && (
-    preset.shootRunOptions === null
-    || typeof preset.shootRunOptions !== 'object'
-    || Array.isArray(preset.shootRunOptions)
-  )) {
-    throw new Error(`dashboard ad asset preset malformed at ${path}: shootRunOptions must be an object`);
-  }
-  const shootRunOptions = preset.shootRunOptions as Record<string, unknown> | undefined;
-  for (const key of ['pollIntervalMs', 'maxPollsPerJob', 'maxPollElapsedMs', 'submitStaggerMs', 'submitRetries'] as const) {
-    if (shootRunOptions?.[key] !== undefined && (typeof shootRunOptions[key] !== 'number' || !Number.isFinite(shootRunOptions[key]))) {
-      throw new Error(`dashboard ad asset preset malformed at ${path}: shootRunOptions.${key} must be a finite number`);
-    }
-  }
-  if (preset.qcThresholds !== undefined && (
-    preset.qcThresholds === null
-    || typeof preset.qcThresholds !== 'object'
-    || Array.isArray(preset.qcThresholds)
-  )) {
-    throw new Error(`dashboard ad asset preset malformed at ${path}: qcThresholds must be an object`);
-  }
-  const qcThresholds = preset.qcThresholds as Record<string, unknown> | undefined;
-  for (const key of ['dialogueLufsTolerance', 'colorDistance', 'frameDiffVariance'] as const) {
-    if (qcThresholds?.[key] !== undefined && (typeof qcThresholds[key] !== 'number' || !Number.isFinite(qcThresholds[key]))) {
-      throw new Error(`dashboard ad asset preset malformed at ${path}: qcThresholds.${key} must be a finite number`);
-    }
-  }
-  if (qcThresholds?.durationRanges !== undefined && (
-    qcThresholds.durationRanges === null
-    || typeof qcThresholds.durationRanges !== 'object'
-    || Array.isArray(qcThresholds.durationRanges)
-  )) {
-    throw new Error(`dashboard ad asset preset malformed at ${path}: qcThresholds.durationRanges must be an object`);
-  }
-  const durationRanges = qcThresholds?.durationRanges as Record<string, unknown> | undefined;
-  for (const scope of ['cut', 'master'] as const) {
-    if (durationRanges?.[scope] !== undefined && (
-      durationRanges[scope] === null
-      || typeof durationRanges[scope] !== 'object'
-      || Array.isArray(durationRanges[scope])
-    )) {
-      throw new Error(`dashboard ad asset preset malformed at ${path}: qcThresholds.durationRanges.${scope} must be an object`);
-    }
-    const range = durationRanges?.[scope] as Record<string, unknown> | undefined;
-    if (range !== undefined) {
-      const minimumSeconds = range.minimumSeconds;
-      const maximumSeconds = range.maximumSeconds;
-      if (typeof minimumSeconds !== 'number' || !Number.isFinite(minimumSeconds)) {
-        throw new Error(`dashboard ad asset preset malformed at ${path}: qcThresholds.durationRanges.${scope}.minimumSeconds must be a finite number`);
-      }
-      if (typeof maximumSeconds !== 'number' || !Number.isFinite(maximumSeconds)) {
-        throw new Error(`dashboard ad asset preset malformed at ${path}: qcThresholds.durationRanges.${scope}.maximumSeconds must be a finite number`);
-      }
-      if (minimumSeconds > maximumSeconds) {
-        throw new Error(`dashboard ad asset preset malformed at ${path}: qcThresholds.durationRanges.${scope}.minimumSeconds must be less than or equal to maximumSeconds`);
-      }
-    }
-  }
-  return {
-    ...(typeof preset.captionFontPath === 'string' ? { captionFontPath: preset.captionFontPath } : {}),
-    ...(typeof preset.musicBedPath === 'string' ? { musicBedPath: preset.musicBedPath } : {}),
-    ...(preset.referenceAssets === undefined ? {} : { referenceAssets: preset.referenceAssets as Record<string, string[]> }),
-    ...(shootRunOptions === undefined ? {} : { shootRunOptions: shootRunOptions as ShootRunOptions }),
-    ...(qcThresholds === undefined ? {} : { qcThresholds: qcThresholds as QcThresholds }),
-  };
-}
-
-export const dashboardAdCommandRunner: CommandRunner = {
-  async run(argv, options) {
-    const process = Bun.spawn([...argv], {
-      stdout: 'pipe',
-      stderr: 'pipe',
-      ...(options?.timeoutMs ? { timeout: options.timeoutMs } : {}),
-    });
-    const [raw, stderr, exitCode] = await Promise.all([
-      new Response(process.stdout).bytes(),
-      new Response(process.stderr).text(),
-      process.exited,
-    ]);
-    return { stdout: new TextDecoder().decode(raw), stderr, exitCode, raw };
-  },
-};
-
-export function createDashboardAdRunSetupFactory(input: {
-  readonly home: string;
-  readonly date: string;
-  readonly contractsJson: string;
-  readonly runner: CommandRunner;
-  readonly assetPresetPath?: string;
-}): (allowSpend: boolean) => ReturnType<typeof buildAdRunSetup> {
-  let runSequence = 0;
-  let activeRunSlug: string | undefined;
-
-  return (allowSpend) => {
-    if (!allowSpend) {
-      const runStart = new Date();
-      const time = [runStart.getHours(), runStart.getMinutes(), runStart.getSeconds()]
-        .map((part) => String(part).padStart(2, '0'))
-        .join('');
-      activeRunSlug = `dashboard-ad-${time}-${++runSequence}`;
-    }
-    const slug = activeRunSlug ?? (() => {
-      const runStart = new Date();
-      const time = [runStart.getHours(), runStart.getMinutes(), runStart.getSeconds()]
-        .map((part) => String(part).padStart(2, '0'))
-        .join('');
-      return `dashboard-ad-${time}-${++runSequence}`;
-    })();
-    const assetPreset = input.assetPresetPath === undefined ? {} : loadDashboardAdAssetPreset(input.assetPresetPath);
-    let setup = buildAdRunSetup({
-      home: input.home,
-      slug,
-      date: input.date,
-      version: 1,
-      aspect: '9x16',
-      contractsJson: input.contractsJson,
-      runner: input.runner,
-      ...assetPreset,
-      referenceAssets: assetPreset.referenceAssets ?? {},
-      shootRunOptions: { ...dashboardDefaultShootRunOptions, ...assetPreset.shootRunOptions },
-      soundtrack: input.runner,
-      voiceover: { runner: input.runner, lines: [] },
-      allowSpend,
-    });
-    if (!('error' in setup) && setup.production) {
-      const production = {
-        ...setup.production,
-        assemblyMaterials: { options: { workDir: setup.workDir, outputName: setup.outputName } },
-      };
-      setup = {
-        ...setup,
-        production,
-        missingProductionInputs: dashboardOptionalProductionInputs.filter((key) => production[key] === undefined),
-      };
-    }
-    return setup;
-  };
-}
-
-/** Builds the /ad runtime bindings used by showDashboard for each invocation's spend intent. */
-export function createDashboardAdRunSetupBindings(
-  buildDashboardAdRunSetup: ReturnType<typeof createDashboardAdRunSetupFactory>,
-) {
-  let adRunSetup: ReturnType<typeof buildAdRunSetup> | undefined;
-  let outputSetupError: string | undefined;
-  try {
-    adRunSetup = buildDashboardAdRunSetup(false);
-    outputSetupError = 'error' in adRunSetup ? adRunSetup.error : undefined;
-  } catch (error) {
-    outputSetupError = error instanceof Error ? error.message : String(error);
-  }
-
-  return {
-    production: adRunSetup && !('error' in adRunSetup) ? adRunSetup.production : undefined,
-    productionForSpend: (allowSpend: boolean) => {
-      try {
-        const setup = buildDashboardAdRunSetup(allowSpend);
-        if ('error' in setup) {
-          outputSetupError = setup.error;
-          return undefined;
-        }
-        return setup.production;
-      } catch (error) {
-        outputSetupError = error instanceof Error ? error.message : String(error);
-        return undefined;
-      }
-    },
-    missingProductionInputs: adRunSetup && !('error' in adRunSetup) ? adRunSetup.missingProductionInputs : undefined,
-    get outputSetupError() {
-      return outputSetupError;
-    },
-  };
-}
-
-/** Connects the dashboard's setup state to the actual /ad runtime. */
-export function createDashboardAdSlashRuntime(
-  input: Omit<DashboardAdSlashRuntimeDeps, 'production' | 'productionForSpend' | 'missingProductionInputs' | 'outputSetupError'> & {
-    readonly adRunSetupBindings?: ReturnType<typeof createDashboardAdRunSetupBindings>;
-    readonly adRunSetupError?: string;
-  },
-): DashboardAdSlashRuntime {
-  const { adRunSetupBindings, adRunSetupError, ...deps } = input;
-  return createAdSlashRuntime({
-    ...deps,
-    production: adRunSetupBindings?.production,
-    productionForSpend: adRunSetupBindings?.productionForSpend,
-    missingProductionInputs: adRunSetupBindings?.missingProductionInputs,
-    get outputSetupError() {
-      return adRunSetupBindings?.outputSetupError ?? adRunSetupError;
-    },
-  });
-}
+import {
+  createDashboardAdRunSetupBindings,
+  createDashboardAdRunSetupFactory,
+  createDashboardAdSlashRuntime,
+  dashboardAdAssetPresetPath,
+  dashboardAdCommandRunner,
+} from './ad-run-setup-bindings.js';
+export {
+  dashboardOptionalProductionInputs,
+  type DashboardAdAssetPreset,
+  dashboardAdAssetPresetPath,
+  loadDashboardAdAssetPreset,
+  dashboardAdCommandRunner,
+  createDashboardAdRunSetupFactory,
+  createDashboardAdRunSetupBindings,
+  createDashboardAdSlashRuntime,
+} from './ad-run-setup-bindings.js';
 
 export interface DashboardGlobalKeyRegistration {
   id: string;
@@ -896,7 +642,7 @@ import { inspectActiveProvider } from '../provider-summary.js';
 import { activeCodexAccountView } from '../oauth/codex-account-store.js';
 import { buildDashboardStatusLines } from './dashboard-status-lines.js';
 import { readSlashContextNow, seatsNowLine } from '../context-bus/context-now-surfaces.js';
-import { buildFirstScreenBand } from './first-screen-band.js';
+import { buildFirstScreenBand, resolveTuiDaemonLink, type TuiDaemonLink } from './first-screen-band.js';
 import { runNexusShow, type NexusShowResult } from '../cli/nexus-show.js';
 import {
   workingDirSegment, sessionCwdSegment, modelSegment, gitSegment,
@@ -1005,11 +751,7 @@ import { createDashboardControlSignalSlashRuntime } from './control-signal-slash
 import { createDashboardBrowserCdpSlashRuntime } from './browser-cdp-slash-runtime.js';
 import { collectGroundingFactsViaCdp } from '../product-grounding/cdp-collect.js';
 import { createDashboardSimSlashRuntime } from './sim-slash-runtime.js';
-import {
-  createDashboardAdSlashRuntime as createAdSlashRuntime,
-  type DashboardAdSlashRuntime,
-  type DashboardAdSlashRuntimeDeps,
-} from './ad-slash-runtime.js';
+import type { DashboardAdSlashRuntime } from './ad-slash-runtime.js';
 import { openDashboardLocalSimulationWebCockpit } from './sim-web-cockpit-runtime.js';
 import { createDashboardCompanionFeedbackRuntime } from './companion-feedback-runtime.js';
 import { resolveDashboardMediaSlash } from './media-slash-runtime.js';
@@ -2128,15 +1870,22 @@ export function renderDashboardFirstScreenBand(input: {
   readonly draw: () => void;
   readonly observe: (data: { daemon: boolean; hasPwa: boolean; hasTailnet: boolean }) => void;
   readonly show?: () => Promise<Pick<NexusShowResult, 'status' | 'urls'>>;
+  readonly daemonLink?: () => Promise<TuiDaemonLink>;
 }): Promise<void> {
   if (input.history.some((message) => message.role !== 'system')) return Promise.resolve();
-  const band = buildFirstScreenBand({ width: input.width, daemon: false });
+  const band = buildFirstScreenBand({ width: input.width, daemon: false, link: { status: 'checking' } });
   input.lines.unshift(...band);
+  const daemonLink = input.daemonLink ?? resolveTuiDaemonLink;
+  const linkPending = Promise.resolve().then(() => daemonLink()).catch((): TuiDaemonLink => ({ status: 'error', stage: 'health' })).then((link) => {
+    if (input.lines[0] !== band[0]) return;
+    input.lines[0] = buildFirstScreenBand({ width: input.width, daemon: false, link })[0]!;
+    try { input.draw(); } catch { /* screen may have closed */ }
+  });
   const show = input.show ?? (() => runNexusShow({ format: 'json', out: { log: () => {}, error: () => {} } }));
   const observe = (data: { daemon: boolean; hasPwa: boolean; hasTailnet: boolean }): void => {
     try { input.observe(data); } catch { /* observation cannot interrupt the transcript */ }
   };
-  return Promise.resolve().then(show).then((result) => {
+  const pwaPending = Promise.resolve().then(show).then((result) => {
     const daemon = result.status !== 'absent';
     const pwa = result.urls?.pwa;
     const hasPwa = !!pwa;
@@ -2148,6 +1897,7 @@ export function renderDashboardFirstScreenBand(input: {
   }).catch(() => {
     observe({ daemon: false, hasPwa: false, hasTailnet: false });
   });
+  return Promise.all([linkPending, pwaPending]).then(() => {});
 }
 
 export async function showDashboard(opts: ShowDashboardOptions = {}): Promise<DashboardAction> {
@@ -4361,13 +4111,27 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     now: Date.now,
   });
   if (versionDir) {
+    let staleNoticeIndex = -1;
+    let staleNoticeLine: string | undefined;
+    let staleNoticeCount = 0;
     const checkInstall = (): void => {
       const result = staleInstallCheck.check();
       debug.log('dashboard.version', 'install-check', {
         state: result.state, bootCommit: result.bootCommit, installedCommit: result.installedCommit,
       });
       if (staleInstallCheck.shouldNotify(result)) {
-        chatLines.push(C.warning(`elanous 가 새 판으로 바뀌었다 (${result.bootCommit!.slice(0, 7)} → ${result.installedCommit!.slice(0, 7)}) · TUI 를 다시 띄워라`));
+        staleNoticeCount++;
+        const notice = C.warning(formatStaleInstallNotice(result, staleNoticeCount));
+        if (chatLines[staleNoticeIndex] !== staleNoticeLine || staleNoticeLine === undefined) {
+          staleNoticeIndex = staleNoticeLine === undefined ? -1 : chatLines.indexOf(staleNoticeLine);
+        }
+        if (staleNoticeIndex < 0) {
+          chatLines.push(notice);
+          staleNoticeIndex = chatLines.length - 1;
+        } else {
+          chatLines[staleNoticeIndex] = notice;
+        }
+        staleNoticeLine = notice;
         chatScrollOffset = -1;
         try { draw(); } catch { /* TUI torn down */ }
       }

package/src/dashboard/slash-runtime/dashboard-handlers.ts

@@ -343,7 +343,7 @@ import { terminalModalRouter } from '../input/terminal-modal-router.js';
 import { termSize, stripAnsi } from '../../tui.js';
 import { SLASH_COMMANDS } from '../../chat/index.js';
 import { buildEssentialHelpLines } from './help-from-registry.js';
-import { HUMAN_MODEL_WORDS, MODEL_CODE_NAMES, modelChangeLine, modelOverviewLines, resolveModelChoice } from './model-choices.js';
+import { HUMAN_MODEL_WORDS, MODEL_CODE_NAMES, humanWordForModel, modelChangeLine, modelOverviewLines, resolveModelChoice } from './model-choices.js';
 import type { FoldMode } from '../../log-entry.js';
 import { resolveDashboardChatMainLogCommand } from '../input/chat-main-log-command.js';
 import {
@@ -6197,8 +6197,10 @@ export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps, decideLedg
     const curModel = curCfg.llm.model;
     const curReasoning = effectiveReasoningLevel(curCfg.llm, curProvider, curModel);
     if (!arg) {
-      const [now, codes] = modelOverviewLines(curProvider, curModel, curReasoning);
-      ctx.chatLines.push(now);
+      const [, codes] = modelOverviewLines(curProvider, curModel, curReasoning);
+      // A model outside the 빠름/보통/깊음 map (codename or custom) says so explicitly instead of dropping the tier slot.
+      const tierName = humanWordForModel(curProvider, curModel, curReasoning) ?? '단계 밖';
+      ctx.chatLines.push(`지금: ${curModel?.trim() || '기본 모델'} (${tierName} · 생각 ${curReasoning}) · 고르기: /model ${HUMAN_MODEL_WORDS.join(' | ')}`);
       ctx.chatLines.push(ctx.muted(codes));
       ctx.setChatScrollOffset(-1);
       return;

package/src/dashboard/stale-install-check.ts

@@ -12,6 +12,22 @@ export type StaleInstallResult = {
 
 export const STALE_INSTALL_CHECK_INTERVAL_MS = 60_000;
 
+/**
+ * Builds the command that relaunches the TUI on the same daemon session: `elanous --resume <id>` boots the dashboard,
+ * loads that session (ACP session/load) and replays its turns (src/index.ts resumeSessionId · dashboard acp-boot).
+ * The user-facing hint and its key binding land with the dashboard wiring slice (`r` is the render toggle today).
+ * Intentional wiring boundary: the dashboard owns the key binding and executes this command;
+ * this scoped helper only constructs it and does not spawn a child process.
+ */
+export function buildStaleInstallRelaunchCommand(sessionId: string): string {
+  return `elanous --resume ${JSON.stringify(sessionId)}`;
+}
+
+export function formatStaleInstallNotice(result: StaleInstallResult, notifiedCount: number): string {
+  const message = `새 판이 깔렸습니다 (부팅 판 ${result.bootCommit!.slice(0, 7)} → 지금 ${result.installedCommit!.slice(0, 7)}) · TUI 를 다시 띄우면 새 판으로 돕니다`;
+  return notifiedCount >= 2 ? `${message} · 이 TUI 가 뜬 뒤 ${notifiedCount}번째 새 판` : message;
+}
+
 /** Identify the immutable installed version containing this module, never the session cwd. */
 export function versionedDashboardInstallDir(
   codeRoot: string,
@@ -21,8 +37,14 @@ export function versionedDashboardInstallDir(
     const packageRoot = realpathSync(codeRoot);
     if (basename(packageRoot) !== 'elanous' || basename(dirname(packageRoot)) !== 'node_modules') return undefined;
     const versionDir = dirname(dirname(packageRoot));
-    if (dirname(versionDir) !== resolve(installRoot, 'versions')) return undefined;
-    return versionDir;
+    let canonicalInstallRoot: string;
+    try { canonicalInstallRoot = realpathSync(installRoot); }
+    catch { canonicalInstallRoot = resolve(installRoot); }
+    if (dirname(versionDir) !== join(canonicalInstallRoot, 'versions')) return undefined;
+    const requestedVersionDir = dirname(dirname(resolve(codeRoot)));
+    return dirname(requestedVersionDir) === resolve(installRoot, 'versions')
+      && realpathSync(requestedVersionDir) === versionDir
+      ? requestedVersionDir : versionDir;
   } catch {
     return undefined;
   }

package/src/dashboard/turn-stream-formatter.ts

@@ -20,6 +20,7 @@ import type { ToolRenderModel } from '../chat/tool-render/types.js';
 import { toolOperationKind, type FoldMode } from '../log-entry.js';
 import { stripAnsi } from '../tui.js';
 import type { TurnStreamPresentationEvent } from './turn-stream-presentation-applier.js';
+import { buildFoldedTailLine, splitNoSynthesisTail } from './chat-fold.js';
 
 /** Drop leading/trailing blank (whitespace-only, ANSI-stripped) rows
  *  from a rendered assistant block. Codex-family models frequently
@@ -181,6 +182,7 @@ export function createTurnStreamFormatter(
   const toolArgsByCallId = new Map<string, Record<string, unknown>>();
   const nonGenericCallIds = new Set<string>();
   let toolCallCount = 0;
+  let noSynthesisTailCount = 0;
 
   const emitAssistantBlock = (): void => {
     deps.thinking.update('Streaming');
@@ -219,6 +221,29 @@ export function createTurnStreamFormatter(
       }
       if (chunk === '') {
         // Path 2 — authoritative replacement (W5-E/F/G force-synthesis).
+        const split = splitNoSynthesisTail(accumulated);
+        if (split) {
+          perRoundText = split.head;
+          emitAssistantBlock();
+          closeRound();
+          deps.emit({ type: 'assistant.commit' });
+          const callId = `no-synthesis-tail-${++noSynthesisTailCount}`;
+          const expandedLines = trimBlankEdges(
+            deps.formatResponse(split.tail, deps.termCols() - 6, deps.wrapOpts),
+          ).map(deps.text);
+          const collapsedLines = [buildFoldedTailLine(expandedLines.length)];
+          if (debug.enabled) {
+            debug.log('dashboard.chat.stream', 'formatter.noSynthesisTail.folded', {
+              callId,
+              headLen: split.head.length,
+              tailLen: split.tail.length,
+              expandedLineCount: expandedLines.length,
+            });
+          }
+          deps.emit({ type: 'tool.appendBlock', callId, lines: collapsedLines, args: {} });
+          deps.emit({ type: 'tool.replaceBlock', callId, collapsedLines, expandedLines });
+          return;
+        }
         perRoundText = accumulated;
       } else {
         // Path 3 — streaming delta. accumulated 무시 (cross-turn fullText).