dsh-code 1.0.6 → 1.2.0

package/lib/types/locales/en.d.ts

@@ -0,0 +1,450 @@
+/**
+ * The English message catalog: every user-visible UI string the terminal
+ * renders, keyed for {@link t}. The catalog is a plain record so missing
+ * keys fail typecheck against the shared key union, not at runtime.
+ *
+ * @module @deepseek-ai/dsh-tui/locales/en
+ */
+export declare const en: {
+    readonly 'panel.close': "esc/q close";
+    readonly 'panel.moveEnterSelect': "↑↓ move · enter select · esc close";
+    readonly 'panel.moveEnterSelectBack': "↑↓ move · enter select · esc back · q close";
+    readonly 'panel.scrollEnds': "↑↓ scroll · pgup/pgdn page · g/G ends · esc/q close";
+    readonly 'panel.loading': "loading…";
+    readonly 'panel.loadFailed': "load failed";
+    readonly 'panel.noMatch': "no matching entries";
+    readonly 'panel.emptyClose': "esc close";
+    readonly 'panel.searchIdle': "search: type to filter";
+    readonly 'panel.searchIdleStop': "search: type to filter · esc stops";
+    readonly 'panel.searchPrefix': "search: ";
+    readonly 'language.title': "/language — interface language";
+    readonly 'language.hint': "↑↓ move · enter apply · esc/q close";
+    readonly 'theme.title': "/theme — color palette";
+    readonly 'theme.compact': "/theme · esc close";
+    readonly 'theme.current': "current";
+    readonly 'theme.dark.label': "dark";
+    readonly 'theme.dark.description': "DeepSeek dark palette (default)";
+    readonly 'theme.light.label': "light";
+    readonly 'theme.light.description': "light palette for bright terminals";
+    readonly 'theme.prismatic.label': "prismatic";
+    readonly 'theme.prismatic.description': "neon synthwave palette (violet/magenta/cyan)";
+    readonly 'theme.rainbow.label': "rainbow";
+    readonly 'theme.rainbow.description': "randomized carnival palette (/rainbow to reroll)";
+    readonly 'theme.auto.label': "auto";
+    readonly 'theme.auto.description': "follow the terminal; dark until detection lands";
+    readonly 'history.title.prompts': "/history · {count} prompts · type to filter";
+    readonly 'history.title.match': "/history · {matches} of {count} match '{query}'";
+    readonly 'history.filterHint': "filter {state}, enter fills the composer";
+    readonly 'history.filterEmpty': "· type to search prompts";
+    readonly 'history.filterQuery': "· {query}";
+    readonly 'history.empty': "no matching prompts";
+    readonly 'history.compact.none': "no matching prompts";
+    readonly 'history.footer': "↑↓ move · g/G ends · enter fill · esc close";
+    readonly 'search.title.type': "/search · type a query and press enter";
+    readonly 'search.title.hits': "/search · {count} hit for '{query}'";
+    readonly 'search.title.hitsPlural': "/search · {count} hits for '{query}'";
+    readonly 'search.hint': "{state} · enter searches or resumes";
+    readonly 'search.hintEmpty': "type to search sessions";
+    readonly 'search.empty.idle': "full-text search across every persisted session";
+    readonly 'search.empty.noHits': "no matching sessions{loading}";
+    readonly 'search.compact.noResults': "no results yet";
+    readonly 'search.compact.searching': "searching…";
+    readonly 'search.compact.error': "error: {message}";
+    readonly 'search.footer': "↑↓ move · enter search/resume · esc close";
+    readonly 'statusline.title': "/statusline · items apply to the live status line below";
+    readonly 'schedule.title': "/schedule · {count} active reminder";
+    readonly 'schedule.titlePlural': "/schedule · {count} active reminders";
+    readonly 'schedule.empty': "no active reminders — the model creates them with schedule_create";
+    readonly 'document.loading': "loading transcript…";
+    readonly 'document.compact': "transcript · esc close";
+    readonly 'document.footer': "lines {from}-{to}/{total} · ↑↓/pg/g/G · t/esc close";
+    readonly 'review.picker.title': "/review · choose a target";
+    readonly 'review.picker.uncommitted': "Review uncommitted changes (staged / unstaged / new files)";
+    readonly 'review.picker.branch': "Compare against a base branch (lists local branches)";
+    readonly 'review.picker.commit': "Review a commit on the current branch (lists recent commits)";
+    readonly 'review.picker.custom': "Custom review focus (type it)";
+    readonly 'review.picker.customHint': "type your focus, then enter to start the review";
+    readonly 'review.picker.branches': "{filtered} of {total} branches";
+    readonly 'review.picker.commits': "{filtered} of {total} commits";
+    readonly 'review.picker.loadingBranches': "loading branches…";
+    readonly 'review.picker.loadingCommits': "loading commits…";
+    readonly 'review.picker.empty': "no candidates";
+    readonly 'review.picker.noMatch': "no matches";
+    readonly 'review.picker.loading': "loading…";
+    readonly 'review.picker.loadFailed': "load failed";
+    readonly 'review.picker.compact': "pick a review target";
+    readonly 'review.picker.footer': "↑↓ move · enter select · esc back · q close";
+    readonly 'review.summary.untagged': "untagged×{n}";
+    readonly 'review.summary.incorrect': "patch incorrect";
+    readonly 'review.summary.correctClean': "no issues found";
+    readonly 'review.summary.correct': "patch correct";
+    readonly 'review.summary.noConclusion': "review finished: no structured conclusion";
+    readonly 'review.summary.zero': "review finished: 0 findings · {verdict}";
+    readonly 'review.summary.count': "review finished: {count} findings ({parts})";
+    readonly 'review.summary.countVerdict': "review finished: {count} findings ({parts}) · {verdict}";
+    readonly 'review.notice.started': "review started under read-only permissions";
+    readonly 'review.notice.failed': "review failed: {message}";
+    readonly 'review.notice.unavailable': "review unavailable: {message}";
+    readonly 'cmd.help': "show this overlay";
+    readonly 'cmd.model': "switch the model and manage providers";
+    readonly 'cmd.effort': "adjust reasoning effort for the current model";
+    readonly 'cmd.mode': "inspect or select the agent preset (/mode [preset])";
+    readonly 'cmd.permission': "inspect or select the permission preset (/permission [preset])";
+    readonly 'cmd.new': "create and switch to a fresh session (/new [preset])";
+    readonly 'cmd.fork': "fork at the latest completed turn (/fork [event-seq])";
+    readonly 'cmd.resume': "browse or switch root sessions (/resume [id|prefix])";
+    readonly 'cmd.search': "full-text search across persisted sessions (/search [query])";
+    readonly 'cmd.plugin': "inspect the live plugin composition";
+    readonly 'cmd.update': "update dsh-code, the harness host, and profile plugins in one aligned step";
+    readonly 'cmd.jobs': "inspect background jobs";
+    readonly 'cmd.schedule': "inspect active reminders (created through schedule tools)";
+    readonly 'cmd.statusline': "customize the status line items";
+    readonly 'cmd.theme': "switch the color theme";
+    readonly 'cmd.language': "switch the interface language (/language [en|zh])";
+    readonly 'cmd.rainbow': "reroll or pin the rainbow palette (/rainbow [seed])";
+    readonly 'cmd.animation': "toggle timed animations (/animation [on|off])";
+    readonly 'cmd.history': "search and recall past prompts";
+    readonly 'cmd.queue': "manage messages queued for the next turn";
+    readonly 'cmd.usage': "show this session token usage";
+    readonly 'cmd.agents': "inspect subagent sessions of this conversation";
+    readonly 'cmd.todos': "inspect the full todo list";
+    readonly 'cmd.subagent': "choose the model delegated subagents run on";
+    readonly 'cmd.vscode-keys': "pass ctrl+r through the vs code terminal";
+    readonly 'cmd.delete': "delete a session and its subagent threads";
+    readonly 'cmd.clear': "clear the screen";
+    readonly 'cmd.export': "export the transcript to markdown (/export [path])";
+    readonly 'cmd.title': "rename this session (/title <text>)";
+    readonly 'cmd.copy': "copy the latest assistant response";
+    readonly 'cmd.diff': "inspect Git changes (/diff [--staged|ref])";
+    readonly 'cmd.review': "review Git changes with the diff pasted in this session (/review [note])";
+    readonly 'cmd.quit': "exit";
+    readonly 'help.keysTitle': " keys";
+    readonly 'help.key.submit': "enter submit · ctrl+j / alt+enter newline · up/down history · tab complete";
+    readonly 'help.key.mentions': "@ mentions workspace files and sessions";
+    readonly 'help.key.inspector': "ctrl+o history details · ctrl/alt+r thinking · shift+tab permission preset";
+    readonly 'help.key.cancel': "esc interrupt the running turn · ctrl+c cancel / clear / quit · ctrl+d exit";
+    readonly 'help.key.queue': "empty tab picks queue or steer · /queue manages queued messages · delete cancels the newest one";
+    readonly 'help.key.edit': "ctrl+k cut to end of line · ctrl+u clear line · ctrl+a / ctrl+e line ends";
+    readonly 'help.commandsTitle': " commands";
+    readonly 'help.skillsTitle': " skills";
+    readonly 'help.footer': "↑↓ scroll · pgup/pgdn page · g/G ends · esc/q close";
+    readonly 'help.compact': "/help · esc/q close";
+    readonly 'panel.queue.title': "/queue — {count} queued · rows {from}-{to}";
+    readonly 'panel.queue.empty': "  no messages queued for the next turn";
+    readonly 'panel.queue.attachments': "[attachments: read-only]";
+    readonly 'panel.queue.footerBusy': "↑↓ select · enter steer · e edit text · d remove · esc/q close";
+    readonly 'panel.queue.footerIdle': "↑↓ select · e edit text · d remove · esc/q close";
+    readonly 'panel.queue.editFooter': "type · ←→ move · enter save · esc cancel";
+    readonly 'panel.queue.compact': "/queue · esc/q close";
+    readonly 'panel.usage.title': "/usage — usage of this session";
+    readonly 'panel.usage.compact': "/usage · esc/q close";
+    readonly 'panel.usage.footer': "↑↓ scroll · pgup/pgdn page · g/G ends · esc/q close";
+    readonly 'panel.usage.totals': "Totals (whole session)";
+    readonly 'panel.usage.uncached': "uncached in";
+    readonly 'panel.usage.cacheWrite': "cache write";
+    readonly 'panel.usage.cacheRead': "cache read";
+    readonly 'panel.usage.output': "out";
+    readonly 'panel.usage.total': "total";
+    readonly 'panel.usage.cacheHit': "cache hit";
+    readonly 'panel.usage.turns': "Per turn";
+    readonly 'panel.usage.byModel': "By model";
+    readonly 'panel.usage.colTurns': "turns";
+    readonly 'panel.usage.unknownModel': "unattributed";
+    readonly 'panel.usage.colTurn': "turn";
+    readonly 'panel.usage.colTotal': "total";
+    readonly 'panel.usage.colUncached': "uncached";
+    readonly 'panel.usage.colCacheRead': "cache R";
+    readonly 'panel.usage.colCacheHit': "hit";
+    readonly 'panel.usage.colCacheWrite': "cache W";
+    readonly 'panel.usage.colOut': "out";
+    readonly 'panel.usage.colThink': "think";
+    readonly 'panel.usage.colModel': "model";
+    readonly 'panel.usage.partialNote': "+ marks a group where some turns did not report that bucket; only reported turns are counted";
+    readonly 'panel.usage.unavailable': "token projections are not mounted in this deployment (dsh-token-meter is missing)";
+    readonly 'panel.usage.noTurns': "no completed turn yet";
+    readonly 'status.cycleHint': "(shift+tab to cycle)";
+    readonly 'approval.compact': "approval{queued} · enter/y allow · esc/n reject";
+    readonly 'approval.overflow': "… +{count} more lines · ctrl+o shows the full call in the transcript";
+    readonly 'question.compact.plan': "plan review · esc cancel";
+    readonly 'question.compact.normal': "question · esc cancel";
+    readonly 'approval.submitted': "submitted…";
+    readonly 'approval.footer': "↑↓ choose · enter confirm · y/n/d quick · esc reject";
+    readonly 'question.footer': "↑↓ choose · 1-9 select · space toggle · enter submit · esc cancel";
+    readonly 'question.custom': "type a custom answer";
+    readonly 'question.submitted': "submitted…";
+    readonly 'question.customNoOptions': "↑↓/pgup/pgdn scroll · type answer · enter submit · esc interrupt";
+    readonly 'question.customOptions': "↑↓/pgup/pgdn scroll · type answer · enter submit · tab/esc or empty backspace: options";
+    readonly 'question.multiOptions': "↑↓ choose · pgup/pgdn scroll · space/1-9 toggle · enter submit · c custom · esc interrupt";
+    readonly 'question.singleOptions': "↑↓ choose · pgup/pgdn scroll · 1-9 pick · enter submit · c custom · esc interrupt";
+    readonly 'question.switch': " · ←→/ctrl+p/n switch question";
+    readonly 'question.title.plan': "📋 plan review";
+    readonly 'question.title.normal': "❓ question";
+    readonly 'composer.placeholder': "type a message · / commands · @ mentions · tab steers";
+    readonly 'composer.placeholderSteer': "steer into this turn · tab queues for the next one";
+    readonly 'notice.submitMode.queue': "send → queue for the next turn";
+    readonly 'notice.submitMode.steer': "send → steer into this turn (only while one runs; idle it sends normally)";
+    readonly 'entry.delivery.queued': "queued";
+    readonly 'entry.delivery.steered': "steered";
+    readonly 'status.shiftTabHint': "(shift+tab to cycle)";
+    readonly 'status.label.turns': "turns";
+    readonly 'status.label.steps': "steps";
+    readonly 'status.label.modelTime': "model";
+    readonly 'status.label.latency': "latency";
+    readonly 'status.label.tokensPerSec': " tokens/s";
+    readonly 'status.label.tool': "tool";
+    readonly 'status.label.cache': "cache";
+    readonly 'status.label.in': "in";
+    readonly 'status.label.out': "out";
+    readonly 'status.label.mode': "/mode";
+    readonly 'status.label.context': "context";
+    readonly 'frozen.keysGoTo': "keys go to {owner} · esc {action}";
+    readonly 'frozen.action.rejects': "rejects";
+    readonly 'frozen.action.cancels': "cancels";
+    readonly 'frozen.action.closes': "closes";
+    readonly 'time.justNow': "now";
+    readonly 'time.minutesAgo': "{n}m ago";
+    readonly 'time.hoursAgo': "{n}h ago";
+    readonly 'time.daysAgo': "{n}d ago";
+    readonly 'notice.themeSaved': "theme → {name}";
+    readonly 'notice.themeRainbow': "theme → rainbow · seed {seed} · /rainbow to reroll";
+    readonly 'notice.rainbowRolled': "rainbow · seed {seed} · /rainbow to reroll · /rainbow {seed} to pin";
+    readonly 'notice.languageSaved': "language → {name}";
+    readonly 'notice.themeSaveFailed': "theme save failed: {message}";
+    readonly 'notice.languageSaveFailed': "language save failed: {message}";
+    readonly 'notice.alreadyActive': "that session is already active";
+    readonly 'notice.queueCancelled': "queued message cancelled";
+    readonly 'notice.queueActionFailed': "queue action failed: {message}";
+    readonly 'notice.queueUnavailable': "queued message is no longer pending";
+    readonly 'notice.queueSteerUnavailable': "steering is available only while the turn is running";
+    readonly 'notice.queueEditEmpty': "queued message cannot be empty";
+    readonly 'notice.queueEdited': "queued message edited";
+    readonly 'notice.queueSteered': "queued message moved into this turn";
+    readonly 'notice.historySaveFailed': "history save failed: {message}";
+    readonly 'notice.turnCancelled': "turn cancelled — Ctrl+C or /quit to exit";
+    readonly 'notice.turnCancelledKeepQueue': "turn cancelled — pending messages are preserved · Ctrl+C or /quit to exit";
+    readonly 'notice.noSessionYet': "no session yet — submit a message to start";
+    readonly 'notice.usage.animation': "usage: /animation [on|off]";
+    readonly 'notice.usage.language': "usage: /language [en|zh]";
+    readonly 'notice.usage.rainbow': "usage: /rainbow [seed]";
+    readonly 'notice.imageCancelled': "image submission cancelled";
+    readonly 'notice.themeConfigUnreadable': "theme config unreadable, using dark: {message}";
+    readonly 'notice.languageConfigUnreadable': "language config unreadable, using english: {message}";
+    readonly 'notice.animationsConfigUnreadable': "animations config unreadable, animations stay on: {message}";
+    readonly 'notice.statuslineConfigUnreadable': "statusline config unreadable, using defaults: {message}";
+    readonly 'notice.sessionSearchUnavailable': "session search is unavailable in this deployment";
+    readonly 'notice.subagentsReadOnly': "subagent conversations are read-only";
+    readonly 'notice.statuslineSaveFailed': "statusline save failed: {message}";
+    readonly 'notice.animationsSaveFailed': "animations save failed: {message}";
+    readonly 'notice.commandRegistryMissing': "no command registry is mounted in this composition";
+    readonly 'notice.commandFallbackFailed': "command fallback failed: {message}";
+    readonly 'notice.commandFailed': "command failed: {message}";
+    readonly 'notice.invalidReference': "invalid session reference: {message}";
+    readonly 'notice.messageFailed': "{kind} failed: {message}";
+    readonly 'notice.referenceFailed': "session reference failed: {message}";
+    readonly 'notice.activationFailed': "session activation failed: {message}";
+    readonly 'notice.creationFailed': "session creation failed: {message}";
+    readonly 'notice.modeChanged': "mode → {value}";
+    readonly 'notice.modeSwitchFailed': "mode switch failed: {message}";
+    readonly 'notice.permissionChanged': "permission → {value}";
+    readonly 'notice.permissionChangeFailed': "permission change failed: {message}";
+    readonly 'notice.cancelFailed': "cancel failed: {message}";
+    readonly 'notice.modeChangeFailed': "mode change failed: {message}";
+    readonly 'notice.modelNotDefault': "model switch applies to this session but was not saved as the default: {message}";
+    readonly 'notice.modelSelectionRejected': "model selection rejected: {message} — reopen /model to pick again";
+    readonly 'notice.exported': "exported to {path}";
+    readonly 'notice.exportFailed': "export failed: {message}";
+    readonly 'notice.resumeFailed': "resume failed: {message}";
+    readonly 'notice.forkFailed': "fork failed: {message}";
+    readonly 'notice.sessionSwitchFailed': "session switch failed: {message}";
+    readonly 'notice.switchQueued': "will switch to {label} when the current turn finishes · /resume cancel to abort";
+    readonly 'notice.reviewStarted': "review started under read-only permissions";
+    readonly 'notice.reviewFailed': "review failed: {message}";
+    readonly 'notice.reviewUnavailable': "review unavailable: {message}";
+    readonly 'notice.startupImages': "processing {count} startup image{plural}…";
+    readonly 'notice.startupImagesAttached': "{count} startup image{plural} attached";
+    readonly 'notice.initialPromptFailed': "initial prompt failed: {message}";
+    readonly 'notice.rejected': "rejected — type below what it should do differently (it steers the next step)";
+    readonly 'notice.attachmentAlready': "{name} is already attached";
+    readonly 'notice.attachmentsChecking': "checking {count} attachment{plural}…";
+    readonly 'notice.attachmentsAlready': "those attachments are already attached";
+    readonly 'notice.attachmentDraftChanged': "draft changed at the attachment drop point; drop the files again";
+    readonly 'notice.attachmentsReady': "{count} attachment{plural} ready for the next message";
+    readonly 'notice.attachmentFailed': "attachment failed: {message}";
+    readonly 'notice.imageChecking': "checking image {name}…";
+    readonly 'notice.imageDraftChanged': "draft changed around the image mention; select it again";
+    readonly 'notice.imageReady': "{name} ready for the next message";
+    readonly 'notice.imageFailed': "image attachment failed: {message}";
+    readonly 'notice.cancelBeforeExit': "cancel the running turn before exiting (Esc or Ctrl+C)";
+    readonly 'notice.commandAttachments': "commands cannot carry attachments; the line will be sent to the model as a prompt";
+    readonly 'notice.copyFailed': "copy failed: {message}";
+    readonly 'notice.vscodeKeysFailed': "vscode-keys failed: {message}";
+    readonly 'notice.animationState': "animations {state}";
+    readonly 'notice.deleteFailed': "delete failed: {message}";
+    readonly 'notice.modelChangedPlaceholder': "model → {model} · image history will be sent as text placeholders";
+    readonly 'notice.modelNextStep': "model → next step uses {model}";
+    readonly 'notice.modelSwitchFailed': "model switch failed: {message}";
+    readonly 'notice.loggedIn': "logged in to {provider}; select a model";
+    readonly 'notice.loggedOut': "logged out from {provider}";
+    readonly 'notice.providerSaved': "provider configuration saved: {provider}{suffix}";
+    readonly 'notice.apiKeyRemoved': "API key removed for {provider}";
+    readonly 'notice.providerRemoved': "provider removed: {provider}";
+    readonly 'notice.providerUnavailable': "provider configuration is unavailable in this profile";
+    readonly 'notice.apiKeyUnavailable': "API key removal is unavailable in this profile";
+    readonly 'notice.providerRemovalUnavailable': "provider removal is unavailable in this profile";
+    readonly 'notice.loginIdleOnly': "provider login is available only while the agent is idle";
+    readonly 'notice.loginUnavailable': "provider login is unavailable in this profile";
+    readonly 'notice.logoutUnavailable': "provider logout is unavailable in this profile";
+    readonly 'notice.modeChangedSimple': "mode → {value}";
+    readonly 'notice.permissionChangedSimple': "permission → {value}";
+    readonly 'notice.subagentsChanged': "subagents → {value}";
+    readonly 'notice.subagentsInherited': "subagents → inherit current model";
+    readonly 'notice.subagentChangeFailed': "subagent model change failed: {message}";
+    readonly 'notice.modelMissing': "current model is not in the catalog";
+    readonly 'notice.effortUnavailable': "reasoning levels temporarily unavailable (capability lookup failed) — try again";
+    readonly 'notice.modelLookupFailed': "model lookup failed: {message}";
+    readonly 'notice.diffFailed': "diff failed: {message}";
+    readonly 'panel.footer.chooseSwitch': "↑↓ choose · enter switch · r refresh · esc close";
+    readonly 'panel.footer.chooseSelect': "↑↓ choose · enter select · r refresh · esc close";
+    readonly 'panel.footer.inspectDetails': "↑↓ inspect · enter details · r refresh · esc close";
+    readonly 'panel.footer.inspectRefresh': "↑↓ inspect · r refresh · esc close";
+    readonly 'panel.footer.resume': "tab/←→ filters · ↑↓/pg navigate · ctrl+f search · e details · t transcript · d delete · enter resume";
+    readonly 'panel.footer.transcript': "lines {from}-{to}/{total} · ↑↓/pg/g/G · t/esc close";
+    readonly 'panel.footer.history': "↑↓ move · g/G ends · enter fill · esc close";
+    readonly 'panel.footer.review': "↑↓ move · enter select · esc back · q close";
+    readonly 'panel.footer.statusline': "↑↓ move · space toggle · ←→ reorder · d default · esc close";
+    readonly 'panel.footer.schedule': "esc/q close{more} · the model schedules via schedule_create";
+    readonly 'panel.mode.title': "/mode · current {current}";
+    readonly 'panel.permission.title': "/permission · current {current}";
+    readonly 'panel.plugin.title': "/plugin · loader inspector";
+    readonly 'panel.jobs.title': "/jobs · background tasks · {count}";
+    readonly 'panel.resume.deleteTitle': "permanently delete {target}? this cannot be undone · subagent threads go too";
+    readonly 'panel.resume.title': "/resume{mode}{search} · {toolbar}";
+    readonly 'panel.noActiveReminders': "no active reminders — the model schedules via schedule_create";
+    readonly 'panel.notMounted': "not mounted";
+    readonly 'panel.broken': "broken: {message}";
+    readonly 'panel.live': "live";
+    readonly 'panel.parent': "parent {id}";
+    readonly 'panel.deleteMode': "delete mode";
+    readonly 'panel.searching': "searching";
+    readonly 'panel.noPresets': "no presets";
+    readonly 'panel.noPermissions': "no permission presets";
+    readonly 'panel.noJobs': "no background jobs";
+    readonly 'panel.diff.compact': "{title} · {files} files · esc/q close";
+    readonly 'panel.diff.noFiles': "no files";
+    readonly 'panel.diff.footer': "↑/↓ scroll · g/G ends · esc/q close";
+    readonly 'panel.todos.compact': "todos · esc/q close";
+    readonly 'panel.todos.title': "todos · {done}/{total} done · {active} active · {pending} pending · rows {from}-{to}/{rows}";
+    readonly 'panel.todos.empty': "no todos yet";
+    readonly 'panel.todos.footer': "↑↓ scroll · pgup/pgdn page · g/G ends · esc/q close";
+    readonly 'panel.verbose.compact': "history details · ctrl+o / esc / q close";
+    readonly 'panel.verbose.footer': "←→ entry · ↑↓ scroll · pgup/pgdn page · g/G ends · ctrl+o/esc/q close";
+    readonly 'panel.model.compact': "/model · {state}{providers} · {tail}";
+    readonly 'panel.model.noMatch': "no models match '{query}'";
+    readonly 'panel.model.compactNoMatch': "no match for '{query}'";
+    readonly 'panel.model.loading': "loading…";
+    readonly 'panel.model.error': "error";
+    readonly 'panel.model.noModels': "no models available";
+    readonly 'panel.model.selectTitle': "/model — select model";
+    readonly 'panel.model.matches': "{filtered} of {total} match '{query}'";
+    readonly 'panel.model.footer.filter': "type to filter · r retry · esc/q close";
+    readonly 'panel.model.footer.filtered': "backspace edits · esc close";
+    readonly 'panel.model.title': "/model — select model";
+    readonly 'panel.model.titleCount': "/model — select model · {index}/{total}";
+    readonly 'panel.model.titleMatches': "/model — select model · {filtered} of {total} match '{query}'";
+    readonly 'panel.model.footer.select': "type to filter · ↑↓ move · pgup/pgdn page · enter select{providers} · r retry · esc/q close";
+    readonly 'panel.model.footer.filteredSelect': "↑↓ move · pgup/pgdn page · enter select · backspace edits · esc close";
+    readonly 'panel.model.providers': "tab providers";
+    readonly 'panel.provider.failure': "unavailable providers: {providers}";
+    readonly 'panel.provider.loading': "loading providers…";
+    readonly 'panel.provider.empty': "no configurable providers";
+    readonly 'panel.provider.notConfigured': "not configured";
+    readonly 'panel.provider.configured': "configured";
+    readonly 'panel.provider.keyMissing': "key missing";
+    readonly 'panel.provider.keyStatusUnavailable': "key status unavailable";
+    readonly 'panel.provider.auth': "provider auth";
+    readonly 'panel.provider.active': "active";
+    readonly 'panel.provider.dormant': "dormant";
+    readonly 'panel.provider.readOnly': "read-only";
+    readonly 'panel.provider.custom': "custom";
+    readonly 'panel.provider.notConfiguredDivider': "── not configured ──";
+    readonly 'panel.provider.title': "/model — providers";
+    readonly 'panel.provider.titleCount': "/model — providers · {index}/{total}";
+    readonly 'panel.provider.state': "{route} · {value}";
+    readonly 'panel.provider.key': "key {value}";
+    readonly 'panel.provider.authConfigured': "provider auth";
+    readonly 'panel.provider.noKey': "key missing";
+    readonly 'panel.provider.noLogin': "not configured";
+    readonly 'panel.provider.loginStatusUnavailable': "login status unavailable: {message}";
+    readonly 'panel.provider.noConfiguredKey': "this provider has no configured API key to remove";
+    readonly 'panel.provider.readOnlyKey': "this API key is supplied read-only by the environment";
+    readonly 'panel.provider.notRemovable': "this provider profile is not removable";
+    readonly 'panel.provider.noLoginFlow': "this provider offers no interactive login flow";
+    readonly 'panel.provider.loginRunning': "a login attempt is already running for this provider";
+    readonly 'panel.provider.noLoginRecord': "this provider has no login record to remove";
+    readonly 'panel.provider.readOnlyLogin': "this login record is read-only";
+    readonly 'panel.provider.notManaged': "this provider is not managed by Harness settings";
+    readonly 'panel.providers.compact': "/model providers · enter configure · d remove key · esc back";
+    readonly 'panel.providers.footer': "↑↓ move · enter configure · l login · o logout · d remove key · x remove provider · r retry · esc back";
+    readonly 'panel.update.compact': "/update · {summary}";
+    readonly 'panel.update.checking': "checking…";
+    readonly 'panel.update.probeFailed': "probe failed";
+    readonly 'panel.update.updating': "updating…";
+    readonly 'panel.update.installed': "installed — restart to activate";
+    readonly 'panel.update.failed': "failed";
+    readonly 'panel.update.upToDate': "up to date";
+    readonly 'panel.update.aheadOfNpm': "newer than npm";
+    readonly 'panel.update.enter': "enter updates";
+    readonly 'panel.update.blocked': "blocked";
+    readonly 'panel.update.title': "/update · aligned upgrade";
+    readonly 'panel.auth.methodsFooter': "↑↓ choose · enter continue · esc/q back";
+    readonly 'panel.auth.answerFooter': "enter answer · c copy URL/code · esc cancel login";
+    readonly 'panel.auth.title': "/model · login {provider}";
+    readonly 'panel.auth.waiting': "waiting for provider…";
+    readonly 'panel.auth.compact': "provider login · esc cancel";
+    readonly 'panel.auth.logoutCompact': "y logout · n/esc back";
+    readonly 'panel.auth.logoutTitle': "/model · logout provider";
+    readonly 'panel.auth.removeRecord': "remove {provider} login record";
+    readonly 'panel.auth.unchanged': "provider endpoint and model configuration stay unchanged";
+    readonly 'panel.auth.working': "working…";
+    readonly 'panel.auth.logoutFooter': "y confirm · n/esc back";
+    readonly 'panel.setup.compact': "provider setup · terminal too small · esc back";
+    readonly 'panel.setup.noDonors': "no model with declared efforts yet; declare one with e, or hand-write settings";
+    readonly 'panel.setup.copyInto': "copy verbatim into {id}";
+    readonly 'panel.setup.copyTitle': "/model — copy efforts";
+    readonly 'panel.setup.copyFooter': "↑↓ move · enter copy · esc back";
+    readonly 'panel.setup.title': "/model — configure {provider}";
+    readonly 'panel.setup.footer': "↑↓ move · ←→ in/out · space remove · e efforts · c copy efforts · tab discover · enter save · esc back";
+    readonly 'panel.discovery.compact': "model discovery · terminal too small · esc back";
+    readonly 'panel.discovery.loading': "discovering models…";
+    readonly 'panel.discovery.empty': "the endpoint advertised no models; add ids by hand on the setup page";
+    readonly 'panel.discovery.summary': "{advertised} advertised · {newCount} new · {checked} checked";
+    readonly 'panel.discovery.title': "/model — discover {provider}";
+    readonly 'panel.discovery.footer': "↑↓ move · space check · enter adopt · f refetch · esc back";
+    readonly 'panel.update.footer.probe': "checking… · esc close";
+    readonly 'panel.update.footer.error': "r recheck · esc close";
+    readonly 'panel.update.footer.apply': "updating… · ↑↓ scroll · esc waits";
+    readonly 'panel.update.footer.current': "up to date · r recheck · esc close";
+    readonly 'panel.update.footer.ahead': "newer than npm — not downgrading · r recheck · esc close";
+    readonly 'panel.update.footer.update': "enter update · r recheck · esc close";
+    readonly 'panel.update.footer.blocked': "blocked · r recheck · esc close";
+    readonly 'panel.footer.effortEmpty': "esc back";
+    readonly 'panel.footer.effort': "↑↓ choose · enter apply · esc/q back";
+    readonly 'panel.effort.title': "/model — effort for {provider} · {model}";
+    readonly 'panel.effort.empty': "this model advertises no reasoning effort levels — the provider default applies";
+    readonly 'panel.default': "default";
+    readonly 'panel.footer.agents': "↑↓ choose · enter/t transcript · r refresh · esc close";
+    readonly 'panel.agents.title': "/agents · {live} live · {total} total";
+    readonly 'panel.document.title': "transcript · {id}";
+    readonly 'panel.subagent.transcriptTitle': "subagent · {id}";
+    readonly 'panel.footer.subagent': "↑↓ choose · enter apply · r refresh · esc close";
+    readonly 'panel.subagent.title': "/subagent — model for delegated agents";
+    readonly 'panel.subagent.override': " · override {value}";
+    readonly 'panel.subagent.inherit': "inherit — follow the current model (/model switches apply)";
+    readonly 'panel.statusline.compact': "/statusline · esc close";
+    readonly 'panel.schedule.compact': "/schedule · {summary}";
+    readonly 'panel.schedule.none': "no active reminders";
+    readonly 'panel.schedule.more': " · +{count} more";
+    readonly 'panel.schedule.footer': "esc/q close{more} · the model schedules via schedule_create";
+};
+export type MessageKey = keyof typeof en;
+export type MessageCatalog = Record<MessageKey, string>;

