@ai-zen/agents-host 0.0.0-stage → 0.1.0-alpha.1

package/dist/handlers/messageHandlers.d.ts

@@ -0,0 +1,11 @@
+/**
+ * `message.*`：历史（PRD L5 / A12 / F-I7）。
+ *
+ * 取法（含自身最新内容、id 不存在就全量）已经在 `MessageService` 里定死，这里只转发。
+ */
+import type { HandlerTable } from "../net/index.js";
+import type { MessageService } from "../services/MessageService.js";
+export interface MessageHandlerDeps {
+    messages: MessageService;
+}
+export declare function createMessageHandlers(deps: MessageHandlerDeps): HandlerTable;

package/dist/handlers/messageHandlers.js

@@ -0,0 +1,10 @@
+/**
+ * `message.*`：历史（PRD L5 / A12 / F-I7）。
+ *
+ * 取法（含自身最新内容、id 不存在就全量）已经在 `MessageService` 里定死，这里只转发。
+ */
+export function createMessageHandlers(deps) {
+    return {
+        "message.list": async (context) => await deps.messages.list(context.params),
+    };
+}

package/dist/handlers/modelHandlers.d.ts

@@ -0,0 +1,17 @@
+/**
+ * `model.*` 的接线壳（F-F3 / F-F4 / F-F7 / F-B8）。
+ *
+ * 业务判断在 `services/ModelService.ts`；这里只转发 + 按连接语言重渲染句子（D8）。
+ */
+import type { HandlerTable } from "../net/WsHub.js";
+import type { ModelService } from "../services/ModelService.js";
+/** 本文件负责的方法名 */
+export type ModelHandlerName = "model.list" | "model.listImages" | "model.create" | "model.update" | "model.delete" | "model.restoreFactory" | "model.saveImage" | "model.deleteImage";
+/** 本文件产出的 handler 表片段 */
+export type ModelHandlers = Pick<HandlerTable, ModelHandlerName>;
+/** 接线壳的依赖 */
+export interface ModelHandlerDeps {
+    models: ModelService;
+}
+/** 造出 `model.*` 的 handler 表 */
+export declare function createModelHandlers(deps: ModelHandlerDeps): ModelHandlers;

package/dist/handlers/modelHandlers.js

@@ -0,0 +1,19 @@
+/**
+ * `model.*` 的接线壳（F-F3 / F-F4 / F-F7 / F-B8）。
+ *
+ * 业务判断在 `services/ModelService.ts`；这里只转发 + 按连接语言重渲染句子（D8）。
+ */
+import { localizeLocalizedTexts } from "./configHandlers.js";
+/** 造出 `model.*` 的 handler 表 */
+export function createModelHandlers(deps) {
+    return {
+        "model.list": async (context) => localizeLocalizedTexts(await deps.models.list(context.params), context.connection.language),
+        "model.listImages": async (context) => localizeLocalizedTexts(await deps.models.listImages(), context.connection.language),
+        "model.create": async (context) => localizeLocalizedTexts(await deps.models.create(context.params), context.connection.language),
+        "model.update": async (context) => localizeLocalizedTexts(await deps.models.update(context.params), context.connection.language),
+        "model.delete": async (context) => localizeLocalizedTexts(await deps.models.delete(context.params), context.connection.language),
+        "model.restoreFactory": async (context) => localizeLocalizedTexts(await deps.models.restoreFactory(context.params), context.connection.language),
+        "model.saveImage": async (context) => localizeLocalizedTexts(await deps.models.saveImage(context.params), context.connection.language),
+        "model.deleteImage": async (context) => localizeLocalizedTexts(await deps.models.deleteImage(context.params), context.connection.language),
+    };
+}

package/dist/handlers/noticeHandlers.d.ts

