elanous 0.2.6 → 0.2.8

package/src/cli/skills-cli.ts

@@ -0,0 +1,173 @@
+// SK2 — `elanous skills repair`: 색인이 못 읽은 스킬을 보여 주고, 확인([y/N])한 것만 그 자리에서 고친다.
+import type { Command } from 'commander';
+import { createInterface } from 'node:readline/promises';
+import { getSkillIndex, resetSkillIndex, skillIndexProblems } from '../skills/index.js';
+import { applySkillRepair, planSkillRepair, skillRepairNotice } from '../skills/repair.js';
+import { CONNECT_AGENTS, connectPrompt, connectSkillRoot, planConnect, withConnectedSource, withoutSources, type ConnectAgent } from '../skills/connect.js';
+import { debug } from '../debug/log.js';
+import { resolve } from 'node:path';
+import { claudePluginPrompt, isClaudePluginDir, mcpEnableHint, planClaudePlugin, readClaudePlugin } from '../skills/connect-claude-plugin.js';
+
+async function ask(question: string, defaultYes = false): Promise<boolean> {
+  if (!process.stdin.isTTY) return false;
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = (await rl.question(question)).trim();
+    return answer === '' ? defaultYes : /^(y|yes|예|네)$/i.test(answer);
+  }
+  finally { rl.close(); }
+}
+
+/** EN9 — `elanous connect <claude|codex>`: find the skills that agent already uses and register their folder (no copy). */
+export function registerConnectCommand(program: Command): void {
+  program.command('connect <agent>')
+    .description(`Use the skills you already have in another agent (${CONNECT_AGENTS.join(' | ')}) or a Claude Code plugin folder — registers in place, never copies; plugin MCP servers are added switched off`)
+    .option('--yes', 'Register without asking')
+    .option('--json', 'Print the plan as JSON and change nothing')
+    .option('--undo', 'Stop using that folder (the files stay where they are)')
+    .action(async (agentArg: string, opts: { yes?: boolean; json?: boolean; undo?: boolean }) => {
+      const agent = agentArg.toLowerCase() as ConnectAgent;
+      if (!CONNECT_AGENTS.includes(agent) && isClaudePluginDir(resolve(agentArg))) {
+        await connectClaudePlugin(resolve(agentArg), opts);
+        return;
+      }
+      if (!CONNECT_AGENTS.includes(agent)) {
+        console.error(`지원하는 에이전트: ${CONNECT_AGENTS.join(', ')} · 또는 Claude 플러그인 폴더(.claude-plugin/plugin.json) (받은 값: ${agentArg})`);
+        process.exitCode = 2;
+        return;
+      }
+      const { defaultSkillDirs, getUserConfig, saveUserConfig } = await import('../user-config.js');
+      const cfg = getUserConfig();
+      if (opts.undo) {
+        const root = connectSkillRoot(agent);
+        const sources = withoutSources(cfg.skills.sources, [root]);
+        if (sources.length === (cfg.skills.sources ?? []).length) { console.log(`연결된 적이 없습니다(${root}).`); return; }
+        saveUserConfig({ ...cfg, skills: { ...cfg.skills, sources } });
+        resetSkillIndex();
+        debug.log('skills.connect', 'undone', { agent });
+        console.log(`연결을 끊었습니다. 파일은 그대로 있습니다(${root}).`);
+        return;
+      }
+      const plan = planConnect(agent, defaultSkillDirs(cfg));
+      debug.log('skills.connect', 'plan', { agent, state: plan.state, count: 'skills' in plan ? plan.skills.length : 0 });
+      if (opts.json) { console.log(JSON.stringify(plan, null, 2)); return; }
+      const prompt = connectPrompt(plan);
+      if (plan.state !== 'new') { console.log(prompt); return; }
+      if (!opts.yes) {
+        if (!process.stdin.isTTY) { console.log(`${prompt.split('\n')[0]}\n가져오려면: elanous connect ${agent} --yes`); return; }
+        if (!(await ask(prompt, true))) { console.log('가져오지 않았습니다. 나중에: elanous connect ' + agent); return; }
+      } else {
+        console.log(prompt.split('\n')[0]);
+      }
+      const next = { ...cfg, skills: { ...cfg.skills, sources: withConnectedSource(cfg.skills.sources, plan.root, agent) } };
+      saveUserConfig(next);
+      resetSkillIndex();
+      const index = getSkillIndex(defaultSkillDirs(next));
+      const problems = skillIndexProblems().filter((p) => p.dir === plan.root);
+      const usable = plan.skills.length - problems.length;
+      debug.log('skills.connect', 'registered', { agent, found: plan.skills.length, problems: problems.length, indexed: index.length });
+      console.log(`연결했습니다 — ${usable}개를 바로 쓸 수 있습니다. 끊으려면: elanous connect ${agent} --undo`);
+      const notice = skillRepairNotice(problems);
+      if (notice) console.log(notice);
+    });
+}
+
+export function registerSkillsCommands(program: Command): void {
+  const skills = program.command('skills').description('Check and repair installed skills');
+  skills.command('sources')
+    .description('List every skill folder elanous reads, in order (preset · shared · connected · package)')
+    .option('--json', 'JSON output')
+    .action(async (opts: { json?: boolean }) => {
+      const { resolveSkillSources } = await import('../user-config.js');
+      const { existsSync } = await import('node:fs');
+      const sources = resolveSkillSources().map((source) => ({ ...source, exists: existsSync(source.path) }));
+      debug.log('skills.sources', 'listed', { count: sources.length, kinds: sources.map((source) => source.kind) });
+      if (opts.json) { console.log(JSON.stringify(sources, null, 2)); return; }
+      const width = Math.max(10, ...sources.map((source) => source.id.length));
+      for (const source of sources) {
+        console.log(`${source.enabled ? '●' : '○'} ${source.id.padEnd(width)}  ${source.kind.padEnd(9)} ${source.path}${source.exists ? '' : '  (없음)'}`);
+      }
+      console.log('묶음 스킬(패키지 skills/)은 늘 마지막에 읽습니다. 다른 에이전트 스킬 더하기: elanous connect claude|codex|<플러그인 폴더>');
+    });
+  skills.command('repair')
+    .description('List skills that could not be read and repair the ones that can be fixed (asks first)')
+    .option('--yes', 'Repair every fixable skill without asking')
+    .action(async (opts: { yes?: boolean }) => {
+      getSkillIndex();
+      const problems = skillIndexProblems();
+      if (!problems.length) { console.log('모든 스킬을 읽었습니다. 고칠 것이 없습니다.'); return; }
+      console.log(`스킬 ${problems.length}개를 읽지 못했습니다.`);
+      // ER1 — operations hears about it too (consented · scrubbed).
+      try {
+        const { reportError } = await import('../error-report/report.js');
+        for (const p of problems.slice(0, 3)) await reportError({ code: 'skill-index', message: `${p.name}: ${p.code ?? ''} ${p.error}`.trim(), surface: 'cli' });
+      } catch { /* reporting is advisory */ }
+      let fixed = 0;
+      for (const problem of problems) {
+        const plan = planSkillRepair(problem);
+        console.log(`\n· ${problem.name} — ${problem.error.split('\n')[0]}`);
+        if (plan.kind === 'permission' || plan.kind === 'manual') { console.log(`  ${plan.hint}`); continue; }
+        const what = plan.kind === 'fixable-permission' ? '읽기 권한을 켭니다' : `${plan.keys.join(', ')} 를 한 줄로 고칩니다(원본은 .bak 으로 남김)`;
+        if (!opts.yes && !(await ask(`  ${what}. 고칠까요? [y/N] `))) { console.log('  건너뜀'); continue; }
+        const result = applySkillRepair(plan);
+        if (result.ok) { fixed += 1; console.log(`  고쳤습니다 — ${result.path}`); }
+        else console.log(`  고치지 못했습니다(${result.reason}) — 원래대로 되돌렸습니다.`);
+      }
+      console.log(`\n${fixed}개를 고쳤습니다.`);
+      if (fixed < problems.length) process.exitCode = 1;
+    });
+}
+
+/** EN8 — a Claude Code plugin folder: skills join `skills.sources[]` (kind connected) in place, `.mcp.json` servers join `mcp.servers[]` switched off. */
+async function connectClaudePlugin(dir: string, opts: { yes?: boolean; json?: boolean; undo?: boolean }): Promise<void> {
+  const { defaultSkillDirs, getUserConfig, saveUserConfig } = await import('../user-config.js');
+  const cfg = getUserConfig();
+  let plugin;
+  try { plugin = readClaudePlugin(dir); }
+  catch (error) {
+    console.error(`플러그인 정보를 읽지 못했습니다(.claude-plugin/plugin.json): ${error instanceof Error ? error.message : String(error)}`);
+    process.exitCode = 1;
+    return;
+  }
+  const rawMcp = (cfg.raw.mcp && typeof cfg.raw.mcp === 'object' && !Array.isArray(cfg.raw.mcp) ? cfg.raw.mcp : {}) as Record<string, unknown>;
+  const rawServers = (Array.isArray(rawMcp.servers) ? rawMcp.servers : []) as Array<Record<string, unknown>>;
+  const writeServers = (servers: Array<Record<string, unknown>>) => ({ ...cfg.raw, mcp: { ...rawMcp, servers } });
+  if (opts.undo) {
+    const ids = new Set(plugin.mcp.map((server) => server.id));
+    const sources = withoutSources(cfg.skills.sources, plugin.skillRoots);
+    const servers = rawServers.filter((row) => !ids.has(row.id as string));
+    if (sources.length === (cfg.skills.sources ?? []).length && servers.length === rawServers.length) { console.log(`연결된 적이 없습니다(${plugin.name}).`); return; }
+    saveUserConfig({ ...cfg, raw: writeServers(servers), skills: { ...cfg.skills, sources } });
+    resetSkillIndex();
+    debug.log('skills.connect', 'undone', { plugin: plugin.name });
+    console.log(`«${plugin.name}» 연결을 끊었습니다. 파일은 그대로 있습니다(${plugin.root}).`);
+    return;
+  }
+  const plan = planClaudePlugin(plugin, defaultSkillDirs(cfg), rawServers.map((row) => row.id as string));
+  debug.log('skills.connect', 'plan', { plugin: plugin.name, state: plan.state, skills: plugin.skills.length, mcp: plugin.mcp.length, skipped: plugin.skipped.length });
+  if (opts.json) { console.log(JSON.stringify(plan, null, 2)); return; }
+  const prompt = claudePluginPrompt(plan);
+  if (plan.state !== 'new') { console.log(prompt); return; }
+  const firstLines = prompt.slice(0, prompt.lastIndexOf('\n'));
+  if (!opts.yes) {
+    if (!process.stdin.isTTY) { console.log(`${firstLines}\n가져오려면: elanous connect ${plugin.root} --yes`); return; }
+    if (!(await ask(prompt, true))) { console.log(`가져오지 않았습니다. 나중에: elanous connect ${plugin.root}`); return; }
+  } else {
+    console.log(firstLines);
+  }
+  const sources = plan.newSkillRoots.reduce((list, root, i) => withConnectedSource(list, root, `plugin:${plugin.name}${i ? `:${i + 1}` : ''}`), cfg.skills.sources ?? []);
+  const servers = [...rawServers, ...plan.newMcp];
+  saveUserConfig({ ...cfg, raw: writeServers(servers), skills: { ...cfg.skills, sources } });
+  resetSkillIndex();
+  const next = { ...cfg, skills: { ...cfg.skills, sources } };
+  getSkillIndex(defaultSkillDirs(next));
+  const problems = skillIndexProblems().filter((p) => plugin.skillRoots.includes(p.dir));
+  debug.log('skills.connect', 'registered', { plugin: plugin.name, skills: plugin.skills.length, problems: problems.length, mcp: plan.newMcp.length });
+  console.log(`연결했습니다 — 스킬 ${plugin.skills.length - problems.length}개를 바로 쓸 수 있습니다. 끊으려면: elanous connect ${plugin.root} --undo`);
+  const notice = skillRepairNotice(problems);
+  if (notice) console.log(notice);
+  if (plan.newMcp.length) {
+    console.log(`MCP 서버 ${plan.newMcp.length}개를 꺼진 채로 등록했습니다. 믿을 수 있는 것만 켜 주세요(켠 뒤 데몬 재시작):`);
+    for (const line of mcpEnableHint(plan.newMcp, servers)) console.log(line);
+  }
+}