package/lib/types/locales/zh.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The Chinese message catalog: mirrors {@link en} key-for-key; the shared
+ * key union comes from the English catalog, so a missing key here fails
+ * typecheck.
+ *
+ * @module @deepseek-ai/dsh-tui/locales/zh
+ */
+import type { MessageCatalog } from './en.ts';
+export declare const zh: MessageCatalog;

package/lib/types/mentions.d.ts

@@ -6,7 +6,10 @@
  * canonical `@[label](dsh-session:…)` tokens; on submit the text is parsed
  * back into readable `@label` text plus structured references, snapshots are
  * injected via `agent.inject()` before the readable message wakes the driver
- * (`followup` idle, `steer` running) — exactly the upstream README's wiring.
+ * (`followup`, which queues the next turn whether or not one is running) —
+ * exactly the upstream README's wiring. Steering the current turn is a
+ * deliberate user action through the `/queue` panel, never an implicit
+ * consequence of submitting while busy.
  *
  * File discovery lives entirely in the Harness service (per-agent bounded
  * index, `@dir/` listing, symlink guards, tool/result invalidation); this
@@ -21,6 +24,7 @@
  */
 import type { Context } from '@deepseek-ai/cordis';
 import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { UserMessage } from '@deepseek-ai/dsh-session';
 import { parseSessionReferenceText, type SessionReferenceCandidate, type SessionReferenceInput } from '@deepseek-ai/dsh-session-reference';
 /** Parsed submission text: readable text plus structured references. */
 type ParsedSessionReferenceText = ReturnType<typeof parseSessionReferenceText>;