@@ -0,0 +1,24 @@
+/**
+ * `notice.*` 三个方法的接线（PRD L3 / F-I8）。
+ *
+ * handler 只做两件事：把连接的**语言**递给服务层（D8：语言挂在连接上，文案在读出时渲染），
+ * 以及把服务层的返回值原样交回。业务事实全在 `NoticeService` 里，这里不做判断 ——
+ * 一层只解释一次，多一层翻译就多一处会漂的地方。
+ */
+import type { HandlerTable } from "../net/WsHub.js";
+import type { EventLocalizer } from "../services/NoticeService.js";
+import type { NoticeService } from "../services/NoticeService.js";
+export interface NoticeHandlerDeps {
+    /** 只要本域用到的那三个方法（结构上 `NoticeService` 满足，用例可以给替身） */
+    notices: Pick<NoticeService, "list" | "dismiss" | "clear">;
+}
+/** 本域注册的方法 */
+export type NoticeHandlers = Pick<HandlerTable, "notice.list" | "notice.dismiss" | "notice.clear">;
+export declare function createNoticeHandlers(deps: NoticeHandlerDeps): NoticeHandlers;
+/**
+ * 事件出网前的按连接本地化（`WsHub` 的 `localizeEvent` 注入点）。
+ *
+ * 通知与问题的统一入口在这里：两类事件都带 `LocalizedText`，语言是连接的事，
+ * 所以「产生时按缺省语言渲染、出网时换成这条连接的语言」这一步落在接线层。
+ */
+export declare function createNoticeEventLocalizer(): EventLocalizer;

package/dist/handlers/noticeHandlers.js

@@ -0,0 +1,24 @@
+/**
+ * `notice.*` 三个方法的接线（PRD L3 / F-I8）。
+ *
+ * handler 只做两件事：把连接的**语言**递给服务层（D8：语言挂在连接上，文案在读出时渲染），
+ * 以及把服务层的返回值原样交回。业务事实全在 `NoticeService` 里，这里不做判断 ——
+ * 一层只解释一次，多一层翻译就多一处会漂的地方。
+ */
+import { createEventLocalizer } from "../services/NoticeService.js";
+export function createNoticeHandlers(deps) {
+    return {
+        "notice.list": async (context) => await deps.notices.list(context.params, context.connection.language),
+        "notice.dismiss": async (context) => await deps.notices.dismiss(context.params),
+        "notice.clear": async (context) => await deps.notices.clear(context.params),
+    };
+}
+/**
+ * 事件出网前的按连接本地化（`WsHub` 的 `localizeEvent` 注入点）。
+ *
+ * 通知与问题的统一入口在这里：两类事件都带 `LocalizedText`，语言是连接的事，
+ * 所以「产生时按缺省语言渲染、出网时换成这条连接的语言」这一步落在接线层。
+ */
+export function createNoticeEventLocalizer() {
+    return createEventLocalizer();
+}

package/dist/handlers/questionHandlers.d.ts

@@ -0,0 +1,16 @@
+/**
+ * `question.*` 两个方法的接线（PRD D22 / D23 / F-I9）。
+ *
+ * 两个事实只在这一层才拿得到，所以由 handler 递给服务层：
+ *   - 这条连接的**语言**（`hello` 里协商出来，断开即忘，D8）；
+ *   - 这条连接的 **id**（多端同时看一个问题时，「谁答的」要写进回答里）。
+ */
+import type { HandlerTable } from "../net/WsHub.js";
+import type { QuestionService } from "../services/QuestionService.js";
+export interface QuestionHandlerDeps {
+    /** 只要本域用到的那两个方法（结构上 `QuestionService` 满足，用例可以给替身） */
+    questions: Pick<QuestionService, "list" | "answer">;
+}
+/** 本域注册的方法 */
+export type QuestionHandlers = Pick<HandlerTable, "question.list" | "question.answer">;
+export declare function createQuestionHandlers(deps: QuestionHandlerDeps): QuestionHandlers;

package/dist/handlers/questionHandlers.js

@@ -0,0 +1,16 @@
+/**
+ * `question.*` 两个方法的接线（PRD D22 / D23 / F-I9）。
+ *
+ * 两个事实只在这一层才拿得到，所以由 handler 递给服务层：
+ *   - 这条连接的**语言**（`hello` 里协商出来，断开即忘，D8）；
+ *   - 这条连接的 **id**（多端同时看一个问题时，「谁答的」要写进回答里）。
+ */
+export function createQuestionHandlers(deps) {
+    return {
+        "question.list": async (context) => await deps.questions.list(context.params, context.connection.language),
+        "question.answer": async (context) => await deps.questions.answer(context.params, {
+            language: context.connection.language,
+            answeredBy: context.connection.id,
+        }),
+    };
+}

package/dist/handlers/searchHandlers.d.ts