package/src/cli/start-cli.ts

@@ -5,6 +5,8 @@ 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';
+import { browserUnavailableReason } from '../oauth/browser-availability.js';
+import { debug } from '../debug/log.js';
 
 export interface StartOptions {
   gui?: boolean;
@@ -63,6 +65,8 @@ export interface StartDeps {
   openTui?: (json: boolean) => Promise<number>;
   sleep?: (ms: number) => Promise<void>;
   output?: (line: string) => void;
+  browserEnv?: NodeJS.ProcessEnv;
+  browserPlatform?: NodeJS.Platform;
   /** Test seam — daemon address. `null` means this universe has no daemon (do not guess a port).
    *  Called again after a launch so the opened address is the daemon that was just started. */
   resolveEndpoint?: (opts?: ResolveDaemonEndpointOpts) => DaemonEndpoint | null;
@@ -193,10 +197,15 @@ export async function runStart(options: StartOptions = {}, deps: StartDeps = {})
       if (!openUrl) {
         record('open-gui', 'failed', 'Daemon address unknown');
       } else {
-        try {
-          if (await (deps.openGui ?? defaultOpenGui)(openUrl)) surface = 'gui';
-        } catch { /* A browser is optional; retain the URL for manual opening. */ }
-        record('open-gui', surface === 'gui' ? 'done' : 'failed', surface === 'gui' ? `Opened ${openUrl}` : `Open manually: ${openUrl}`);
+        const why = browserUnavailableReason(deps.browserEnv ?? process.env, deps.browserPlatform ?? process.platform);
+        if (why) {
+          debug.log('browser.open', 'skipped', { reason: why.includes('ssh') ? 'ssh' : 'no-display' });
+        } else {
+          try {
+            if (await (deps.openGui ?? defaultOpenGui)(openUrl)) surface = 'gui';
+          } catch { /* A browser is optional; retain the URL for manual opening. */ }
+        }
+        record('open-gui', surface === 'gui' ? 'done' : why ? 'skipped' : 'failed', surface === 'gui' ? `Opened ${openUrl}` : `Open manually: ${openUrl}${why ? ` — ${why}` : ''}`);
       }
       record('open-tui', 'skipped', 'GUI selected');
     } else {

package/src/cli/usage-cli.ts

@@ -12,9 +12,13 @@ import { consumeCodexResetCredits, listCodexResetCredits } from '../budget/codex
 import { rollupRunUsage, type RunUsageInput } from '../budget/run-usage-rollup.js';
 import { LogStore, logsDbPath, type LogQuery, type LogStoreRow } from '../mss/logging/log-store.js';
 import { LOGS_SINCE_OPTION, parseSince } from './logs-cli.js';
+import { formatCodexCreditPlan, type CodexCreditPlan } from '../budget/codex-credit-plan.js';
+import { codexCreditPlanFromDisk } from './codex-credit-plan-view.js';
 
 export interface UsageCliDeps {
   readonly collect?: typeof collectUnifiedUsage;
+  /** Codex credit plan (disk only). Returns null when it cannot be read. */
+  readonly creditPlan?: () => CodexCreditPlan | null;
   readonly out?: { log: (s: string) => void };
   /** Read-only LogStore query seam; returns stored llm-usage rows, newest first. */
   readonly readRunLogs?: (query: LogQuery) => LogStoreRow[];
@@ -61,6 +65,10 @@ function usageData(row: LogStoreRow): RunUsageInput | null {
   } catch { return null; }
 }
 
+function defaultCreditPlan(): CodexCreditPlan | null {
+  try { return codexCreditPlanFromDisk(); } catch { return null; }
+}
+
 export function registerUsageCommand(program: Command, deps: UsageCliDeps = {}): void {
   const out = deps.out ?? { log: (s: string) => console.log(s) };
   const collect = deps.collect ?? collectUnifiedUsage;
@@ -71,11 +79,13 @@ export function registerUsageCommand(program: Command, deps: UsageCliDeps = {}):
     .option('--json', 'JSON 출력 — 자격 값은 없다')
     .action(async (opts: { json?: boolean }) => {
       const report = await collect();
+      const creditPlan = (deps.creditPlan ?? defaultCreditPlan)();
       if (opts.json) {
-        out.log(JSON.stringify(report, null, 2));
+        out.log(JSON.stringify({ ...report, codexCreditPlan: creditPlan }, null, 2));
         return;
       }
       out.log(formatUnifiedUsage(report));
+      if (creditPlan) out.log(['', 'codex 크레딧', ...formatCodexCreditPlan(creditPlan).map((l) => `  ${l}`)].join('\n'));
     });
 
   usage

package/src/codex/setup.ts

@@ -62,14 +62,35 @@ export interface CodexSetupResult {
 
 // ── Picker helpers (shared with onboarding) ──────────────────────────
 
-export async function pickCodexAuthMode(io: WizardIO): Promise<CodexAuthMode> {
-  const existing = loadTokens('openai-codex');
-  if (existing) {
-    const exp = existing.tokens.expiresAt;
-    const when = exp != null
-      ? (Date.now() > exp ? 'EXPIRED' : `${Math.round((exp - Date.now()) / 60000)}min left`)
-      : 'no expiry tracked';
-    io.print(`  OAuth tokens already on file (${when}).`);
+export interface CodexAuthModeDeps {
+  loadTokens?: typeof loadTokens;
+  /** OB1 — a codex CLI login (~/.codex/auth.json) the runtime already uses; default = `inspectSubscription`. */
+  hasCodexCliLogin?: () => boolean;
+}
+
+export async function pickCodexAuthMode(io: WizardIO, deps: CodexAuthModeDeps = {}): Promise<CodexAuthMode> {
+  const existing = (deps.loadTokens ?? loadTokens)('openai-codex');
+  // OB1 (10-01): a user already signed in to the codex CLI was sent through the device-code flow again,
+  // because only elanous's own token store counted. The runtime reads ~/.codex/auth.json, so it counts too.
+  // Same judgment as the runtime (`codexOAuthAvailable` in llm.ts) — two judgments drifting apart was the bug.
+  const codexCli = !existing && (deps.hasCodexCliLogin ?? (() => {
+    try {
+      const { codexOAuthAvailable } = require('../llm.js') as typeof import('../llm.js');
+      return codexOAuthAvailable();
+    } catch { return false; }
+  }))();
+  if (existing || codexCli) {
+    if (existing) {
+      const exp = existing.tokens.expiresAt;
+      const left = exp != null ? exp - Date.now() : null;
+      const when = left == null ? '만료 시각 모름'
+        : left <= 0 ? '만료됨'
+          : left >= 86_400_000 ? `약 ${Math.round(left / 86_400_000)}일 남음`
+            : left >= 3_600_000 ? `약 ${Math.round(left / 3_600_000)}시간 남음` : `약 ${Math.max(1, Math.round(left / 60_000))}분 남음`;
+      io.print(`  이미 로그인돼 있습니다(${when}).`);
+    } else {
+      io.print('  Codex CLI 에 있는 ChatGPT/Codex 로그인을 찾았습니다(~/.codex/auth.json).');
+    }
     // Sprint 11 — chooseFrom Yes/No so fullScreenIO renders the arrow
     // picker (with 'y'/'n' + 한글 자모 quick-pick from PR #986 + #988)
     // instead of a bare text input. The runner distinguishes 'oauth-keep'
@@ -77,10 +98,10 @@ export async function pickCodexAuthMode(io: WizardIO): Promise<CodexAuthMode> {
     // rotation on an unnecessary refresh).
     const keep = await chooseFrom<boolean>(
       io,
-      'Keep using existing OAuth tokens?',
+      '지금 로그인을 그대로 쓸까요?',
       [
-        { key: 'y', label: 'Yes — keep them', value: true },
-        { key: 'n', label: 'No — re-run device-code flow', value: false },
+        { key: 'y', label: '예 — 그대로 씁니다', value: true },
+        { key: 'n', label: '아니오 — 다시 로그인합니다', value: false },
       ],
       { defaultIndex: 0 },
       undefined,
@@ -246,18 +267,18 @@ async function runCodexSetupImpl(
   let apiKey: string | undefined = initial.llm.apiKey;
 
   if (authMode === 'oauth') {
-    io.print('  Launching device-code flow…');
+    io.print('  코드로 로그인합니다…');
     try {
       await loginWithCodex({
         onProgress: (p) => {
           if (p.type === 'user_code') {
             io.print('');
-            io.print(`    1) Open in any browser: ${p.loginUrl}`);
-            io.print(`    2) Enter code:          ${p.userCode}`);
+            io.print(`    1) 아무 브라우저에서 열기: ${p.loginUrl}`);
+            io.print(`    2) 코드 입력:             ${p.userCode}`);
             io.print('');
-            io.print('  Waiting for sign-in…');
+            io.print('  로그인을 기다리는 중…');
           }
-          if (p.type === 'saved') io.print('  Signed in. Tokens saved.');
+          if (p.type === 'saved') io.print('  로그인했습니다. 저장했습니다.');
         },
         fetchImpl: opts.fetchImpl,
         sleepImpl: opts.sleepImpl,

package/src/dashboard/index.ts

@@ -725,7 +725,8 @@ import { SELF_IMPLEMENT_TOOL_NAMES } from '../boot/daemon-tools/self-implement-n
 import { FOLD_LIMITS, type FoldMode } from '../log-entry.js';
 import { renderToolCallEvent, renderToolResultVariants } from '../chat/tool-render/index.js';
 import { FoldStack } from '../fold-stack.js';
-import { getSkillIndex, reloadSkillIndex, applySkillFilter } from '../skills/index.js';
+import { getSkillIndex, reloadSkillIndex, applySkillFilter, skillIndexProblems } from '../skills/index.js';
+import { skillRepairNotice } from '../skills/repair.js';
 import type { DetectResult } from '../skills/router.js';
 import { detectUrlRoute } from '../skills/url-router.js';
 import {
@@ -7190,6 +7191,21 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
   // and after each user-initiated skill cursor change.
   const skillView: SkillViewState = createSkillViewState(LOCAL_SKILLS_DIR);
   try { refreshSkills(skillView); refreshSkillFiles(skillView); } catch { /* missing root fine */ }
+  // SK2 — a skill the index could not read is a one-line notice with the repair command, never a crash.
+  try {
+    getSkillIndex();
+    const problems = skillIndexProblems();
+    const notice = skillRepairNotice(problems);
+    if (notice) chatLines.push(C.info(notice));
+    // ER1 — tell operations too (consented · scrubbed · async); a kept unsent report is retried once a day.
+    void import('../error-report/report.js').then(async ({ reportError, retryPendingErrorReport }) => {
+      await retryPendingErrorReport();
+      for (const p of problems.slice(0, 3)) {
+        const outcome = await reportError({ code: 'skill-index', message: `${p.name}: ${p.code ?? ''} ${p.error}`.trim(), surface: 'tui' });
+        if (outcome.sent && outcome.reportId) { chatLines.push(C.muted(`  운영팀에 알렸습니다 (보고 번호 ${outcome.reportId})`)); }
+      }
+    }).catch(() => { /* reporting never breaks the dashboard */ });
+  } catch { /* the notice is advisory */ }
 
   // Scratch visibility (Phase S5). When closed, the workingDir
   // layouts drop the scratch cell so the remaining panes expand
@@ -16779,7 +16795,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
             preferHistoryArrowKeys: slashQuickMode,
             history: inputHistory,
             placeholder: anyProviderAvailable()
-              ? '/command, or type a question (inline /path/to.pdf to attach)'
+              ? '말 한 줄로 시작 — 질문하거나 «하니스로 구현 …» · /command · /path/to.pdf 첨부'
               : '/quit /clear (run `elanous setup` — no LLM provider available)',
             debugLog: debug.enabled ? (event, label, payload) => debug.log(event, label, payload) : undefined,
             textInputOpts: {

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

@@ -1370,8 +1370,8 @@ export function buildDashboardSlashRegistry(): SlashCommandRegistry<DashboardSla
     ctx.attachmentRowMap.clear();
     ctx.clearLogSearch();
     ctx.clearLogFilter();
-    ctx.pushDebugLine(ctx.muted('Status cleared'));
-    ctx.chatLines.push(ctx.muted('Status cleared'));
+    ctx.pushDebugLine(ctx.muted('Chat log cleared'));
+    ctx.chatLines.push(ctx.muted('Chat log cleared'));
     ctx.setChatScrollOffset(-1);
   });
 

package/src/dashboard/slash-runtime/help-from-registry.ts

@@ -3,7 +3,9 @@ import { visibleWidth } from '../../tui.js';
 
 const ESSENTIAL_KEYS = [
   ['Enter', 'Send message'],
-  ['Esc', 'Clear input / close help modal'],
+  // U1 · 2026-10-02 — stopping and queueing while an answer streams were missing from help (same line count:
+  // the modal has a row budget and falls back to the chat log when it is exceeded).
+  ['Esc', 'Stop the answer (Esc again = rewind) · clear input / close help'],
   ['Ctrl+U', 'Clear text before cursor'],
   ['Ctrl+W', 'Delete previous word'],
   ['Ctrl+← / →', 'Move by word'],
@@ -11,7 +13,7 @@ const ESSENTIAL_KEYS = [
   ['Home / End', 'Move to start / end of line'],
   ['Ctrl+A / E', 'Move to start / end of line'],
   ['PgUp / PgDn', 'Scroll chat log'],
-  ['Ctrl+↑', 'Recall sent line while streaming'],
+  ['Ctrl+↑', 'Recall a queued line (Enter while answering queues it)'],
 ] as const;
 
 function fitLine(text: string, width: number): string {