elanous 0.2.0 → 0.2.5

package/src/budget/fetchers/codex.ts

@@ -124,7 +124,8 @@ export function createCodexFetcher(opts: CodexFetcherOpts = {}): ProviderFetcher
       const usedPercent = snapshot.windows
         .filter((window) => window.model === undefined)
         .reduce<number | undefined>((max, window) => max === undefined || window.used > max ? window.used : max, undefined);
-      writeQuotaSignal(snapshot.rateLimitReached, usedPercent, opts.codexHome, opts.quotaSignalStorage);
+      writeQuotaSignal(snapshot.rateLimitReached, usedPercent, opts.codexHome, opts.quotaSignalStorage,
+        snapshot.credits ? { balance: snapshot.credits.balance, hasCredits: snapshot.credits.hasCredits } : undefined);
       return snapshot;
     },
   };

package/src/budget/run-usage-rollup.ts

@@ -3,6 +3,8 @@ import type { BillingRoute } from './llm-cost.js';
 export interface RunUsageInput {
   runId?: string | null;
   hostId?: string | null;
+  site?: string | null;
+  role?: string | null;
   model?: string | null;
   billingProvider?: string | null;
   billing?: BillingRoute | null;
@@ -16,6 +18,8 @@ export interface RunUsageInput {
 
 export interface RunUsageRow {
   runId: string;
+  role?: string;
+  site?: string;
   model: string;
   billingProvider: string;
   billing: string;
@@ -33,18 +37,21 @@ export interface RunUsageRow {
 }
 
 /** Aggregate llm-usage observations without turning unavailable prices into a known zero. */
-export function rollupRunUsage(rows: readonly RunUsageInput[]): RunUsageRow[] {
+export function rollupRunUsage(...[rows, opts]: [rows: readonly RunUsageInput[], opts?: { by?: 'run' | 'role' }]): RunUsageRow[] {
   const groups = new Map<string, RunUsageRow>();
+  const byRole = opts?.by === 'role';
   for (const data of rows) {
-    const runId = data.runId ?? '(none)';
+    const runId = byRole ? '(all)' : data.runId ?? '(none)';
+    const role = data.role ?? '(none)';
+    const site = data.site ?? '(none)';
     const model = data.model ?? '(none)';
     const billingProvider = data.billingProvider ?? '(none)';
     const billing = data.billing ?? '(none)';
-    const key = JSON.stringify([runId, model, billingProvider, billing]);
+    const key = JSON.stringify(byRole ? [role, site, model, billingProvider, billing] : [runId, model, billingProvider, billing]);
     let row = groups.get(key);
     if (!row) {
       row = {
-        runId, model, billingProvider, billing, hostIds: [], calls: 0,
+        runId, ...(byRole ? { role, site } : {}), model, billingProvider, billing, hostIds: [], calls: 0,
         inputTokens: 0, outputTokens: 0, cacheReadInputTokens: 0,
         cacheCreationInputTokens: 0, reasoningOutputTokens: 0,
         usdKnown: 0, unknownCostCalls: 0, includedCalls: 0, apiEquivalentUsd: 0,

package/src/budget/unified-usage.ts

@@ -16,6 +16,7 @@ import { resolveGrokCredential } from '../grok/credential.js';
 import { getOpenRouterApiKey } from '../config.js';
 import { listCodexAccountsInStore } from '../oauth/codex-account-store.js';
 import { loadTokens } from '../oauth/store.js';
+import { envLiteral } from '../platform/env-literal.js';
 import { describeResetCreditExpiry } from './codex-reset-credit-state.js';
 import { listCodexResetCredits, type CodexResetCreditsResult } from './codex-reset-credits.js';
 import type {
@@ -173,7 +174,7 @@ async function collectResetCreditExpiry(
   warningWindowMs: number | undefined,
   nowMs: number,
 ): Promise<ResetCreditExpiryAxis> {
-  const listed = await listResetCredits(home ? { env: { CODEX_HOME: home } } : {});
+  const listed = await listResetCredits(home ? { env: envLiteral({ CODEX_HOME: home }) } : {});
   if (!listed.ok) return { status: 'unavailable', detail: listed.kind };
   return describeResetCreditExpiry(listed.value.credits, warningWindowMs, nowMs);
 }

package/src/capture/tui-self-report.ts

@@ -97,6 +97,13 @@ export function createTuiFrameObserver(
 export interface TuiControlTargetDeps {
   injectKey?: (key: Key) => boolean;
   splitKeys?: (input: string) => Key[];
+  /** The foreground terminal's real size; `undefined` when it cannot be known (stdout is not a TTY). */
+  dims?: () => { readonly cols: number; readonly rows: number } | undefined;
+}
+
+function stdoutDims(): { cols: number; rows: number } | undefined {
+  const out = process.stdout;
+  return out.isTTY && out.columns > 0 && out.rows > 0 ? { cols: out.columns, rows: out.rows } : undefined;
 }
 
 export interface TuiControlTarget extends PtyControlTarget {
@@ -108,11 +115,14 @@ export interface TuiControlTarget extends PtyControlTarget {
 export function createTuiControlTarget(surfaceId: string, deps: TuiControlTargetDeps = {}): TuiControlTarget {
   const inject = deps.injectKey ?? injectKey;
   const parse = deps.splitKeys ?? splitKeys;
+  const dims = deps.dims ?? stdoutDims;
   let alive = true;
   let accessMode: PtyAccessMode = 'write';
   let transitionPolicy: PtyTransitionPolicy = 'open';
   return {
     id: surfaceId,
+    get cols() { return dims()?.cols; },
+    get rows() { return dims()?.rows; },
     get accessMode() { return accessMode; },
     set accessMode(mode: PtyAccessMode) { accessMode = mode; },
     get transitionPolicy() { return transitionPolicy; },

package/src/channel-bot-token.ts

@@ -0,0 +1,126 @@
+import { existsSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { debug } from './debug/log.js';
+import { getSecret, setSecretAsync } from './nexus/config/secrets/index.js';
+import { userConfigPath } from './nexus/config/paths.js';
+import { isSecretRef, makeSecretRef, secretIdFromRef } from './nexus/config/types.js';
+import { acquireLockAsync } from './storage/file-lock.js';
+import type { UserConfig } from './user-config.js';
+
+export type ChannelBotPlatform = 'telegram' | 'discord';
+export type ChannelBotTokenSource = 'tokenRef' | 'env' | 'plaintext';
+
+/** The tab reference is read from the same persistent config as the NEXUS switch. */
+export function resolveChannelBotToken(
+  platform: ChannelBotPlatform,
+  cfg: Pick<UserConfig, 'telegram' | 'discord'> & { tabs?: Record<string, { tokenRef?: unknown }> },
+): { token: string; source: ChannelBotTokenSource } | undefined {
+  const ref = cfg.tabs?.[`${platform}:1`]?.tokenRef;
+  if (isSecretRef(ref)) {
+    const id = secretIdFromRef(ref);
+    const token = id ? getSecret(id) : undefined;
+    if (token) return { token, source: 'tokenRef' };
+  }
+  const envName = platform === 'telegram' ? 'ELANOUS_TELEGRAM_BOT_TOKEN' : 'ELANOUS_DISCORD_BOT_TOKEN';
+  const envToken = process.env[envName];
+  if (envToken) return { token: envToken, source: 'env' };
+  const token = cfg[platform]?.botToken;
+  if (token) {
+    debug.log('channel-bot.token', 'plaintext-fallback', { platform });
+    return { token, source: 'plaintext' };
+  }
+  return undefined;
+}
+
+/** Publish the secret before its reference, under the config lock. Other config keys survive unchanged. */
+type ChannelBotTokenWrite = {
+  platform: ChannelBotPlatform; token: string; allowedUsers?: string[];
+};
+
+export function storeChannelBotToken(platform: ChannelBotPlatform, token: string, allowedUsers?: string[]): Promise<void>;
+/** Migration selects candidates and backs up the exact config under the same lock as the write. */
+export function storeChannelBotToken(entries: (cfg: Record<string, unknown>) => ReadonlyArray<ChannelBotTokenWrite>, requireSameSecret: boolean): Promise<void>;
+export async function storeChannelBotToken(
+  platformOrEntries: ChannelBotPlatform | ((cfg: Record<string, unknown>) => ReadonlyArray<ChannelBotTokenWrite>),
+  tokenOrRequireSameSecret: string | boolean,
+  allowedUsers?: string[],
+): Promise<void> {
+  const requireSameSecret = typeof tokenOrRequireSameSecret === 'boolean' ? tokenOrRequireSameSecret : false;
+  const path = userConfigPath();
+  const lock = await acquireLockAsync(`${path}.lock`);
+  try {
+    const cfg = existsSync(path) ? JSON.parse(readFileSync(path, 'utf8')) as Record<string, unknown> : {};
+    const entries: ReadonlyArray<ChannelBotTokenWrite> = typeof platformOrEntries === 'string'
+      ? [{ platform: platformOrEntries, token: tokenOrRequireSameSecret as string, allowedUsers }]
+      : platformOrEntries(cfg);
+    if (entries.length === 0) return;
+    if (entries.some(({ platform, allowedUsers }) => platform === 'telegram' && allowedUsers !== undefined
+      && (!Array.isArray(allowedUsers) || !allowedUsers.every(id => typeof id === 'string'
+        && /^\d+$/.test(id) && Number.isSafeInteger(Number(id)) && Number(id) > 0)))) {
+      throw new Error('invalid-allowed-users');
+    }
+    const tabs = cfg.tabs && typeof cfg.tabs === 'object' && !Array.isArray(cfg.tabs)
+      ? cfg.tabs as Record<string, unknown> : {};
+    const updates = entries.map(({ platform, token, allowedUsers }) => {
+      const section = cfg[platform] && typeof cfg[platform] === 'object' && !Array.isArray(cfg[platform])
+        ? cfg[platform] as Record<string, unknown> : {};
+      const tabKey = `${platform}:1`;
+      const tab = tabs[tabKey] && typeof tabs[tabKey] === 'object' && !Array.isArray(tabs[tabKey])
+        ? tabs[tabKey] as Record<string, unknown> : {};
+      // 기존 참조가 «같은 토큰»을 이미 가리키면 그 참조를 재사용한다(#20744 reuse-ref) — 평문만 지운다.
+      // 다른 값을 가리키면 그 비밀은 남(다른 서비스와 공유 가능)이라 덮지 않고 표준 id 로 간다.
+      const refId = isSecretRef(tab.tokenRef) ? secretIdFromRef(tab.tokenRef as string) : null;
+      const id = refId && token && getSecret(refId) === token ? refId : `${platform}_1__tokenRef`;
+      return { platform, token, allowedUsers, section, tabKey, tab, id,
+        existing: token ? getSecret(id) : undefined };
+    });
+    if (requireSameSecret && updates.some(update => update.token && update.existing !== undefined
+      && update.existing !== update.token)) throw new Error('secret conflict');
+    for (const update of updates) {
+      const { platform, token, allowedUsers, section, tabKey, tab, id, existing } = update;
+      if (token) {
+        if (existing !== token) await setSecretAsync(id, token);
+        tab.tokenRef = makeSecretRef(id);
+        tabs[tabKey] = tab;
+        cfg.tabs = tabs;
+      }
+      // 평문은 «새 토큰을 저장할 때»와 «빈 평문»일 때만 지운다 — 허용 사용자만 고치는 저장은 토큰 칸을 안 건드린다.
+      if (token || section.botToken === '') delete section.botToken;
+      if (allowedUsers !== undefined) section.allowedUsers = platform === 'telegram'
+        ? allowedUsers.map(Number) : allowedUsers;
+      cfg[platform] = section;
+    }
+    if (!lock.stillHeld()) throw new Error('config lock lost');
+    const tmp = `${path}.${randomUUID()}.tmp`;
+    try {
+      writeFileSync(tmp, JSON.stringify(cfg, null, 2), { mode: 0o600, flag: 'wx' });
+      renameSync(tmp, path);
+    } finally {
+      if (existsSync(tmp)) unlinkSync(tmp);
+    }
+  } finally {
+    lock.release();
+  }
+}
+
+/** Fetch errors may contain the Telegram token-bearing URL; never propagate them. */
+export async function probeChannelBotToken(
+  platform: ChannelBotPlatform,
+  token: string,
+  fetchImpl: typeof fetch = fetch,
+): Promise<{ ok: boolean; botName?: string }> {
+  try {
+    const response = await fetchImpl(platform === 'telegram'
+      ? `https://api.telegram.org/bot${token}/getMe` : 'https://discord.com/api/v10/users/@me',
+    platform === 'discord' ? { headers: { Authorization: `Bot ${token}` } } : undefined);
+    if (!response.ok) return { ok: false };
+    const body: unknown = await response.json();
+    if (!body || typeof body !== 'object') return { ok: false };
+    const data = body as { ok?: boolean; result?: { username?: unknown }; username?: unknown };
+    const name = platform === 'telegram' ? data.result?.username : data.username;
+    if (platform === 'telegram' && data.ok !== true) return { ok: false };
+    return typeof name === 'string' && name.trim() ? { ok: true, botName: name } : { ok: false };
+  } catch {
+    return { ok: false };
+  }
+}

package/src/chat/index.ts

@@ -107,9 +107,27 @@ import {
 import { resolveTextInputControlAction } from './input-control-key.js';
 import { resolveTextInputEditAction } from './input-edit-key.js';
 import { resolveTextInputTextAction } from './input-text-key.js';
+import { classifyLeftoverInput, summarizeSubmitText } from './submit-trace.js';
 
 import { perf } from '../perf-counters.js';
 
+let lastSubmitAt: number | null = null;
+
+function traceAfterSubmitKey(key: Key): void {
+  if (lastSubmitAt === null) return;
+  const withinMs = Date.now() - lastSubmitAt;
+  if (withinMs > 1000) {
+    lastSubmitAt = null;
+    return;
+  }
+  if (key.ctrl || key.alt) return;
+  const input = key.name === 'paste' ? key.paste ?? '' : key.name;
+  if (!input || (key.name !== 'paste' && [...input].length !== 1)) return;
+  lastSubmitAt = null;
+  const kind = classifyLeftoverInput(input, withinMs);
+  if (kind) debug.log('chat.input.leftover', 'after-submit', { withinMs, kind });
+}
+
 /** Row where the input prompt starts — set by the textInput paint
  *  loop so writeTerminal knows which rows to invalidate in the
  *  frame cache. Falls back to "invalidate everything" when unknown
@@ -413,91 +431,62 @@ export interface SlashCommand {
 
 // Default commands available in the input
 export const SLASH_COMMANDS: SlashCommand[] = [
+  { name: 'directive', aliases: [], description: 'Record a directive as a Linear issue' },
   { name: 'run-skill', aliases: ['rs', 'run'], description: 'Execute a skill via its SKILL.md prompt' },
   { name: 'ad', aliases: [], description: 'Create an advertising plan from a URL, brief, or attached image' },
   // B4 — craft rulebook verdict, same resolution as `elanous repo design-check`
   //   and the PWA `/design-check` panel. Listed (not baselined as hidden) on
   //   purpose: a surface nobody can discover is not a surface.
-  { name: 'design',    aliases: ['design-check'], description: 'Craft rulebooks — 이 저장소 DESIGN.md 가 선언한 규칙집 · 못 찾은 것 · elanous 가 주는데 선언 안 된 것. /design [--declared]', subcommands: ['--declared'] },
+  { name: 'design',    aliases: ['design-check'], description: 'Design rulebooks this repository declares · /design [--declared] · /design pick [number|id] to choose a design direction', subcommands: ['--declared', 'pick'] },
   { name: 'provider',  aliases: ['p'],          description: 'LLM providers — /provider (list) · next (cycle, also Alt+M / pill click) · use <name> · pick (visual picker) · reset', subcommands: ['next', 'use', 'pick', 'picker', 'menu', 'reset', 'list'] },
   { name: 'reasoning', aliases: ['r', 'think'],  description: 'Reasoning level (codex effort + summary, anthropic extended-thinking budget) — /reasoning [off|low|medium|high|xhigh] (cycle when no arg · xhigh 는 모델 상한이 xhigh 이상일 때만 wire 에 실린다, 아니면 high 로 깎인다)', subcommands: ['off', 'low', 'medium', 'high', 'xhigh'] },
   { name: 'model',     aliases: ['m'],           description: 'Switch active model — /model <codex|terra|sol|luna|opus|sonnet|grok> (list + current when no arg). OpenAI 는 Codex(Responses API)만. effort 는 /reasoning.', subcommands: ['codex', 'terra', 'sol', 'luna', 'opus', 'sonnet', 'grok'] },
   { name: 'local',     aliases: ['ll'],         description: 'Local OpenAI-compatible LLM — ping / models / test / use', subcommands: ['ping', 'models', 'test', 'use', 'status'] },
   { name: 'session',   aliases: ['sess'],       description: 'Session resume — list / load / sync / new (handoff from mobile)', subcommands: ['list', 'load', 'sync', 'new'] },
-  { name: 'resume',    aliases: [],             description: 'Resume session — 픽커에서 선택 · /resume <id-prefix> 즉시 로드 (TUI 부활 S-a)' },
-  { name: 'fork',      aliases: [],             description: 'Fork — 현 시점 전체 복사로 새 세션 분기 (codex /fork 동형)' },
+  { name: 'resume',    aliases: [],             description: 'Pick a past session, or load one by id prefix · /resume <id-prefix>' },
+  { name: 'fork',      aliases: [],             description: 'Copy this session into a new one' },
   { name: 'rewind',    aliases: [],             description: 'Rewind — 과거 user 턴 픽커로 되감기 (원본 보존 · 새 세션 분기 · /rewind <n> 숏컷)' },
   // TUI 부활 C-a (2026-07-12): autopilot 미션 TUI 표면 — CLI 동등 단일 창구 소비.
   { name: 'mission',   aliases: [],             description: 'Autopilot 미션 — list(+헬스) · trace <id> 계보 · arm <id> 승인 (구체화/종료는 CLI)', subcommands: ['list', 'trace', 'arm'] },
   { name: 'resume-turn', aliases: [],           description: 'Resume a paused turn checkpoint (/pause 짝 · 구 /resume)', subcommands: ['list'] },
   { name: 'context',   aliases: ['ctx'],        description: 'Show / clear / drop attached files', subcommands: ['clear', 'drop'] },
-  { name: 'paste', aliases: ['v'],          description: 'Attach clipboard image (macOS)' },
+  { name: 'paste', aliases: [],             description: 'Attach clipboard image (macOS)' },
   { name: 'sync',  aliases: ['s'],         description: 'Enter sync mode' },
   { name: 'plugin', aliases: ['plugins'], description: 'Manage plugins', subcommands: ['list', 'activate', 'deactivate', 'reload'] },
   { name: 'widget', aliases: ['widgets'], description: 'Manage widgets', subcommands: ['list', 'reload', 'instances'] },
   { name: 'clear', aliases: ['cls'],       description: 'Clear chat log' },
   { name: 'log',   aliases: [],             description: 'Chat Log controls — size / clear / filter / search / freeze / solo / turn / fold / help', subcommands: ['size', 'clear', 'filter', 'search', 'freeze', 'solo', 'turn', 'fold', 'help'] },
-  { name: 'media', aliases: ['mv'],         description: 'Last assistant media preview — status / open / sample / clear', subcommands: ['status', 'open', 'sample', 'clear', 'help'] },
-  { name: 'browser-cdp', aliases: ['bcdp'], description: 'Browser CDP status / smoke / stop', subcommands: ['status', 'smoke', 'stop', 'help'] },
   { name: 'help',  aliases: ['?'],         description: 'Show help overlay' },
-  { name: 'codex-setup', aliases: ['codex-init'], description: 'Codex 1-point setup — OAuth login + model pick + save config' },
   { name: 'setup', aliases: [], description: 'Onboarding wizard guide — /setup (anchor) · /setup reset (re-run wizard on next boot)', subcommands: ['help', 'reset'] },
   { name: 'memory', aliases: ['mem'], description: 'Memory ops — list / show / search / add / delete (see `elanous memory --help`)', subcommands: ['list', 'show', 'search', 'add', 'delete', 'index'] },
   { name: 'status', aliases: ['st'], description: 'Print the claude-code-style status pills (working dir + git + model)' },
   { name: 'export', aliases: [], description: 'Export this conversation transcript to a markdown file — /export [path] (default ~/temp/elanous-transcript-<stamp>.md)' },
-  { name: 'cache', aliases: [], description: 'Prompt-cache metrics — show session totals / reset', subcommands: ['show', 'reset'] },
   { name: 'delta', aliases: ['diffs'], description: 'Source delta browser — open the latest turn-scoped file diff popup', subcommands: ['open', 'help'] },
   { name: 'theme', aliases: [], description: 'Theme controls — list / switch / use / reset / preview / export', subcommands: ['list', 'switch', 'use', 'reset', 'preview', 'export'] },
   { name: 'debug', aliases: [], description: 'Runtime tracer + surfaces — /debug on (mirror+file) · off · file (quiet trail) · diag (loud trail) · render on|off (렌더 무음, 레벨과 직교); surfaces: window / popup / workbench / promote', subcommands: ['on', 'off', 'file', 'diag', 'mirror', 'verbose', 'render', 'level', 'toggle', 'tail', 'clear', 'path', 'view', 'status', 'window', 'popup', 'workbench'] },
-  { name: 'audit', aliases: [], description: 'Tail control-audit log (default: input policy changes; last 20 entries)', subcommands: ['input', 'all'] },
   { name: 'rebind', aliases: [], description: 'Manage runtime input bindings — list / show / add / reset / export / import', subcommands: ['actions', 'reset', 'export', 'import', 'help'] },
-  { name: 'perf',  aliases: [], description: 'Perf counters: draw latency + debug.log calls + stdout writes', subcommands: ['on', 'off', 'report', 'reset', 'status'] },
-  { name: 'substrate-stats', aliases: ['sst'], description: 'Substrate observability — paint cache hits/misses · overlay skip/write · mount churn · F8 generation bumps' },
-  { name: 'playground', aliases: ['pg'], description: 'IUL playground lab — list / run <id> [-v] / parse <path> / edit <id> / save <id> <path>.', subcommands: ['list', 'run', 'parse', 'edit', 'save'] },
-  { name: 'hint',  aliases: [], description: 'Tool hints — prefer/avoid/enable/disable/list/reset/show', subcommands: ['prefer', 'avoid', 'enable', 'disable', 'list', 'reset', 'show'] },
   { name: 'api-allow', aliases: ['api'], description: 'api_call allowlist — add/remove/list hosts the model may call', subcommands: ['add', 'remove', 'list', 'clear'] },
   { name: 'prompt', aliases: ['prompts'], description: 'Prompt Bank — list / show / search / select / inject / explain / enable / disable / config', subcommands: ['list', 'show', 'search', 'select', 'inject', 'explain', 'enable', 'disable', 'config'] },
   { name: 'history', aliases: ['hist', 'inputs'], description: 'Input history — list / find / show / clear', subcommands: ['list', 'find', 'show', 'clear'] },
   { name: 'research', aliases: ['rsh'],    description: 'Autonomous research loop — start / status / stop / tail / replan (PFC-S4)', subcommands: ['start', 'status', 'stop', 'tail', 'replan'] },
   // /harness is the dashboard's sole harness-launching entry. Its first
-  // positional token selects plan, ask, implement, goal, runs, stop, or memo;
+  // positional token selects plan, ask, dev, goal, runs, stop, or memo;
   // otherwise the complete sentence follows the former /dev dispatch.
-  { name: 'harness', aliases: [], description: 'Harness — /harness <goal> (self-dev) · plan <goal> · ask <sentence> · implement <feature> · goal <goal-file> · runs · stop <space-id> · memo <space-id> <note>', subcommands: ['plan', 'ask', 'implement', 'goal', 'runs', 'stop', 'memo'] },
+  { name: 'harness', aliases: [], description: 'Harness — /harness <goal> (self-dev) · plan <goal> · ask <sentence> · dev <goal> · goal <goal-file> · runs · stop <space-id> · memo <space-id> <note>', subcommands: ['plan', 'ask', 'dev', 'goal', 'runs', 'stop', 'memo'] },
   { name: 'plan',  aliases: [],            description: 'Toggle plan mode — read-only planning posture (slash alias for EnterPlanMode tool)', subcommands: ['enter', 'exit', 'status'] },
   { name: 'chat',  aliases: [],            description: 'Toggle LLM-only layout (hide 3-pane grid)' },
   { name: 'dashboard', aliases: ['dash'],  description: 'Return to 3-pane dashboard layout' },
-  // TUI 부활 T2 (2026-07-12): 단일 UI 모드 축 — essential(chat 전체화면 ·
-  // 기본) ↔ rich(full dashboard). config persist 포함.
-  { name: 'ui',    aliases: [],            description: 'UI mode — essential (chat 전체화면 · 기본) ↔ rich (full dashboard) · config 저장', subcommands: ['essential', 'rich'] },
-  // Q2 (substrate Occam, 2026-05-03): the legacy `/workspace`
-  // (working-dir | skill view switch) entry was vestigial — declared
-  // in the catalog but never wired to a handler. Removed so the new
-  // `/workspace` (virtual window management) below can take the name.
-  // Use `/view` for view switching instead.
   { name: 'telegram',  aliases: ['tg'],    description: 'Telegram bot — status / pair / send / pause / stop / attach / detach / sessions', subcommands: ['status', 'pair', 'setup', 'send', 'pause', 'stop', 'attach', 'detach', 'sessions'] },
-  { name: 'view',      aliases: [],        description: 'Switch or manage dashboard views', subcommands: ['list', 'next', 'prev', 'reload', 'save', 'restore', 'reset', 'export', '1', '2', '3', '4', '5', '6'] },
-  // Q2 (substrate Occam, 2026-05-03): renamed `/window` → `/workspace`
-  // per PLAN §4. `/window` `/win` `/ws` preserved as muscle-memory
-  // aliases. Implementation directory rename + symbol rename
-  // (`VirtualWindow` → `Workspace`, etc.) deferred to a follow-up PR
-  // — slash-command rename is the user-facing first step.
-  { name: 'workspace', aliases: ['ws', 'window', 'win'], description: 'Workspaces (formerly virtual windows) — list / new / browser / preview / browser-preview / iul / acp / sim / switch / close / picker / companion', subcommands: ['list', 'new', 'browser', 'preview', 'browser-preview', 'iul', 'acp', 'sim', 'switch', 'close', 'closeall', 'picker', 'companion'] },
-  { name: 'sim',       aliases: ['simulator'], description: 'Simulator shell — open / list / run <scenario>', subcommands: ['open', 'list', 'run'] },
-  { name: 'tablet',    aliases: [],        description: 'Tablet mode — collapse layout to log + input (Ctrl+M <pane> for others)', subcommands: ['on', 'off', 'toggle', 'auto', 'status', 'browser-preview', 'bp'] },
-  { name: 'surface',   aliases: ['surf'],  description: 'Surface control — open a pane/catalog launcher (/surface catalog · browser · preview · log · scratch · obsidian · skill) OR set a preferred LLM surface (/surface coding-agent · research-agent · control-agent · ops-agent · … · clear · status)', subcommands: ['catalog', 'browser', 'preview', 'browser-preview', 'log', 'scratch', 'obsidian', 'skill', 'skill-file', 'agents', 'coding-agent', 'coding-chat', 'research-agent', 'research-chat', 'control-agent', 'ops-ui-agent', 'ops-fleet-agent', 'ops-agent', 'clear', 'status'] },
-  { name: 'scratch',   aliases: ['sc'],    description: 'Scratchpad ops (text body / memo / clear / dump-log / popup)', subcommands: ['memo', 'clear', 'dump', 'popup'] },
+  { name: 'tablet',    aliases: [],        description: 'Tablet mode — collapse layout to log + input', subcommands: ['on', 'off', 'toggle', 'auto', 'status', 'browser-preview', 'bp'] },
+  { name: 'surface',   aliases: [], description: 'Surface control — open a pane/catalog launcher (/surface catalog · browser · preview · log · scratch · obsidian · skill) OR set a preferred LLM surface (/surface coding-agent · research-agent · control-agent · ops-agent · … · clear · status)', subcommands: ['catalog', 'browser', 'preview', 'browser-preview', 'log', 'scratch', 'obsidian', 'skill', 'skill-file', 'agents', 'coding-agent', 'coding-chat', 'research-agent', 'research-chat', 'control-agent', 'ops-ui-agent', 'ops-fleet-agent', 'ops-agent', 'clear', 'status'] },
   { name: 'term',  aliases: ['terminal'], description: 'Interactive terminal modal — spawn / list / attach / detach / switch / kill / snapshot / resume', subcommands: ['spawn', 'list', 'attach', 'detach', 'switch', 'kill', 'snapshot', 'resume'] },
-  { name: 'pty-list', aliases: ['ptys'], description: 'List PTY shell processes started from this dashboard session' },
-  { name: 'pty-pane', aliases: ['pty-view'], description: 'Open a virtual-window pane tailing a PTY shell (auto-picks the only live one, else specify id)' },
   { name: 'claude', aliases: [], description: 'Spawn claude-code CLI in a terminal modal' },
   { name: 'codex',  aliases: [], description: 'Spawn codex CLI in a terminal modal' },
   { name: 'gemini', aliases: [], description: 'Spawn gemini CLI in a terminal modal' },
   { name: 'acp',    aliases: [], description: 'ACP chat — stream claude-code / codex / gemini replies into the chat pane (not a VW spawn). /acp codex points at the canonical codex app-server path; /acp cas is a synonym.', subcommands: ['claude', 'codex', 'gemini', 'cas', 'cancel', 'status', 'drop'] },
-  { name: 'acp-vw', aliases: [], description: 'Spawn claude-code/codex/gemini/local-llm inside a new virtual window pane. /acp-vw clc (claude-code) · /acp-vw gem (gemini) · /acp-vw lll <node>:<model> (local-llm via lms chat · local node only) route through the H5 Embodied Agent Bus.', subcommands: ['claude', 'codex', 'clc', 'gem', 'lll'] },
   { name: 'conv', aliases: [], description: 'Conversation widget/popup host — /conv list · /conv open <session-id> · /conv layout <cascade|tile|stack> · /conv focus <next|prev>.', subcommands: ['list', 'ls', 'open', 'layout', 'focus'] },
   { name: 'handoff', aliases: [], description: 'H5 P3 cross-agent context handoff: /handoff <from_session_id> <to_brand> [--channels r,p,m] [--prompt "prefix"]. Takes source session snapshot (filtered by channels if observer present) and launches target via adapter registry. Brands: codex · claude · claude-code · gemini · elanous.' },
-  { name: 'budget',  aliases: ['b'], description: 'H6 P1 budget tracker — /budget [brand] · /budget remaining · /budget set <b> <w> <q> · /budget refresh · /budget forecast · /budget help', subcommands: ['set', 'refresh', 'forecast', 'status', 'remaining', 'help'] },
-  { name: 'remaining', aliases: [], description: '계정마다 행으로 「지금 쓸 수 있는 것이 얼마나 남았나」를 본다 — 크레딧 축과 구독 축을 갈라 낸다. 화면은 명령 산출을 그대로 읽는다.' },
+  { name: 'remaining', aliases: [], description: 'What each account has left' },
   { name: 'agent-room', aliases: [], description: 'H6 P4 VW agent-room — /agent-room <N> <brands...> · /agent-room list · /agent-room close <id> · N ∈ {2,3,4} · brands: codex/claude/gemini/elanous/auto/lll:<m>', subcommands: ['list', 'close', 'preset', 'help'] },
   { name: 'showroom', aliases: ['sr'], description: 'Showroom v2 multi-LLM lane composer — /showroom (default 2-pane) · /showroom <lane1> <lane2> [<lane3> [<lane4>]] · lane = role:provider[:transport] · roles plan/build/exec/review/reflect · pair with /lane and /relay for cross-lane handoffs.', subcommands: ['help'] },
   { name: 'reply',   aliases: [], description: 'H6 P5 AgentReply — /reply <target-session-id> <message...> · send message to a live session, capture the response · flags: --from · --channels r,m · --idle-ms · --timeout-ms', subcommands: ['help'] },
@@ -505,18 +494,13 @@ export const SLASH_COMMANDS: SlashCommand[] = [
   { name: 'inject',    aliases: [], description: 'H6 P7 InjectCaptureToContext — /inject <sourceId> <targetId> · inject capture snapshot into target session · --as user-message|system-note|attached-block · HITL approver gated · non-revocable v1', subcommands: ['help'] },
   { name: 'relay',     aliases: [], description: 'Showroom v2 multi-lane handoff macros — /relay plan-build-review · /relay broadcast [--from <lane>] · /relay <from> -> <toA>,<toB> · HITL approver gates each step · failed steps non-aborting', subcommands: ['plan-build-review', 'broadcast', 'help'] },
   { name: 'lane',      aliases: [], description: 'Showroom v2 cross-lane context inject — /lane <from> <to> · address by pane index | role (plan/build/exec/review/reflect) | brand · --as user-message|system-note|attached-block · HITL approver gated · /lane list · /lane help', subcommands: ['list', 'help'] },
-  { name: 'llm',       aliases: [], description: 'H6 P2 Bundle 1 local LLM fleet — /llm nodes · /llm models [--node <id>] · /llm refresh · enumerate Tailscale hosts + LM Studio inventory · model spec = local-llm:<node>:<model>', subcommands: ['nodes', 'models', 'refresh', 'help'] },
-  { name: 'claude-vw', aliases: [], description: 'Spawn claude-code CLI in a new virtual window (fullscreen-by-default, single pane).' },
-  { name: 'codex-vw',  aliases: [], description: 'Spawn codex CLI in a new virtual window (fullscreen-by-default, single pane).' },
-  { name: 'control', aliases: ['dm'],      description: 'Enter control mode — the LLM treats every message as a dashboard command. /control off to exit.' },
+  { name: 'control', aliases: [],      description: 'Enter control mode — the LLM treats every message as a dashboard command. /control off to exit.' },
   { name: 'default', aliases: [],          description: 'Exit control mode back to default chat.' },
   // NOTE: the preferred-LLM-surface command (/surface coding-agent · … · clear · status)
   // shares the '/surface' name with the pane/catalog launcher above — both handlers
   // dispatch by argument (immediate slash-executor for panes, registry for LLM surfaces).
   // They are documented in the single merged '/surface' entry to keep names unique.
   { name: 'qc',      aliases: [],          description: 'Quick-control — arm one-shot control mode; next message runs as control, then auto-return to chat.' },
-  { name: 'ctoggle', aliases: [],          description: 'Toggle persistent control mode (alternative to /control ↔ /default).' },
-  { name: 'fullscreen', aliases: ['fs'], description: 'Toggle fullscreen mode for the current terminal modal' },
   { name: 'voice-chat', aliases: ['vc'], description: 'Continuous voice chat mode — speak, elanous replies in voice (Phase 4-5). Subcommands: start / stop / cancel / status. Chord: Alt+R toggles enter/exit anywhere.', subcommands: ['start', 'stop', 'cancel', 'status'] },
   { name: 'auto-tts', aliases: ['tts', 'autotts'], description: 'Auto-TTS for chat responses (Phase 2) — speaks LLM replies sentence-by-sentence. Subcommands: on / off / toggle / status.', subcommands: ['on', 'off', 'toggle', 'status'] },
   { name: 'quit',  aliases: ['q', 'exit'], description: 'Exit application' },
@@ -735,6 +719,8 @@ export async function textInput(opts: {
    *  typing. The host is expected to mutate its own state; the input
    *  redraws the bar + picker on top afterward. */
   onMouse?: (mouse: { row: number; col: number; type: 'click' | 'double-click' | 'right-click' | 'scroll-up' | 'scroll-down' | 'drag' | 'release'; shift?: boolean }) => void | boolean | Promise<void | boolean>;
+  /** Scroll the host's chat log from the input without editing its buffer. */
+  onScrollKey?: (name: 'pageup' | 'pagedown') => boolean | void;
   /** MX11b — key interceptor called BEFORE textInput's own key
    *  handling. Host returns 'consumed' to short-circuit the event
    *  (no further input processing), 'passthrough' to let the default
@@ -1365,13 +1351,15 @@ export async function textInput(opts: {
     writeTerminal(endTextInputCursor(opts.cursorSink));
     return result;
   };
-  const submitBufferResult = (text: string): InputResult => (
-    finalizeInput({
+  const submitBufferResult = (text: string): InputResult => {
+    debug.log('chat.input.submit', 'summary', summarizeSubmitText(text.trim()));
+    lastSubmitAt = Date.now();
+    return finalizeInput({
       text: text.trim(),
       submitted: true,
       ...(pendingExternalSubmitSource ? { externalSubmitSource: pendingExternalSubmitSource } : {}),
-    })
-  );
+    });
+  };
   const currentBufferText = (): string => lines.join('\n').trim();
 
   // Expose drawAll so the host can ping us to re-paint after an
@@ -1435,6 +1423,7 @@ export async function textInput(opts: {
     }
 
     const key = await (opts.readKey ?? (() => readKey('input')))();
+    traceAfterSubmitKey(key);
 
     // Raw-key trace — diagnoses "modifier bit dropped before global-action
     // matcher saw the chord" cases (e.g. tablet terminal apps that
@@ -1661,6 +1650,11 @@ export async function textInput(opts: {
       }
     }
 
+    if (!key.ctrl && (key.name === 'pageup' || key.name === 'pagedown') && opts.onScrollKey) {
+      if (opts.onScrollKey(key.name) !== false) drawAll();
+      continue;
+    }
+
     const controlAction = resolveTextInputControlAction(key, {
       currentLine: lines[lineIdx] ?? '',
       cursor: colIdx,
@@ -1771,10 +1765,20 @@ export async function textInput(opts: {
     }
     // ── Arrow keys (non-slash mode) ──
     else if (editAction.kind === 'move-left') {
-      applyMultilineEditorState(multilineEditorMoveLeft(multilineEditorState()));
+      if (key.ctrl) {
+        const action = resolveTextInputTextAction(currentLineEditorState(), key);
+        if (action.kind === 'insert') applyCurrentLineEditorState(action.next);
+      } else {
+        applyMultilineEditorState(multilineEditorMoveLeft(multilineEditorState()));
+      }
     }
     else if (editAction.kind === 'move-right') {
-      applyMultilineEditorState(multilineEditorMoveRight(multilineEditorState()));
+      if (key.ctrl) {
+        const action = resolveTextInputTextAction(currentLineEditorState(), key);
+        if (action.kind === 'insert') applyCurrentLineEditorState(action.next);
+      } else {
+        applyMultilineEditorState(multilineEditorMoveRight(multilineEditorState()));
+      }
     }
     else if (editAction.kind === 'history-older') {
       applyHistoryState(navigateSingleLineHistory(historyState(), history, 'older'));
@@ -1921,6 +1925,7 @@ export function attachStreamingKeys(
   };
   function deliver(keys: readonly Key[]): void {
     for (const key of keys) {
+      traceAfterSubmitKey(key);
       traceKey(key, 'stream');
       try {
         const r = handler(key);
@@ -2064,7 +2069,7 @@ export function buildContext(ctx: DashboardContext): string {
 export function formatResponse(
   text: string,
   maxWidth: number,
-  wrapOpts: { urlAware?: boolean; preserveOsc8?: boolean } = {},
+  wrapOpts: { urlAware?: boolean } = {},
 ): string[] {
   // Apply markdown styling first
   const rendered = renderMarkdown(text);

package/src/chat/input-text-key.ts

@@ -26,10 +26,10 @@ export function resolveTextInputTextAction(
   state: InlineEditorState,
   key: Pick<Key, 'name' | 'ctrl' | 'shift'>,
 ): TextInputTextAction {
-  if (key.ctrl) {
+  if (key.ctrl && key.name !== 'w' && key.name !== 'left' && key.name !== 'right') {
     return { kind: 'none' };
   }
-  if (NON_TEXT_NAMED_KEYS.has(key.name)) {
+  if (!key.ctrl && NON_TEXT_NAMED_KEYS.has(key.name)) {
     return { kind: 'none' };
   }
 

package/src/chat/log-scroll-key.ts

@@ -0,0 +1,12 @@
+export function nextChatScrollOffset(
+  current: number,
+  key: 'pageup' | 'pagedown',
+  pageSize: number,
+  maxOffset: number,
+): number {
+  if (maxOffset <= 0) return -1;
+  const offset = current < 0 ? maxOffset : Math.max(0, Math.min(current, maxOffset));
+  if (key === 'pageup') return Math.max(0, offset - pageSize);
+  const next = offset + pageSize;
+  return next >= maxOffset ? -1 : next;
+}

package/src/chat/mode/manual.ts

@@ -144,10 +144,8 @@ export function buildDashboardControlManual(opts: BuildControlManualOpts = {}):
     '- **Approval**: mutating tools (PaneInject, BroadcastPanes, TerminalModalInject,',
     '  DashboardConfigSet) pop a Y/N modal before write. Tell the user what you will do;',
     '  they confirm.',
-    '- **References**: embed `@term:<id>` / `@pane:<id>` / `@win:<N>` in your response',
-    '  to have the expander inline the referenced session/pane output for the LLM.',
-    '- **Virtual windows**: `WindowCreate` spawns a new VW; `PaneSplit` carves it. `^B 0`',
-    '  is the picker. Use `SpawnCodingAgentInVW` for a one-call claude-code/codex setup.',
+    '- **References**: embed `@term:<id>` in your response to have the expander',
+    '  inline the referenced session output for the LLM.',
     '- **Terminal sessions**: `/term spawn <cmd>` + `TerminalModalInject` + OSC 9/99/777',
     '  drive long-running CLI workflows.',
     '- **SSH remote mode**: Ctrl+K host picker; the browser pane then reads/writes over',

package/src/chat/pickers/state.ts

@@ -629,10 +629,12 @@ export function createPickerState(deps: PickerDeps): PickerState {
 
     if (key.name === 'up' || (key.ctrl && key.name === 'p')) {
       cmdPickerIdx = (cmdPickerIdx - 1 + currentArgItems.length) % currentArgItems.length;
+      pickerNavigated = true;
       return { consumed: true, action: null };
     }
     if (key.name === 'down' || (key.ctrl && key.name === 'n')) {
       cmdPickerIdx = (cmdPickerIdx + 1) % currentArgItems.length;
+      pickerNavigated = true;
       return { consumed: true, action: null };
     }
     if (key.name === 'tab') {
@@ -660,7 +662,7 @@ export function createPickerState(deps: PickerDeps): PickerState {
       const ctx = parseArgContext(buf, deps.commands);
       const selected = currentArgItems[cmdPickerIdx];
       let submitText = buf.lines[0] ?? '';
-      if (ctx && ctx.currentArg === '' && selected) {
+      if (ctx && ctx.currentArg === '' && selected && pickerNavigated) {
         submitText = submitText.slice(0, ctx.currentArgStart) + selected.value;
       }
       return {
@@ -707,32 +709,13 @@ export function createPickerState(deps: PickerDeps): PickerState {
     }
     if (key.name === 'enter' && !key.shift) {
       const selected = filtered[cmdPickerIdx];
-      const typed = (buf.lines[0] ?? '').slice(1).toLowerCase();
-      const exactMatch = selected
-        ? typed === selected.name || (selected.aliases?.includes(typed) ?? false)
-        : false;
-      if (selected && (pickerNavigated || exactMatch)) {
-        return {
-          consumed: true,
-          action: { kind: 'submit', text: '/' + selected.name },
-        };
-      }
-      // Autofill-only: rewrite the line to the full name, stay open.
-      if (selected) {
-        const newLine0 = '/' + selected.name;
-        return {
-          consumed: true,
-          action: {
-            kind: 'splice',
-            lineIdx: 0,
-            start: 0,
-            end: (buf.lines[0] ?? '').length,
-            text: newLine0,
-            newColIdx: newLine0.length,
-          },
-        };
-      }
-      return { consumed: true, action: null };
+      return {
+        consumed: true,
+        action: {
+          kind: 'submit',
+          text: pickerNavigated && selected ? '/' + selected.name : (buf.lines[0] ?? ''),
+        },
+      };
     }
     return { consumed: false };
   };

package/src/chat/search/modal.ts

@@ -157,6 +157,7 @@ export function createSearchModal(spec: SearchModalSpec): SearchModalHandle {
   const submitCurrent = (): void => {
     const item = items[cursor];
     if (item) spec.onAccept(item, query);
+    else spec.onCancel?.();
   };
 
   // SelectView as the paint engine. Filtering stays with the caller
@@ -255,8 +256,19 @@ export function createSearchModal(spec: SearchModalSpec): SearchModalHandle {
 
   // KX3 — coordinator.routeKey drives this directly. Unknown keys
   // still return 'consumed' so the modal behaves as a keyboard trap
-  // (matches legacy router contract).
-  const onKey = (ev: KeyEvent): 'consumed' | 'passthrough' => routeSearchModalKeyInput(ev, handle);
+  // (matches legacy router contract). Accept alternate terminal key names
+  // before delegating the ordinary keys to the shared router.
+  const onKey = (ev: KeyEvent): 'consumed' | 'passthrough' => {
+    if (ev.name === 'esc' || ev.name === '\x1b' || ev.sequence === '\x1b') {
+      handle.cancel();
+      return 'consumed';
+    }
+    if (ev.name === 'return') {
+      handle.accept();
+      return 'consumed';
+    }
+    return routeSearchModalKeyInput(ev, handle);
+  };
 
   const onMouse = (ev: DisplayMouseEvent): Action => {
     const localX = ev.col - spec.bounds.col;