elanous 0.2.4 → 0.2.5

package/src/cli/release-cli.ts

@@ -18,8 +18,11 @@ import { tmpdir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 import type { Command } from 'commander';
 import { debug } from '../debug/log.js';
-import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { effectiveInstanceRoot, releaseLedgerRoot } from '../instance/resolve.js';
+import { getElanousConfigDirOverride } from '../elanous-config-dir.js';
 import { envLiteral } from '../platform/env-literal.js';
+import { userConfigPath } from '../user-config.js';
+import { addItem, devVersion, listChecklist, removeItem, seedFromRoadmap, setItem, summarizeChecklist, type ChecklistStatus } from '../release-loop/checklist.js';
 
 export const DEFAULT_PUBLIC_REPO = 'ElanvitalAI/elanous';
 const SEMVER = /^\d+\.\d+\.\d+(?:-(?:rc|alpha|beta)\.\d+)?$/;
@@ -257,7 +260,7 @@ export async function tagRelease(opts: TagOptions, run: Runner = defaultRunner):
   return { tagged: true };
 }
 
-export async function publishRelease(opts: { dir: string; notesFile: string; yes?: boolean; repoRoot?: string; instanceRoot?: string; log?: (l: string) => void }, run: Runner = defaultRunner): Promise<{ published: boolean; steps: PublishStep[] }> {
+export async function publishRelease(opts: { dir: string; notesFile: string; yes?: boolean; repoRoot?: string; instanceRoot?: string; ledgerRoot?: string; log?: (l: string) => void }, run: Runner = defaultRunner): Promise<{ published: boolean; steps: PublishStep[] }> {
   const log = opts.log ?? ((l: string) => console.log(l));
   const m = readManifest(opts.dir);
   if (!existsSync(opts.notesFile)) throw new Error(`릴리스 본문 파일이 없다: ${opts.notesFile} (초안: ${m.notesDraft ?? 'release notes --from <ref>'})`);
@@ -273,11 +276,24 @@ export async function publishRelease(opts: { dir: string; notesFile: string; yes
   checkSourceTag(m.version, m.sourceCommit, repoRoot, run);
   for (const s of steps) must(run(s.command, s.args, s.cwd), s.what);
   applySourceTag(m.version, m.sourceCommit, repoRoot, run);
-  const recordDir = join(opts.instanceRoot ?? effectiveInstanceRoot(), 'release', m.version);
-  mkdirSync(recordDir, { recursive: true });
-  const record = join(recordDir, 'release.json');
-  writeFileSync(record, `${JSON.stringify({ ...m, publishedAt: new Date().toISOString() }, null, 2)}\n`, { mode: 0o600 });
-  chmodSync(record, 0o600);
+  // 판 기록은 이 우주 ⊕ 기계 단위 릴리스 원장(`releaseLedgerRoot()` · 다음 판 gate 가 기준선으로 읽는 자리) 두 곳에 남긴다.
+  // 공개는 이미 끝났으니 한 자리가 실패해도 다른 자리는 쓰고, 실패는 숨기지 않고 알린다(되돌릴 수 없는 단계 뒤라 던지지 않는다).
+  const body = `${JSON.stringify({ ...m, publishedAt: new Date().toISOString() }, null, 2)}\n`;
+  // 설정 디렉터리를 명시로 바꿔 끼운 경우(시험·`--config-dir`)는 그 우주만 — 다른 원장으로 넘지 않는다(gate 의 `releaseLedgerRoot` 와 같은 규칙).
+  const roots = getElanousConfigDirOverride() ? [effectiveInstanceRoot()]
+    : [...new Set([opts.instanceRoot ?? effectiveInstanceRoot(), opts.ledgerRoot ?? releaseLedgerRoot()])];
+  for (const root of roots) {
+    const record = join(root, 'release', m.version, 'release.json');
+    try {
+      mkdirSync(dirname(record), { recursive: true });
+      const temp = `${record}.${process.pid}.tmp`;
+      writeFileSync(temp, body, { mode: 0o600 });
+      chmodSync(temp, 0o600);
+      renameSync(temp, record);
+    } catch (error) {
+      log(`⚠ 판 기록을 못 남겼다: ${record} — ${error instanceof Error ? error.message : String(error)} (공개는 끝났다 · 다음 판 gate 는 기준선을 다시 스윕한다)`);
+    }
+  }
   log(`✅ 공개: https://github.com/${m.publicRepo}/releases/tag/${m.tag} — 이어서 \`elanous release verify --version ${m.version}\``);
   return { published: true, steps };
 }
@@ -436,8 +452,79 @@ async function jsonAction<T>(json: boolean | undefined, body: (log: (l: string)
   }
 }
 
+function checklistCodenames(): Record<string, string> {
+  const path = getElanousConfigDirOverride() ? join(effectiveInstanceRoot(), 'config.json') : userConfigPath();
+  if (!existsSync(path)) return {};
+  const raw = JSON.parse(readFileSync(path, 'utf8')) as { release?: { codenames?: Record<string, string> } };
+  return raw.release?.codenames ?? {};
+}
+
+function checklistVersion(input: string | undefined, codenames: Record<string, string>): string {
+  const v = input ?? devVersion().replace(/-dev\.\d+$/, '');
+  const resolved = isReleaseVersion(v) ? v : Object.entries(codenames).find(([, name]) => name === v)?.[0] ?? v;
+  if (!isReleaseVersion(resolved)) throw new Error(`체크리스트 판 또는 별칭이 아니다: ${v}`);
+  return resolved;
+}
+
+function checklistOutput(v: string, codenames: Record<string, string>, mode: 'list' | 'status', json?: boolean): void {
+  const data = listChecklist(v);
+  const summary = summarizeChecklist(data);
+  const result = { ...data, codename: codenames[v] ?? '', ...summary };
+  if (json) { console.log(JSON.stringify(result)); return; }
+  console.log(`${v}${result.codename ? ` (${result.codename})` : ''} · 공개 ${data.released || '없음'} · 개발 ${data.dev}`);
+  if (mode === 'list') {
+    for (const item of data.items) console.log(`${({ green: '🟢', yellow: '🟡', red: '🔴', done: '✅' } as const)[item.status]} ${item.id} ${item.title}${item.owner ? ` · ${item.owner}` : ''}`);
+  } else {
+    console.log(`🟢 ${summary.green} · 🟡 ${summary.yellow} · 🔴 ${summary.red} · ✅ ${summary.done}`);
+    console.log(`🔴 칸: ${summary.blocked.join(', ') || '없음'}`);
+    console.log(`담당별: ${Object.entries(summary.byOwner).map(([owner, count]) => `${owner} ${count}`).join(' · ') || '없음'}`);
+  }
+}
+
 export function registerReleaseCommands(program: Command): void {
   const release = program.command('release').description('공개 배포 한 판 — prepare(로컬) → publish(--yes) → verify (docs/manual/MANUAL-versioning-and-release-2026-09-25.md)');
+  const checklist = release.command('checklist').description('판별 확인표 조회·갱신')
+    .option('--version <v>', '판 또는 별칭(기본: package.json 의 개발판에서 -dev.N 제거)')
+    .option('--json', '결과 JSON');
+  const context = (cmd: Command) => {
+    const opts = { ...(cmd.parent?.opts() as { version?: string; json?: boolean }), ...(cmd.opts() as { version?: string; json?: boolean }) };
+    const codenames = checklistCodenames();
+    return { version: checklistVersion(opts.version, codenames), codenames, json: opts.json };
+  };
+  const withContext = (cmd: Command) => cmd.option('--version <v>', '판 또는 별칭').option('--json', '결과 JSON');
+  withContext(checklist.command('list').description('모든 칸')).action((_opts: unknown, cmd: Command) => {
+    const { version, codenames, json } = context(cmd);
+    checklistOutput(version, codenames, 'list', json);
+  });
+  withContext(checklist.command('status').description('상태 요약')).action((_opts: unknown, cmd: Command) => {
+    const { version, codenames, json } = context(cmd);
+    checklistOutput(version, codenames, 'status', json);
+  });
+  withContext(checklist.command('add <id> <title>').description('칸 추가')).option('--owner <owner>', '담당').action((id: string, title: string, opts: { owner?: string }, cmd: Command) => {
+    const { version, json } = context(cmd);
+    const data = addItem(version, { id, title, ...(opts.owner !== undefined ? { owner: opts.owner } : {}) });
+    if (json) console.log(JSON.stringify(data)); else console.log(`✅ ${id} 추가`);
+  });
+  withContext(checklist.command('set <id>').description('칸 상태·근거·담당 갱신'))
+    .option('--status <status>', 'green|yellow|red|done').option('--evidence <evidence>', '근거').option('--owner <owner>', '담당')
+    .action((id: string, opts: { status?: string; evidence?: string; owner?: string }, cmd: Command) => {
+      const { version, json } = context(cmd);
+      if (opts.status !== undefined && !['green', 'yellow', 'red', 'done'].includes(opts.status)) throw new Error(`잘못된 상태: ${opts.status}`);
+      if (opts.status === undefined && opts.evidence === undefined && opts.owner === undefined) throw new Error('갱신할 칸을 지정하라');
+      const data = setItem(version, id, { ...(opts.status !== undefined ? { status: opts.status as ChecklistStatus } : {}), ...(opts.evidence !== undefined ? { evidence: opts.evidence } : {}), ...(opts.owner !== undefined ? { owner: opts.owner } : {}) }, process.env.ELANOUS_TRACK || 'cli');
+      if (json) console.log(JSON.stringify(data)); else console.log(`✅ ${id} 갱신`);
+    });
+  withContext(checklist.command('rm <id>').description('칸 삭제')).action((id: string, _opts: unknown, cmd: Command) => {
+    const { version, json } = context(cmd);
+    const data = removeItem(version, id, process.env.ELANOUS_TRACK || 'cli');
+    if (json) console.log(JSON.stringify(data)); else console.log(`✅ ${id} 삭제`);
+  });
+  withContext(checklist.command('seed').description('마크다운 로드맵에서 빈 칸 들이기')).requiredOption('--from <file>', '로드맵 파일')
+    .action((opts: { from: string }, cmd: Command) => {
+      const { version, json } = context(cmd);
+      const data = seedFromRoadmap(version, readFileSync(opts.from, 'utf8'));
+      if (json) console.log(JSON.stringify(data)); else console.log(`✅ ${version} ${data.items.length}칸`);
+    });
   release.command('prepare')
     .description('깨끗한 원본 → 공개본 → 공개 저장소 이력 위 커밋 → PWA → 묶음·체크섬 → 로컬 끝까지 (네트워크 쓰기 없음)')
     .requiredOption('--version <x.y.z>', 'package.json 과 같은 버전(먼저 버전 PR 을 착지)')

package/src/cli/self-update.ts

@@ -235,11 +235,11 @@ export function formatUpdateNotice(result: Pick<SelfUpdateResult, 'installedVers
 function defaultNotice(text: string): void {
   // 시험에선 텔레그램으로 나가지 않는다.
   if (process.env.NODE_ENV === 'test') return;
-  import('../domains/outbound-alert.js').then((m) => { m.sendOutbound(text, 'report'); }).catch(() => {});
+  import('../domains/outbound-alert.js').then((m) => { m.sendOutbound(text, 'ops-report'); }).catch(() => {});
 }
 
 function defaultAlert(text: string): void {
-  import('../domains/outbound-alert.js').then((m) => { m.sendOutbound(text, 'alert'); }).catch(() => {});
+  import('../domains/outbound-alert.js').then((m) => { m.sendOutbound(text, 'ops-alert'); }).catch(() => {});
 }
 
 export interface VersionPruneOutcome {
@@ -296,8 +296,11 @@ export function childPath(env: NodeJS.ProcessEnv = process.env, execPath: string
   return current.split(':').includes(bunDir) ? current : [bunDir, current].filter(Boolean).join(':');
 }
 
+// bun 1.4 는 maxBuffer(기본 1MiB)를 넘는 출력을 자르고 자식을 죽인다 — 설치·빌드 로그는 그보다 클 수 있다.
+const SPAWN_MAX_BUFFER = 64 * 1024 * 1024;
+
 const execute = (command: string, args: string[], cwd: string, options?: { timeout?: number }) => {
-  const result = spawnSync(command, args, { cwd, encoding: 'utf8', timeout: options?.timeout, maxBuffer: options?.timeout ? 64 * 1024 * 1024 : undefined, env: { ...process.env, PATH: childPath() } });
+  const result = spawnSync(command, args, { cwd, encoding: 'utf8', timeout: options?.timeout, maxBuffer: SPAWN_MAX_BUFFER, env: { ...process.env, PATH: childPath() } });
   return { status: result.status, stdout: result.stdout ?? '', stderr: result.error?.message ?? result.stderr ?? '' };
 };
 
@@ -395,7 +398,7 @@ export async function runReleaseUpdate(options: ReleaseUpdateOptions = {}, deps:
     }
   } catch { previous = ''; }
   const run = deps.run ?? ((command: string, args: string[], cwd: string, input?: string, env?: NodeJS.ProcessEnv) => {
-    const result = spawnSync(command, args, { cwd, encoding: 'utf8', input, env: { ...process.env, ...env, PATH: childPath() } });
+    const result = spawnSync(command, args, { cwd, encoding: 'utf8', input, maxBuffer: SPAWN_MAX_BUFFER, env: { ...process.env, ...env, PATH: childPath() } });
     return { status: result.status, stderr: result.error?.message ?? result.stderr ?? '' };
   });
   try {

package/src/cli/start-cli.ts

@@ -1,7 +1,8 @@
 import { spawn, type SpawnOptions } from 'node:child_process';
 import { createInterface } from 'node:readline/promises';
 import type { Command } from 'commander';
-import { detectProviders, type DetectedProvider } from '../llm/provider-detect.js';
+import type { DetectedProvider } from '../llm/provider-detect.js';
+import { resolveUsableLlm, type UsableLlm } from '../llm/usable-llm.js';
 import { resolveDaemonEndpoint, type DaemonEndpoint, type ResolveDaemonEndpointOpts } from '../nexus/daemon-endpoint.js';
 import { runBgLaunch } from './bg-launch.js';
 
@@ -13,10 +14,13 @@ export interface StartOptions {
 }
 
 export interface StartState {
-  providers: readonly Pick<DetectedProvider, 'provider' | 'auth' | 'available' | 'rank'>[];
+  /** Discovery candidates are diagnostic only; the resolved route controls the plan. */
+  providers?: readonly Pick<DetectedProvider, 'provider' | 'auth' | 'available' | 'rank'>[];
   tty: boolean;
   healthy: boolean;
   discoveryFailed?: boolean;
+  /** Required selected runtime route; null means resolution failed, not an absent LLM. */
+  llm: UsableLlm | null;
 }
 
 export type StartStepId = 'detect-llm' | 'login' | 'check-daemon' | 'launch-daemon' | 'open-gui' | 'open-tui';
@@ -32,11 +36,13 @@ export interface StartResult {
 
 /** No I/O and no credential values: the same observations always produce the same actions. */
 export function planStart(options: StartOptions, state: StartState): StartPlannedStep[] {
-  const available = state.providers.some((entry) => entry.available && entry.auth !== 'agent-cli');
+  const available = state.llm?.usable === true;
+  // The offered login is the Codex device login: it only fixes the auto route or an explicit openai-codex.
+  const codexLoginFixes = state.llm?.provider === undefined || state.llm.provider === 'openai-codex';
   const gui = options.gui === true || options.tui !== true;
   return [
     { id: 'detect-llm', needed: true },
-    { id: 'login', needed: !state.discoveryFailed && !available && state.tty && options.json !== true && options.login !== false },
+    { id: 'login', needed: !state.discoveryFailed && state.llm !== null && !available && codexLoginFixes && state.tty && options.json !== true && options.login !== false },
     { id: 'check-daemon', needed: true },
     { id: 'launch-daemon', needed: !state.healthy },
     { id: 'open-gui', needed: gui },
@@ -45,7 +51,9 @@ export function planStart(options: StartOptions, state: StartState): StartPlanne
 }
 
 export interface StartDeps {
+  /** Optional diagnostic seam; never gates runtime route selection. */
   detect?: () => Promise<DetectedProvider[]>;
+  resolveLlm?: () => UsableLlm;
   isTty?: () => boolean;
   confirmLogin?: () => Promise<boolean>;
   login?: () => Promise<boolean>;
@@ -115,21 +123,25 @@ export async function runStart(options: StartOptions = {}, deps: StartDeps = {})
   const output = deps.output ?? console.log;
   const steps: StartStep[] = [];
   const record = (id: StartStepId, status: StartStep['status'], detail: string) => steps.push({ id, status, detail });
-  let providers: DetectedProvider[] = [];
+  let usable: UsableLlm | undefined;
   let discoveryFailed = false;
+  if (deps.detect) {
+    try { await deps.detect(); }
+    catch { /* Diagnostic candidate probe must not gate the runtime route. */ }
+  }
   try {
-    providers = await (deps.detect ?? detectProviders)();
-    record('detect-llm', 'done', 'LLM discovery finished');
+    usable = (deps.resolveLlm ?? resolveUsableLlm)();
+    record('detect-llm', 'done', 'LLM route resolved');
   } catch {
     discoveryFailed = true;
-    record('detect-llm', 'failed', 'LLM discovery failed');
+    record('detect-llm', 'failed', 'LLM route could not be resolved');
   }
   const tty = (deps.isTty ?? (() => process.stdin.isTTY === true))();
   let healthy = false;
   const probeHealth = deps.health ?? (() => defaultHealth(deps));
   try { healthy = await probeHealth(); } catch { /* No health response; try launch. */ }
-  const plan = planStart(options, { providers, tty, healthy, discoveryFailed });
-  let llm: StartResult['llm'] = discoveryFailed ? 'unknown' : providers.some((entry) => entry.available && entry.auth !== 'agent-cli') ? 'available' : 'missing';
+  const plan = planStart(options, { tty, healthy, discoveryFailed, llm: usable ?? null });
+  let llm: StartResult['llm'] = discoveryFailed ? 'unknown' : usable?.usable ? 'available' : 'missing';
   if (plan.find((entry) => entry.id === 'login')?.needed) {
     let agreed = false;
     try { agreed = await (deps.confirmLogin ?? confirmLogin)(); } catch { /* No consent. */ }
@@ -137,8 +149,12 @@ export async function runStart(options: StartOptions = {}, deps: StartDeps = {})
       try {
         if (await (deps.login ?? defaultLogin)()) {
           try {
-            providers = await (deps.detect ?? detectProviders)();
-            llm = providers.some((entry) => entry.available && entry.auth !== 'agent-cli') ? 'available' : 'missing';
+            if (deps.detect) {
+              try { await deps.detect(); }
+              catch { /* Runtime route decides. */ }
+            }
+            usable = (deps.resolveLlm ?? resolveUsableLlm)();
+            llm = usable.usable ? 'available' : 'missing';
             record('login', llm === 'available' ? 'done' : 'failed', llm === 'available' ? 'LLM login detected' : 'No usable LLM login detected');
           } catch {
             llm = 'unknown';
@@ -147,7 +163,8 @@ export async function runStart(options: StartOptions = {}, deps: StartDeps = {})
         } else record('login', 'failed', 'LLM login did not complete');
       } catch { record('login', 'failed', 'LLM login or discovery did not complete'); }
     } else record('login', 'skipped', 'Login declined');
-  } else record('login', 'skipped', llm === 'available' ? 'LLM already available' : llm === 'unknown' ? 'LLM discovery unavailable; login not offered' : 'Interactive login unavailable');
+  } else record('login', 'skipped', llm === 'available' ? 'LLM already available' : llm === 'unknown' ? 'LLM discovery unavailable; login not offered'
+    : usable?.provider !== undefined && usable.provider !== 'openai-codex' ? `Codex login does not configure llm.provider=${usable.provider}` : 'Interactive login unavailable');
   record('check-daemon', healthy ? 'done' : 'failed', healthy ? 'Daemon healthy' : 'Daemon did not respond');
   let daemon: StartResult['daemon'] = healthy ? 'running' : 'failed';
   if (plan.find((entry) => entry.id === 'launch-daemon')?.needed) {
@@ -197,7 +214,9 @@ export async function runStart(options: StartOptions = {}, deps: StartDeps = {})
   if (options.json) output(JSON.stringify(result));
   else {
     for (const step of steps) output(`${step.status === 'done' ? '✓' : step.status === 'failed' ? '✗' : '–'} ${step.id}: ${step.detail}`);
-    if (llm === 'missing') output('LLM not configured; run `elanous login openai-codex` or `elanous llm detect`.');
+    const selected = usable?.provider;
+    if (llm === 'missing' && selected !== undefined && selected !== 'openai-codex') output(`LLM not configured for llm.provider=${selected}; run \`elanous doctor\` for that provider's fix.`);
+    else if (llm === 'missing') output('LLM not configured; run `elanous login openai-codex` or `elanous llm detect`.');
     if (llm === 'unknown') output('LLM status unknown; discovery failed. Run `elanous llm detect` to check configuration.');
   }
   return result;

package/src/dashboard/acp-boot.ts

@@ -83,6 +83,8 @@ export interface DashboardAcpBootDeps {
    *  callbacks become unused — the daemon's `runTurn` owns those.
    *  `getCwd()` is still consulted to populate `newSession(cwd)`. */
   remote?: { url: string; token?: string; label?: string };
+  /** Notifies the dashboard when an established remote connection drops. */
+  onRemoteDisconnect?: () => void;
   /** Tier 1 daemon-resume — when set together with `remote`,
    *  the boot flips from `DashboardSession.attach()`
    *  (which mints a new sessionId) to `attachExisting({sessionId})`
@@ -205,6 +207,7 @@ export async function bootDashboardAcpSession(
           url: deps.remote!.url,
           ...(deps.remote!.token ? { token: deps.remote!.token } : {}),
           ...(deps.remote!.label ? { label: deps.remote!.label } : {}),
+          onDisconnect: () => deps.onRemoteDisconnect?.(),
         }),
     });
     recordDashboardAcpBootOutcome(result);

package/src/dashboard/index.ts

@@ -5,11 +5,14 @@
 
 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 { 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';
@@ -602,6 +605,7 @@ import {
 import { createDashboardInlineSetupFlow } from './setup-inline.js';
 import { resolveDashboardChatMainThemeCommand } from './input/chat-main-theme-command.js';
 import { resolveDashboardChatMainLogCommand } from './input/chat-main-log-command.js';
+import { noProviderReply } from './input/no-provider-reply.js';
 import {
   dashboardLogHelpLines,
   resolveDashboardLogFilterAction,
@@ -1066,6 +1070,7 @@ import { bootDashboardHitl } from './hitl-boot.js';
 import { attachDashboardFilePathToken } from './file-path-attachment.js';
 import { bootDashboardSlashExecutor } from './slash-executor-boot.js';
 import { buildDashboardSlashRegistry, type DashboardSlashContext } from './slash-runtime/index.js';
+import { unknownSlashReply } from './slash-runtime/unknown-slash-reply.js';
 import { resolveSurfaceUx } from '../agent/surface-ux/build.js';
 import type { SurfaceUx } from '../agent/surface-ux/types.js';
 import { getDefaultQuestionChannels, type QuestionChannel } from '../hitl/question.js';
@@ -4239,6 +4244,36 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     } catch { /* noop */ }
   }, 5_000);
   (gitDirtyTimer as unknown as { unref?: () => void }).unref?.();
+  // The running module's installed version, not the user's working directory, is the baseline.
+  const dashboardCodeRoot = dirname(dirname(dirname(fileURLToPath(import.meta.url))));
+  const versionDir = versionedDashboardInstallDir(dashboardCodeRoot);
+  const staleInstallCheck = createStaleInstallCheck({
+    codeRoot: dashboardCodeRoot,
+    bootCommit: versionDir ? readDashboardBootCommit(versionDir) : undefined,
+    readInstalledCommit: readCurrentInstalledCommit,
+    now: Date.now,
+  });
+  if (versionDir) {
+    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 를 다시 띄워라`));
+        chatScrollOffset = -1;
+        try { draw(); } catch { /* TUI torn down */ }
+      }
+    };
+    checkInstall();
+    const installCheckTimer = setInterval(checkInstall, STALE_INSTALL_CHECK_INTERVAL_MS);
+    installCheckTimer.unref?.();
+  } else {
+    const result = staleInstallCheck.check();
+    debug.log('dashboard.version', 'install-check', {
+      state: result.state, bootCommit: result.bootCommit, installedCommit: result.installedCommit,
+    });
+  }
   // Phase T1 — unified terminal matrix. Wraps sessionRegistry during
   // the migration window: spawns flow through `matrix.spawn()` so we
   // get a single `term:<N>` id space, character/transport fields,
@@ -15343,7 +15378,13 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     ).persistToolOutputPreview;
     acpPtyAvailable = (await import('../pty-shell/registry.js')).ptyAvailable;
     const dashboardAcpBootResult = await bootDashboardAcpSession({
-        ...(opts.remote ? { remote: opts.remote } : {}),
+        ...(opts.remote ? {
+          remote: opts.remote,
+          onRemoteDisconnect: () => {
+            pushChatLine(C.warning('  ⚠ 데몬 연결이 끊겼다 · 입력 중인 글은 그대로다 · 다시 붙으려면 TUI 를 다시 띄워라'));
+            draw();
+          },
+        } : {}),
         ...(opts.resumeSessionId ? { resumeSessionId: opts.resumeSessionId } : {}),
         getCwd: () => getSessionCwd(),
         getChatHistory: () => chat.history,
@@ -16742,6 +16783,17 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
               : '/quit /clear (run `elanous setup` — no LLM provider available)',
             debugLog: debug.enabled ? (event, label, payload) => debug.log(event, label, payload) : undefined,
             textInputOpts: {
+              onScrollKey: (name) => {
+                const { rows } = termSize();
+                const viewport = computePromptFrameLogViewportBounds(
+                  rows, computePaneH(rows), getLayoutPromptFrame(rows),
+                );
+                chatScrollOffset = nextChatScrollOffset(
+                  chatScrollOffset, name, Math.max(1, viewport.height),
+                  Math.max(0, chatLines.length - viewport.height),
+                );
+                draw();
+              },
               // TUI 부활 후속 — Esc·Esc = /rewind 픽커 (codex backtrack
               // 제스처 · resolveEscEscRewind 순수 판정). 빈 버퍼에서만
               // prime · 1.5s 창. 힌트는 세션 1회.
@@ -18453,17 +18505,9 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
                   const handled = await pluginHost.dispatchSlash(cmdLower, args);
                   if (handled) { chatScrollOffset = -1; continue; }
                 }
-                const retiredHarnessCommand = ({
-                  ask: '/harness ask <무엇을 왜 고칠지 한 문장>',
-                  say: '/harness ask <무엇을 왜 고칠지 한 문장>',
-                  implement: '/harness implement <feature>',
-                  dev: '/harness dev <무엇을 왜 고칠지 한 문장>',
-                } as Record<string, string>)[cmdLower];
-                if (retiredHarnessCommand) {
-                  chatLines.push(C.warning(`/${cmdLower} has moved; use ${retiredHarnessCommand}`));
-                } else {
-                  chatLines.push(C.warning(`Unknown command: /${cmdLower}`));
-                  chatLines.push(C.muted('Type /help for the list of commands.'));
+                const replyLines = unknownSlashReply(cmdLower, dashboardSlashRegistry.names());
+                for (const [index, line] of replyLines.entries()) {
+                  chatLines.push(index === 0 ? C.warning(line) : C.muted(line));
                 }
                 chatScrollOffset = -1;
                 continue; // stay in input mode
@@ -18475,7 +18519,12 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
 
           // ── Q&A chat — requires at least one LLM provider ──
           if (!anyProviderAvailable()) {
-            chatLines.push(C.warning('No LLM provider available. Run `elanous setup` or `elanous codex setup`.'));
+            const reply = noProviderReply(input.text);
+            for (const line of reply.lines) {
+              chatLines.push(line.tone === 'warning' ? C.warning(line.text) : C.muted(line.text));
+            }
+            inputPrefixState.set(reply.prefill);
+            nextInitial = inputPrefixState.consumeInitialText('plain');
             continue; // stay in input mode
           }
 

package/src/dashboard/input/no-provider-reply.ts

@@ -0,0 +1,13 @@
+export function noProviderReply(text: string): {
+  lines: Array<{ tone: 'warning' | 'muted'; text: string }>;
+  prefill: string;
+} {
+  const prefill = text.trim();
+  return {
+    lines: [
+      { tone: 'warning', text: 'No LLM provider available. Run `elanous setup` or `elanous codex setup`.' },
+      { tone: 'muted', text: '보내지 않았다 — 입력칸에 그대로 두었다 · setup 뒤 Enter' },
+    ],
+    prefill,
+  };
+}

package/src/dashboard/slash-runtime/unknown-slash-reply.ts

@@ -0,0 +1,78 @@
+// Keep migration and retirement advice separate from the active slash registry:
+// a retired name must never be advertised as an available command.
+export const RETIRED_SLASH_ADVICE: Readonly<Record<string, { kind: 'moved' | 'retired'; use: string }>> = {
+  // These four entry points moved into the harness command.
+  ask: { kind: 'moved', use: '/harness ask <무엇을 왜 고칠지 한 문장>' },
+  say: { kind: 'moved', use: '/harness ask <무엇을 왜 고칠지 한 문장>' },
+  implement: { kind: 'moved', use: '/harness ask <무엇을 왜 고칠지 한 문장>' },
+  dev: { kind: 'moved', use: '/harness dev <무엇을 왜 고칠지 한 문장>' },
+  // Retired rich-UI and auxiliary commands from the slash registration tests.
+  ui: { kind: 'retired', use: '/help' }, workspace: { kind: 'retired', use: '/help' },
+  ws: { kind: 'retired', use: '/help' }, window: { kind: 'retired', use: '/help' },
+  win: { kind: 'retired', use: '/help' }, scratch: { kind: 'retired', use: '/help' },
+  sc: { kind: 'retired', use: '/help' }, 'acp-vw': { kind: 'retired', use: '/help' },
+  'claude-vw': { kind: 'retired', use: '/help' }, 'pty-pane': { kind: 'retired', use: '/help' },
+  'pty-view': { kind: 'retired', use: '/help' }, fullscreen: { kind: 'retired', use: '/help' },
+  fs: { kind: 'retired', use: '/help' }, view: { kind: 'retired', use: '/help' },
+  ctoggle: { kind: 'retired', use: '/help' }, cache: { kind: 'retired', use: '/help' },
+  perf: { kind: 'retired', use: '/help' }, 'pty-list': { kind: 'retired', use: '/help' },
+  ptys: { kind: 'retired', use: '/help' }, 'sweep-tool-results': { kind: 'retired', use: '/help' },
+  budget: { kind: 'retired', use: '/tokens' }, b: { kind: 'retired', use: '/tokens' },
+  route: { kind: 'retired', use: '/help' }, llm: { kind: 'retired', use: '/model' },
+  'browser-cdp': { kind: 'retired', use: '/help' }, bcdp: { kind: 'retired', use: '/help' },
+  dm: { kind: 'retired', use: '/help' }, surf: { kind: 'retired', use: '/help' },
+  'codex-vw': { kind: 'retired', use: '/help' }, 'skill-triggers': { kind: 'retired', use: '/help' },
+  triggers: { kind: 'retired', use: '/help' }, git: { kind: 'retired', use: '/help' },
+  memorize: { kind: 'retired', use: '/memory' }, 'mem-compact': { kind: 'retired', use: '/memory' },
+  sim: { kind: 'retired', use: '/help' }, simulator: { kind: 'retired', use: '/help' },
+  'turn-slider': { kind: 'retired', use: '/help' }, turnslider: { kind: 'retired', use: '/help' },
+  tslider: { kind: 'retired', use: '/help' }, playground: { kind: 'retired', use: '/help' },
+  pg: { kind: 'retired', use: '/help' }, branch: { kind: 'retired', use: '/help' },
+  audit: { kind: 'retired', use: '/help' }, 'substrate-stats': { kind: 'retired', use: '/help' },
+  sst: { kind: 'retired', use: '/help' }, usage: { kind: 'retired', use: '/tokens' },
+  stats: { kind: 'retired', use: '/help' }, 'codex-setup': { kind: 'retired', use: '/help' },
+  'codex-init': { kind: 'retired', use: '/help' }, hint: { kind: 'retired', use: '/help' },
+  media: { kind: 'retired', use: '/help' }, mv: { kind: 'retired', use: '/help' },
+};
+
+function distanceAtMostTwo(a: string, b: string): number {
+  if (Math.abs(a.length - b.length) > 2) return 3;
+  let previous = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1; i <= a.length; i++) {
+    const current = [i];
+    for (let j = 1; j <= b.length; j++) {
+      current[j] = Math.min(
+        current[j - 1]! + 1,
+        previous[j]! + 1,
+        previous[j - 1]! + (a[i - 1] === b[j - 1] ? 0 : 1),
+      );
+    }
+    if (Math.min(...current) > 2) return 3;
+    previous = current;
+  }
+  return previous[b.length]!;
+}
+
+/** Plain lines: the caller applies its existing warning/muted presentation. */
+export function unknownSlashReply(name: string, registered: readonly string[]): string[] {
+  const slashName = name.replace(/^\//, '').toLowerCase();
+  const advice = Object.hasOwn(RETIRED_SLASH_ADVICE, slashName)
+    ? RETIRED_SLASH_ADVICE[slashName] : undefined;
+  if (advice?.kind === 'moved') {
+    return [`/${slashName} has moved; use ${advice.use}`];
+  }
+  if (advice) return [`/${slashName} is retired; use ${advice.use}`];
+
+  const suggestions = [...new Set(registered)]
+    .filter((candidate) => !Object.hasOwn(RETIRED_SLASH_ADVICE, candidate))
+    .map((candidate) => ({ candidate, distance: distanceAtMostTwo(slashName, candidate) }))
+    .filter(({ distance }) => distance <= 2)
+    .sort((a, b) => a.distance - b.distance || a.candidate.localeCompare(b.candidate))
+    .slice(0, 3)
+    .map(({ candidate }) => `/${candidate}`);
+  return [
+    `Unknown command: /${slashName}`,
+    ...(suggestions.length ? [`Did you mean: ${suggestions.join(', ')}?`] : []),
+    'Type /help for the list of commands.',
+  ];
+}

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

@@ -0,0 +1,77 @@
+import { realpathSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, dirname, join, resolve } from 'node:path';
+
+import { readInstallMetadataCommit } from '../version/code-revision.js';
+
+export type StaleInstallResult = {
+  state: 'same' | 'changed' | 'unknown' | 'not-installed';
+  bootCommit: string | undefined;
+  installedCommit: string | undefined;
+};
+
+export const STALE_INSTALL_CHECK_INTERVAL_MS = 60_000;
+
+/** Identify the immutable installed version containing this module, never the session cwd. */
+export function versionedDashboardInstallDir(
+  codeRoot: string,
+  installRoot = join(homedir(), '.local', 'share', 'elanous'),
+): string | undefined {
+  try {
+    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;
+  } catch {
+    return undefined;
+  }
+}
+
+export function createStaleInstallCheck(input: {
+  bootCommit: string | undefined;
+  readInstalledCommit: () => string | undefined;
+  now: () => number;
+  codeRoot?: string;
+  installRoot?: string;
+}) {
+  const installed = input.codeRoot === undefined
+    || versionedDashboardInstallDir(input.codeRoot, input.installRoot) !== undefined;
+  const notifiedCommits = new Set<string>();
+  let lastReadAt = -Infinity;
+  let lastResult: StaleInstallResult | undefined;
+  const check = (): StaleInstallResult => {
+    if (!installed) return { state: 'not-installed', bootCommit: input.bootCommit, installedCommit: undefined };
+    const time = input.now();
+    if (lastResult && time - lastReadAt < STALE_INSTALL_CHECK_INTERVAL_MS) return lastResult;
+    lastReadAt = time;
+    let installedCommit: string | undefined;
+    try { installedCommit = input.readInstalledCommit(); } catch { /* unreadable metadata */ }
+    const result: StaleInstallResult = {
+      state: !input.bootCommit || !installedCommit
+        ? 'unknown'
+        : input.bootCommit === installedCommit ? 'same' : 'changed',
+      bootCommit: input.bootCommit,
+      installedCommit,
+    };
+    lastResult = result;
+    return result;
+  };
+  return {
+    check,
+    shouldNotify(result: StaleInstallResult): boolean {
+      if (result.state !== 'changed' || !result.installedCommit || notifiedCommits.has(result.installedCommit)) return false;
+      notifiedCommits.add(result.installedCommit);
+      return true;
+    },
+  };
+}
+
+/** Only the current pointer is polled; boot metadata is read once from the immutable version. */
+export function readDashboardBootCommit(versionDir: string): string | undefined {
+  return readInstallMetadataCommit(join(versionDir, 'install.json'));
+}
+
+export function readCurrentInstalledCommit(installRoot = join(homedir(), '.local', 'share', 'elanous')): string | undefined {
+  return readInstallMetadataCommit(join(installRoot, 'current', 'install.json'));
+}