@@ -42,14 +46,14 @@ export interface PreparedMention {
     /** Structured source sessions in appearance order (empty when none). */
     references: SessionReferenceInput[];
     /** Aggregated snapshot for `agent.inject()`, undefined without references. */
-    additionalContext?: import('@deepseek-ai/dsh-session').UserMessage;
+    additionalContext?: UserMessage;
 }
 /** Whether a mention token is already navigating a filesystem path. */
 export declare function isPathLikeMentionQuery(query: string): boolean;
 /** The mention API the input editor and the runner share. */
 export interface MentionsApi {
     /** Ranked menu candidates for the typed `@` query. */
-    candidates(query: string, signal?: AbortSignal): Promise<readonly MentionCandidate[]>;
+    candidates: (query: string, signal?: AbortSignal) => Promise<readonly MentionCandidate[]>;
     /** Parse submission text into readable text plus structured references. */
     parse(text: string): ParsedSessionReferenceText;
     /**

package/lib/types/models.d.ts

@@ -9,6 +9,7 @@
  */
 import type { Context } from '@deepseek-ai/cordis';
 import type { ModelSelection } from '@deepseek-ai/dsh-agent';
+import type { SessionEvent } from '@deepseek-ai/dsh-session';
 import { type LlmCallConfig, type LlmModelReasoningInfo, type ModelModality } from '@deepseek-ai/dsh-llm';
 /** Display metadata for one adapter-owned reasoning effort (mirrors `LlmReasoningEffortInfo`). */
 export interface ModelReasoningEffort {
@@ -74,6 +75,19 @@ export declare function resolveEffectiveSelection(picked: ModelSelection | undef
     model: string;
     reasoningEffort?: string;
 } | undefined, defaults: ModelSelection): ModelSelection;
+/**
+ * The session log's unconsumed explicit model selection (the resume layer of
+ * the documented precedence). `model/selection` events are log-only facts the
+ * web host's session-controller appends when its user picks a model for the
+ * NEXT request; a request header assembling exactly that selection retires
+ * it, while a header for different values (another route forced the request)
+ * leaves it armed. Seeding the resumed pick from here restores a selection
+ * that was made but never sent — the request header alone would answer with
+ * the older model.
+ * @param events - the full persisted event list of the resumed session.
+ * @returns the still-pending selection, when one exists.
+ */
+export declare function pendingModelSelection(events: readonly SessionEvent[]): ModelSelection | undefined;
 /**
  * Build the selection one `/model` pick applies, rejecting an effort the
  * row does not advertise. The row is the picker's source of truth, so a

package/lib/types/panel-accent.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Stable per-panel accents for the prismatic theme: every bordered panel
+ * claims the next slot in a first-seen sequence keyed by its stable id, so a
+ * screen with several open panels shows several ring colors while each panel
+ * keeps one learnable color. Deliberately NOT a React hook — several panels
+ * render through direct function calls inside conditionals, where hooks are
+ * illegal — and identity is by panel id, not by mount. Outside prismatic the
+ * helper is an identity: callers pass their usual border/title colors
+ * through unchanged and dark/light render pixel-identically.
+ *
+ * @module @deepseek-ai/dsh-tui/panel-accent
+ */
+import { type RgbTriple } from './theme.ts';
+/** One panel's resolved accent pair (border and title share the ring color in prismatic). */
+export interface PanelAccent {
+    readonly border: RgbTriple;
+    readonly title: RgbTriple;
+}
+/**
+ * The accent pair for one panel: in prismatic both entries are the panel's
+ * ring color (border and title match, per the design); in every other theme
+ * they are exactly the colors passed in.
+ * @param id - stable panel identity ('todos', 'model', 'kernel-list', …).
+ * @param border - the border color used outside prismatic.
+ * @param title - the title color used outside prismatic (defaults to border).
+ * @returns the resolved accent pair for this panel.
+ */
+export declare function panelAccent(id: string, border: RgbTriple, title?: RgbTriple): PanelAccent;

package/lib/types/rainbow.d.ts

@@ -0,0 +1,69 @@
+/**
+ * The rainbow theme's per-launch roll: a seeded shuffle over a twelve-color
+ * bright-tier spectrum that fills every palette role, the status-bar tone map
+ * (adjacent tones in canonical on-screen order never share a color, the
+ * row1/row2 boundary included), the panel accent ring, and full-spectrum
+ * flow anchors with a random phase. The roll happens once per launch and
+ * stays stable for the whole run; setting RAINBOW_SEED=<uint32> pins it for
+ * reproduction (the /theme notification prints the seed of the current roll).
+ *
+ * All pool colors clear AA body text (≥4.5:1) on a black terminal by a wide
+ * margin (11-17:1); diff rows pair a bright hue with its own 22% dark tint
+ * so the foreground stays 7.7-10.2:1 on its background.
+ *
+ * @module @deepseek-ai/dsh-tui/rainbow
+ */
+import type { StatusTone } from './render/status.ts';
+import type { RgbTriple, ThemePalette } from './theme.ts';
+/**
+ * The bright-tier spectrum: twelve Tailwind *-300 hues covering red through
+ * fuchsia, every one ≥11:1 on black. The roll samples this pool by shuffle;
+ * nothing outside it is ever painted.
+ */
+export declare const RAINBOW_POOL: readonly RgbTriple[];
+/** One per-launch carnival roll: everything the rainbow theme paints from. */
+export interface RainbowRoll {
+    /** The seed this roll came from (print it to reproduce). */
+    readonly seed: number;
+    /** The full 15-token palette for this launch. */
+    readonly palette: ThemePalette;
+    /** The four-color panel ring (random order and start). */
+    readonly ring: readonly RgbTriple[];
+    /** Status-tone → color: adjacent tones in {@link TONE_ORDER} never match. */
+    readonly toneColors: Readonly<Record<StatusTone, RgbTriple>>;
+    /** Full-spectrum flow anchors in hue order (a different subset every launch). */
+    readonly flowAnchors: readonly RgbTriple[];
+    /** Random phase offset into the flow lap, milliseconds. */
+    readonly flowPhaseMs: number;
+}
+/** Parse a RAINBOW_SEED value: a non-negative decimal uint32, else nothing. */
+export declare function parseRainbowSeed(value: string | undefined): number | undefined;
+/**
+ * One parsed `/rainbow` argument: empty means a fresh random roll; a
+ * decimal uint32 pins that seed; anything else is a usage error.
+ * @param argument - the raw text after `/rainbow`.
+ * @returns `{ seed }`, `'random'`, or `'usage'`.
+ */
+export declare function parseRainbowArgument(argument: string): {
+    seed: number;
+} | 'random' | 'usage';
+/**
+ * Build the roll for one seed: pure and deterministic, so tests pin exact
+ * outcomes and RAINBOW_SEED reproduces a lucky launch exactly.
+ * @param seed - the uint32 seed to roll from.
+ * @returns the complete carnival roll.
+ */
+export declare function rollRainbow(seed: number): RainbowRoll;
+/** The memoized per-launch roll; computed once, stable for the whole run. */
+export declare function rainbowRoll(): RainbowRoll;
+/**
+ * Replace the memoized roll: omit the seed for a fresh random one, or pass
+ * a uint32 to pin it. `/rainbow` uses this so a mid-session reroll actually
+ * recolors; {@link setTheme}(`'rainbow'`) must run afterwards so the
+ * palette accessor picks the new values up.
+ * @param seed - the seed to pin, or undefined for a new random roll.
+ * @returns the roll now in force.
+ */
+export declare function rerollRainbow(seed?: number): RainbowRoll;
+/** The current roll's seed as display copy (also the RAINBOW_SEED value). */
+export declare function rainbowSeedLabel(): string;