@@ -0,0 +1,12 @@
+/**
+ * `search.*`：找得到旧对话（PRD F-C6 / D16）。
+ *
+ * 名称搜与全文搜的取数、分词退化（少于 3 字走 `LIKE`）都在 `SearchService` 里，
+ * 这里只转发。
+ */
+import type { HandlerTable } from "../net/index.js";
+import type { SearchService } from "../services/SearchService.js";
+export interface SearchHandlerDeps {
+    search: SearchService;
+}
+export declare function createSearchHandlers(deps: SearchHandlerDeps): HandlerTable;

package/dist/handlers/searchHandlers.js

@@ -0,0 +1,12 @@
+/**
+ * `search.*`：找得到旧对话（PRD F-C6 / D16）。
+ *
+ * 名称搜与全文搜的取数、分词退化（少于 3 字走 `LIKE`）都在 `SearchService` 里，
+ * 这里只转发。
+ */
+export function createSearchHandlers(deps) {
+    return {
+        "search.conversations": async (context) => await deps.search.conversations(context.params),
+        "search.messages": async (context) => await deps.search.messages(context.params),
+    };
+}

package/dist/handlers/workspaceHandlers.d.ts

@@ -0,0 +1,29 @@
+/**
+ * `workspace.*`：项目（PRD D9 / D10 / D11 / D12）。
+ *
+ * 薄到只有一层：参数交给 `WorkspaceService`，结果原样回去。唯一在接线层补的是删项目之后的
+ * 两件事（回收它的 Scope、逐段对话推 `deleted`）—— 那两样分别属于运行时与接线层，服务层只负责
+ * 删行并算出代价（裁定 R43 / R33）。素材字节的清理不在这里：挂引用归零之后由素材层删。
+ */
+import type { HandlerTable } from "../net/index.js";
+import type { ChatEventEmitter, ChatRunner, ScopeRegistry } from "../runtime/index.js";
+import type { ConversationService } from "../services/ConversationService.js";
+import type { WorkspaceService } from "../services/WorkspaceService.js";
+/** `workspace.*` 的实现要的持有者 */
+export interface WorkspaceHandlerDeps {
+    workspaces: WorkspaceService;
+    /** 删项目要连带它的对话一起清（PRD D11）：删之前先记下名下有哪几段 */
+    conversations: ConversationService;
+    /** 名下的对话在运行时里可能还留着现场，删之前一并丢掉 */
+    runner: ChatRunner;
+    /** 删项目要把它的 Scope 一起回收（MCP 连接在这里断开） */
+    scopes: ScopeRegistry;
+    /**
+     * 推 `conversation.changed`（L5 / D22：删项目带走的那几段对话也要让别的窗口知道）。
+     * 不注入时不推。
+     */
+    emit?: ChatEventEmitter;
+    /** 时间戳（`conversation.changed.at`）；缺省用 `Date.now` */
+    now?: () => string;
+}
+export declare function createWorkspaceHandlers(deps: WorkspaceHandlerDeps): HandlerTable;

package/dist/handlers/workspaceHandlers.js

@@ -0,0 +1,47 @@
+/**
+ * `workspace.*`：项目（PRD D9 / D10 / D11 / D12）。
+ *
+ * 薄到只有一层：参数交给 `WorkspaceService`，结果原样回去。唯一在接线层补的是删项目之后的
+ * 两件事（回收它的 Scope、逐段对话推 `deleted`）—— 那两样分别属于运行时与接线层，服务层只负责
+ * 删行并算出代价（裁定 R43 / R33）。素材字节的清理不在这里：挂引用归零之后由素材层删。
+ */
+export function createWorkspaceHandlers(deps) {
+    return {
+        "workspace.list": async (context) => await deps.workspaces.list(context.params),
+        "workspace.create": async (context) => await deps.workspaces.create(context.params),
+        "workspace.get": async (context) => await deps.workspaces.get(context.params),
+        "workspace.rename": async (context) => await deps.workspaces.rename(context.params),
+        "workspace.remove": async (context) => await removeWorkspace(deps, context.params),
+    };
+}
+/**
+ * 删项目（PRD D11 / D17 / F-F9 / R43）。
+ *
+ * 顺序是有意的：
+ *   1. 先记下名下的对话（删完就问不出来了，而运行时里它们的现场要一起丢）；
+ *   2. 服务层删行（它顺带让运行时忘掉那几段对话的临时覆盖，以及删完之后清归零的素材字节）；
+ *   3. 逐段对话丢掉这一轮的现场，并推一条 `deleted`（多端在线时对方界面靠它去拉）；
+ *   4. 回收这个 Workspace 的 Scope —— MCP 连接在这里断开（architecture §4 三因之二）。
+ *
+ * `dryRun` 只走第 2 步：它要的只是代价，不该有任何副作用。
+ */
+async function removeWorkspace(deps, params) {
+    const doomed = params.dryRun === true
+        ? []
+        : (await deps.conversations.list({ workspaceId: params.workspaceId })).conversations;
+    const report = await deps.workspaces.remove(params);
+    if (params.dryRun !== true && report.removed) {
+        for (const conversation of doomed) {
+            deps.runner.forget(conversation.id);
+            deps.emit?.("conversation.changed", {
+                conversationId: conversation.id,
+                workspaceId: params.workspaceId,
+                change: "deleted",
+                messageCount: null,
+                at: (deps.now ?? (() => new Date().toISOString()))(),
+            });
+        }
+        await deps.scopes.disposeWorkspace(params.workspaceId);
+    }
+    return { removed: report.removed, consequences: report.consequences };
+}

package/dist/i18n/en.d.ts

@@ -0,0 +1,243 @@
+/**
+ * 英文文案表 —— 键的真相源（key 的集合以本文件为准，`zh` 与它逐键对应，类型层面拦住漂移）。
+ *
+ * 写作口径（PRD §1「它说人话」）：一句能直接摆在用户面前的话，说「发生了什么」以及
+ * 「用户可以怎么做」，不写 `Error: undefined`、不写 `E_XXX` 这类机器码，也不写
+ * 「请求失败」这种没有信息量的话。占位符用 `{name}` 形式，值与含义在键旁的注释里。
+ *
+ * 文案只描述事实，不做取舍判断（例如目录不存在时只说「目录已不存在」，是否只读由客户端定，
+ * PRD D12）；凡是「宿主给事实、客户端给表现」的地方，事实都在结构化字段里，文案只是给人看的那一层。
+ */
+export declare const en: {
+    readonly "error.unauthorized": "That access key wasn't accepted. Check the key and try again.";
+    readonly "error.invalidParams": "Part of this request doesn't look right: {field}.";
+    readonly "error.notFound": "There's no {entity} with that id.";
+    readonly "error.busy": "This conversation is still working on the previous turn. Stop it or wait for it to finish.";
+    readonly "error.payloadTooLarge": "That file is {size}, which is over the {limit} limit.";
+    readonly "error.unsupported": "The host can't handle {what}.";
+    readonly "error.internal": "Something broke on the host. The log has the details.";
+    readonly "error.configInvalid": "The settings aren't usable yet: {reason}.";
+    readonly "error.portInvalid": "That port number can't be used: {value} (from {source}). It has to be a whole number from 1 to 65535 — 0 means \"let the system pick one\" and only works on the command line.";
+    readonly "error.modelUnresolved": "No model could be resolved for this assistant — pick a model for it, or set a default model in the settings.";
+    readonly "error.notFactoryModel": "\"{id}\" isn't part of the factory model list, so there's no factory version to restore.";
+    readonly "error.mcpUnavailable": "{name} isn't answering, so its tools are missing this turn. Everything else still works.";
+    readonly "error.modelUnsupported": "{model} can't take the images already in this conversation, so the switch was refused.";
+    readonly "error.handoffDeclined": "Handoff was declined, so this conversation carries on as it is.";
+    readonly "error.questionPending": "There's an unanswered question ({question}). Answer it before sending something new.";
+    readonly "error.contextGuard": "This conversation reached its {limit}-token limit at {used} tokens, so the request was stopped before it could fail.";
+    readonly "notice.settingsSaved": "Settings saved.";
+    readonly "notice.settingsApplied": "Settings applied — no restart needed.";
+    readonly "notice.conversationDeleted": "Conversation deleted.";
+    readonly "notice.workspaceDeleted": "Project removed, along with its {count} conversation(s). The folder itself was left alone.";
+    readonly "notice.assetsUploaded": "{count} image(s) uploaded.";
+    readonly "notice.attachmentDropped": "{name} couldn't be sent and was left out of the message.";
+    readonly "notice.upgradeRestarting": "Updated to {version}. Restarting now.";
+    readonly "notice.logWarning": "Host warning: {summary}";
+    readonly "notice.logError": "Host error: {summary}";
+    readonly "notice.handoffWritten": "Handoff document written to {path}.";
+    readonly "notice.autoNamed": "Named this conversation \"{name}\".";
+    readonly "notice.languageChanged": "This connection now speaks {language}.";
+    readonly "notice.hardLimitHit": "This turn stopped at the {limit}-token limit. Nothing was lost — the conversation is waiting for you.";
+    readonly "status.connected": "Connected";
+    readonly "status.awaitingFirstToken": "Connected — waiting for the first word";
+    readonly "status.thinking": "Thinking…";
+    readonly "status.generating": "Writing…";
+    readonly "status.assemblingToolCalls": "Putting together {count} tool call(s)…";
+    readonly "status.awaitingTools": "Waiting on {tools}";
+    readonly "status.idle": "Ready";
+    readonly "status.done": "Finished";
+    readonly "status.aborted": "Stopped";
+    readonly "status.error": "Stopped by an error";
+    readonly "question.handoff.prompt": "This conversation is at {percent}% of the context budget set for it. How should we continue?";
+    readonly "question.handoff.self": "Let the assistant write the handoff itself";
+    readonly "question.handoff.selfDetail": "Uses the full conversation and its tools — the best result, at the price of one more full input.";
+    readonly "question.handoff.summary": "Summarise the history instead";
+    readonly "question.handoff.summaryDetail": "Cheaper and predictable, but the document is less faithful.";
+    readonly "question.handoff.decline": "Keep going in this conversation";
+    readonly "question.confirm.prompt": "{action} can't be undone. Go ahead?";
+    readonly "question.confirm.accept": "Yes, do it";
+    readonly "question.confirm.decline": "Cancel";
+    readonly "question.blocking": "This question is holding the conversation. Answer it to continue.";
+    readonly "message.reverted": "Removed {count} message(s). The text is back in your input.";
+    readonly "message.cwdMissing": "This project's folder no longer exists ({cwd}). The conversation and its history are still here.";
+    readonly "message.injectedContext": "Sent by the host, not typed by you: {summary}";
+    readonly "message.injectedContext.cwd": "the current folder is {cwd}";
+    readonly "message.subagentFailed": "The helper agent {name} failed: {reason}";
+    readonly "message.subagentFinished": "The helper agent {name} finished.";
+    readonly "message.imageAsText": "{model} can't look at images, so {name} was described in text instead.";
+    readonly "message.attachmentTooMany": "A message carries at most {limit} images. {name} was left out.";
+    readonly "usage.turn": "{value} tokens this turn";
+    readonly "usage.total": "{value} tokens in total";
+    readonly "usage.rate": "{value} tokens/s";
+    readonly "usage.withSubAgents": "the total includes {value} from helper agents";
+    readonly "label.agent": "Assistant";
+    readonly "label.model": "Model";
+    readonly "label.thinking": "Thinking";
+    readonly "label.context": "Context";
+    readonly "label.usage": "Usage";
+    readonly "label.cwd": "Folder";
+    readonly "label.tools": "Tools running";
+    readonly "label.subagents": "Helper agents";
+    readonly "completion.scanning": "Still reading the project's file list — a few more characters and it will fill in.";
+    readonly "completion.timedOut": "The file list took longer than {seconds}s to build, so it may be incomplete.";
+    readonly "completion.unavailable": "The file list isn't available here: {reason}";
+    readonly "completion.noFolder": "this project's folder isn't there anymore";
+    readonly "completion.truncated": "Only the first {limit} files are listed; narrow what you type to see the rest.";
+    readonly "config.referenced": "Still used by {count} item(s), so it can't be removed: {names}";
+    readonly "config.fileBroken": "{path} can't be read as settings: {reason}";
+    readonly "endpoint.missing": "{id} isn't in the endpoint list anymore, so this can't be reached.";
+    readonly "endpoint.noKey": "{endpoint} has no access key yet, so its models can't answer.";
+    readonly "model.endpointMissing": "{model} points to an endpoint ({id}) that isn't in the endpoint list anymore.";
+    readonly "agent.modelMissing": "This assistant is bound to a model ({id}) that isn't in the model list anymore.";
+    readonly "agent.fileBroken": "{name} can't be read as an assistant definition: {reason}";
+    readonly "agent.notFactory": "\"{id}\" isn't part of the factory assistant list, so there's no factory version to restore.";
+    readonly "config.issue.thresholdOrder": "{name} has its handoff line ({handoff} tokens) at or above its hard limit ({guard} tokens).";
+    readonly "config.issue.defaultMissing": "{field} points to {id}, which isn't in that list anymore.";
+    readonly "config.issue.defaultAgentMissing": "The default assistant ({id}) isn't among the assistant definitions anymore.";
+    readonly "discovery.notADirectory": "{path} isn't a directory, so nothing was read from it.";
+    readonly "discovery.shadowed": "This entry is overridden by the closer {path}.";
+    readonly "discovery.mcpEntryInvalid": "{name} has neither a transport nor a command, so it can't be connected.";
+    readonly "discovery.skillBroken": "{name} has a SKILL.md that can't be used as a skill: {reason}";
+    readonly "discovery.toolUnloadable": "{name} couldn't be loaded as a tool: {reason}";
+    readonly "discovery.subAgentBroken": "{name} isn't a usable sub-agent definition: {reason}";
+    readonly "model.unavailable": "{name} is listed but can't be used right now: {reason}";
+    readonly "model.visionRequired": "{model} can't read images, and this conversation has some.";
+    readonly "handoff.degraded": "The handoff fell back to {mode}: {reason}";
+    readonly "handoff.declined": "No handoff this time.";
+    readonly "handoff.noDocuments": "No handoff documents in this project yet.";
+    readonly "workspace.removalCost": "This removes {conversations} conversation(s) and their {messages} message(s). The folder on disk stays.";
+    readonly "attachment.tooLarge": "Each image can be at most {limit}; {name} is {size}.";
+    readonly "attachment.tooMany": "A message carries at most {limit} images.";
+    readonly "notice.unknown": "A notice from the host ({code}).";
+    readonly "error.handoffFailed": "The handoff didn't go through: {reason}";
+    readonly "error.transientFailed": "That one-off request didn't finish: {reason}";
+    readonly "handoff.newConversationSummary": "This conversation continues an earlier one. The handoff document is at {path} — read it first, then carry on with the task.\n\nSummary of the handoff:\n{summary}";
+    readonly "handoff.degradeReason.fallback": "the assistant couldn't write the document itself this time";
+    readonly "autoName.failed": "No name came out of it, so the original one stays: {reason}";
+    readonly "capability.host.hello": "Connect to the host";
+    readonly "capability.host.hello.detail": "Opens a connection with an access key and fixes the language this connection speaks.";
+    readonly "capability.host.version": "Show the host version";
+    readonly "capability.host.version.detail": "The running version and the protocol version, so an upgrade can be checked.";
+    readonly "capability.host.upgrade": "Restart into a newer version";
+    readonly "capability.host.upgrade.detail": "Compares the version on disk with the running one and restarts when the update has really landed.";
+    readonly "capability.host.shutdown": "Shut the host down";
+    readonly "capability.host.shutdown.detail": "Stops serving once nothing is left running — open connections are closed.";
+    readonly "capability.host.capabilities": "List what the host can do";
+    readonly "capability.host.capabilities.detail": "The list this help page is drawn from: what each ability does and whether it blocks or can't be undone.";
+    readonly "capability.host.reload": "Reload from disk";
+    readonly "capability.host.reload.detail": "Re-read configuration, assistants, tools, skills or MCP entries: affected projects rebuild their capabilities, nothing restarts.";
+    readonly "capability.host.setLanguage": "Switch language for this connection";
+    readonly "capability.host.setLanguage.detail": "Every message on this connection is rendered in the chosen language; a reconnect forgets it.";
+    readonly "capability.workspace.list": "List projects";
+    readonly "capability.workspace.list.detail": "Every project on this machine, including the ones whose folder is gone.";
+    readonly "capability.workspace.create": "Add a project";
+    readonly "capability.workspace.create.detail": "Registers a folder as a project; the same folder can only be added once.";
+    readonly "capability.workspace.get": "Show a project";
+    readonly "capability.workspace.get.detail": "One project by id, with whether its folder still exists.";
+    readonly "capability.workspace.rename": "Rename a project";
+    readonly "capability.workspace.rename.detail": "Changes the display name only; the folder path never changes.";
+    readonly "capability.workspace.remove": "Remove a project";
+    readonly "capability.workspace.remove.detail": "Deletes the project and every conversation in it; the folder on disk is left alone.";
+    readonly "capability.conversation.list": "List conversations";
+    readonly "capability.conversation.list.detail": "Newest first, pinned ones on top; can be narrowed to one project.";
+    readonly "capability.conversation.create": "Start a conversation";
+    readonly "capability.conversation.create.detail": "Fixes the project, the assistant and the model for this conversation up front.";
+    readonly "capability.conversation.get": "Open a conversation";
+    readonly "capability.conversation.get.detail": "One conversation by id — how you pick up where you left off.";
+    readonly "capability.conversation.state": "Show what is happening right now";
+    readonly "capability.conversation.state.detail": "The six-state run, context thresholds, pending questions and usage in one snapshot.";
+    readonly "capability.conversation.rename": "Rename a conversation";
+    readonly "capability.conversation.rename.detail": "Changes the name only; identity and order stay as they were.";
+    readonly "capability.conversation.pin": "Pin a conversation";
+    readonly "capability.conversation.pin.detail": "Keeps it at the top of the sidebar without changing anything else.";
+    readonly "capability.conversation.delete": "Delete a conversation";
+    readonly "capability.conversation.delete.detail": "Removes the conversation and its messages for good, and cleans up its images.";
+    readonly "capability.conversation.send": "Send a message";
+    readonly "capability.conversation.send.detail": "Starts one turn: you get the message ids back at once, the answer streams in after.";
+    readonly "capability.conversation.abort": "Stop the current turn";
+    readonly "capability.conversation.abort.detail": "Stops the answer that is being written; what was written so far stays.";
+    readonly "capability.conversation.revert": "Take back messages";
+    readonly "capability.conversation.revert.detail": "Deletes everything after a chosen message and puts that text back in your input.";
+    readonly "capability.conversation.setModel": "Switch model for this conversation";
+    readonly "capability.conversation.setModel.detail": "Without touching the assistant's default and without restarting the conversation.";
+    readonly "capability.conversation.setThinking": "Set how hard the model thinks";
+    readonly "capability.conversation.setThinking.detail": "Turns a thinking level into request parameters for this conversation only.";
+    readonly "capability.conversation.transient": "Ask once without a conversation";
+    readonly "capability.conversation.transient.detail": "One request, one answer, nothing saved and no conversation created.";
+    readonly "capability.message.list": "Show messages";
+    readonly "capability.message.list.detail": "The whole history of a conversation, or everything from a given message on, helper agents included.";
+    readonly "capability.question.list": "Show open questions";
+    readonly "capability.question.list.detail": "Questions waiting for an answer; every window sees the same ones.";
+    readonly "capability.question.answer": "Answer a question";
+    readonly "capability.question.answer.detail": "Records the answer and carries on: a handoff question starts the handoff by itself.";
+    readonly "capability.notice.list": "Show notices";
+    readonly "capability.notice.list.detail": "The notices still on screen — separate from the message stream.";
+    readonly "capability.notice.dismiss": "Dismiss a notice";
+    readonly "capability.notice.dismiss.detail": "Clears one notice; timed notices go away on their own.";
+    readonly "capability.notice.clear": "Clear all notices";
+    readonly "capability.notice.clear.detail": "Clears a batch at once, either the whole list or one conversation's.";
+    readonly "capability.config.get": "Show settings";
+    readonly "capability.config.get.detail": "Endpoints (keys masked), models, defaults and what is misconfigured, in one read.";
+    readonly "capability.config.patch": "Change settings";
+    readonly "capability.config.patch.detail": "Writes the change and applies it right away — no restart, no save button.";
+    readonly "capability.config.setDefaults": "Set the defaults";
+    readonly "capability.config.setDefaults.detail": "Default assistant, fallback model, migration model, image model and naming model.";
+    readonly "capability.config.getDiscovery": "Show where abilities come from";
+    readonly "capability.config.getDiscovery.detail": "The MCP layers, Skills, tools and helpers that are actually found, plus the files that can't be read.";
+    readonly "capability.config.saveMcp": "Save an MCP server";
+    readonly "capability.config.saveMcp.detail": "Creates it if the id is new, edits it otherwise — one entry at a time, with its transport and that transport's parameters; fields this version doesn't know are kept as they are.";
+    readonly "capability.config.deleteMcp": "Delete an MCP server";
+    readonly "capability.config.deleteMcp.detail": "Removes one entry from one of the two editable scopes; says so plainly when it wasn't there.";
+    readonly "capability.config.saveEndpoint": "Save an endpoint";
+    readonly "capability.config.saveEndpoint.detail": "Creates or edits an endpoint; leave the key out to keep the current one.";
+    readonly "capability.config.deleteEndpoint": "Delete an endpoint";
+    readonly "capability.config.deleteEndpoint.detail": "Refuses while models still point at it and lists who does.";
+    readonly "capability.agent.list": "List assistants";
+    readonly "capability.agent.list.detail": "Every assistant, including the ones that can't be used right now and why.";
+    readonly "capability.agent.get": "Show an assistant";
+    readonly "capability.agent.get.detail": "One assistant definition by id, straight from its file.";
+    readonly "capability.agent.create": "Create an assistant";
+    readonly "capability.agent.create.detail": "Writes a new definition file — one file per assistant, editable by hand.";
+    readonly "capability.agent.update": "Edit an assistant";
+    readonly "capability.agent.update.detail": "Changes the definition file; from then on it counts as your own, not the factory one.";
+    readonly "capability.agent.delete": "Delete an assistant";
+    readonly "capability.agent.delete.detail": "Removes the definition and says who else points at it first.";
+    readonly "capability.agent.setModel": "Set an assistant's model";
+    readonly "capability.agent.setModel.detail": "Changes the assistant's default model, which affects conversations started later.";
+    readonly "capability.agent.setThinking": "Set an assistant's thinking level";
+    readonly "capability.agent.setThinking.detail": "Writes the expanded request parameters into the assistant definition.";
+    readonly "capability.agent.restoreFactory": "Restore an assistant to factory settings";
+    readonly "capability.agent.restoreFactory.detail": "Puts the whole assistant definition — prompt, model, permissions and thinking settings — back to the one that shipped with the host. You can look at the result before it's written.";
+    readonly "capability.model.list": "List models";
+    readonly "capability.model.list.detail": "Factory-managed and custom models with thresholds, thinking presets and availability.";
+    readonly "capability.model.listImages": "List image models";
+    readonly "capability.model.listImages.detail": "The models used for image generation, plus which one is the default.";
+    readonly "capability.model.create": "Create a model";
+    readonly "capability.model.create.detail": "Adds a model bound to an endpoint; a new one counts as custom right away.";
+    readonly "capability.model.update": "Edit a model";
+    readonly "capability.model.update.detail": "Editing a factory model turns it into a custom one so later updates leave it alone.";
+    readonly "capability.model.delete": "Delete a model";
+    readonly "capability.model.delete.detail": "Refuses while an assistant still points at it, and fixes the defaults when it goes.";
+    readonly "capability.model.restoreFactory": "Restore a model to factory settings";
+    readonly "capability.model.restoreFactory.detail": "Replaces the whole model definition with the factory one in a single step.";
+    readonly "capability.model.saveImage": "Create or edit an image model";
+    readonly "capability.model.saveImage.detail": "Binds an image model to an endpoint with its default size and quality.";
+    readonly "capability.model.deleteImage": "Delete an image model";
+    readonly "capability.model.deleteImage.detail": "Refuses while it is the default image model.";
+    readonly "capability.asset.begin": "Start an upload";
+    readonly "capability.asset.begin.detail": "Declares the size and type of a file; anything over the limit is refused right here.";
+    readonly "capability.asset.end": "Finish an upload";
+    readonly "capability.asset.end.detail": "Checks length and digest, then turns the file into something a message can reference.";
+    readonly "capability.asset.get": "Fetch an asset";
+    readonly "capability.asset.get.detail": "Returns the stored bytes so any model can replay an image from history; the thumbnail variant currently equals the original.";
+    readonly "capability.completion.files": "Complete file paths";
+    readonly "capability.completion.files.detail": "The project's file list behind the `@` menu; says so when it is still reading.";
+    readonly "capability.handoff.start": "Write a handoff document";
+    readonly "capability.handoff.start.detail": "Writes the document and, if asked, opens the next conversation; the old one stays complete.";
+    readonly "capability.handoff.listDocuments": "List handoff documents";
+    readonly "capability.handoff.listDocuments.detail": "The documents already written in this project, ready to be refined again.";
+    readonly "capability.search.conversations": "Search conversations by name";
+    readonly "capability.search.conversations.detail": "Finds old conversations by what they are called, optionally within one project.";
+    readonly "capability.search.messages": "Search inside conversations";
+    readonly "capability.search.messages.detail": "Full-text search over what was said, with a snippet of each hit.";
+};