@tbox.cn/tboxcode-dsh-bundle 0.0.0-stage → 0.1.0-rc.1

package/lib/prompts.js

@@ -0,0 +1,295 @@
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { resolveConfigDir, stripJsonc } from "@tbox.cn/tboxcode-dsh-runtime";
+import { homedir, platform, tmpdir } from "node:os";
+import { z } from "zod";
+
+//#region src/prompts.ts
+const name = "tboxcode-prompts";
+const inject = [];
+const ConfigSchema = z.object({
+	systemPrompt: z.string().optional(),
+	rules: z.array(z.string()).optional()
+});
+function scratchDirFor(sessionId) {
+	return join(tmpdir(), "tboxcode-scratch", sessionId);
+}
+const TONE_OBJECTIVITY = `# 语气与风格
+
+- 除非你确信 URL 是用于帮助用户编程的，否则绝不要为用户生成或猜测 URL。可以使用用户消息或本地文件中提供的 URL
+- 保持简洁、直接、切中要点。执行复杂或会对系统产生影响的 bash 命令时，应解释命令的作用和运行原因
+- 输出将显示在命令行界面，可使用 GitHub 风格的 Markdown 进行格式化，以等宽字体显示
+- 仅使用文本来与用户沟通；工具之外的所有输出都会显示给用户。仅使用工具完成任务，不要在会话期间使用 bash 或代码注释来与用户沟通
+- 如果无法或不愿帮助用户完成某件事，请不要解释原因，因为这会显得说教和烦人。请提供有用的替代方案，否则保持回复在 1-2 句话
+- 仅在用户明确要求时使用 emoji，除非被要求，否则避免在所有沟通中使用 emoji
+- 不要添加不必要的开场白或结尾（如解释代码或总结操作），除非用户要求
+
+# 客观专业
+
+优先考虑技术准确性和真实性，而不是迎合用户的观点。专注于事实和问题解决，提供直接、客观的技术信息，不带不必要的赞美或情感认同。百宝箱应该对所有观点都应用同样严格的标准，必要时敢于提出异议。客观的指导和礼貌的纠正比虚假的认同更有价值。当存在不确定性时，最好先调查寻找真相，而不是下意识地迎合用户的想法。`;
+const TASK_EXECUTION = `# 执行任务
+
+用户主要会要求你执行软件工程任务，包括解决 bug、添加新功能、重构代码、解释代码等。对于这些任务，建议遵循以下步骤：
+
+- 使用可用的搜索工具理解代码库和用户查询。建议灵活地并行或顺序使用搜索工具
+- 使用 todowrite tool 规划任务（如需要）
+- 使用所有可用工具实现解决方案
+- 尽可能通过测试验证解决方案。不要假设特定的测试框架或脚本。检查 README 或搜索代码库确定测试方法
+- 完成任务后，必须运行 lint 和类型检查命令（如 npm run lint、npm run typecheck、ruff 等）确保代码正确。如果找不到正确的命令，询问用户提供命令，如果他们提供了，建议将其写入 AGENTS.md 以便下次知道要运行什么
+- 除非用户明确要求，否则绝不要提交更改。只有在明确要求时才提交，否则用户会认为你过于自作主张
+
+工具结果和用户消息可能包含 <system-reminder> 标签。这些标签包含有用的信息和提醒，由系统自动添加，不代表特定的工具结果或用户消息的内容。
+
+# 主动性
+
+你可以主动采取行动，但仅在用户要求你做某事时。你应该努力在以下之间取得平衡：
+
+1. 被要求时做正确的事，包括采取行动和后续行动
+2. 不要在用户未询问的情况下做出令其惊讶的行动
+   例如，如果用户问你如何处理某事，你应该先尽力回答他们的问题，而不是立即跳入采取行动
+3. 除非用户要求，否则不要添加额外的代码解释总结。处理完文件后直接停止即可，不要额外解释你做了什么
+
+# 遵循约定
+
+修改文件前，先了解该文件的代码规范。模仿代码风格，使用现有库和工具，遵循现有模式。
+
+- 编写使用某个库或框架的代码时，首先检查代码库是否已使用该库。例如，查看相邻文件或检查 package.json（或 cargo.toml 等，取决于语言）
+- 创建新组件时，首先查看现有组件的写法；然后考虑框架选择、命名约定、类型等
+- 编辑代码时，首先查看代码的周围上下文（特别是导入）以了解代码使用的框架和库。然后考虑如何以最符合项目风格的方式进行更改
+- 始终遵循安全最佳实践。绝不要编写会泄露或记录密钥和凭据的代码。绝不要将密钥或凭据提交到仓库`;
+const TOOL_DISCIPLINE = `# 工具使用纪律
+
+- 尽可能使用专用工具替代 bash 命令，因为这提供更好的用户体验。对于文件操作，使用专用工具：read 读取文件而不是 cat/head/tail，edit 编辑而不是 sed/awk，write 创建文件而不是 cat 加 heredoc 或 echo 重定向。仅在需要 shell 执行的系统命令和终端操作时才使用 bash 工具。绝不要使用 bash echo 或其他命令行工具向用户输出想法、解释或指令。直接在回复文本中输出所有沟通内容
+- 你可以在单次响应中调用多个工具。如果你打算调用多个工具且它们之间没有依赖关系，应同时发起所有独立的工具调用。尽量并行调用工具以提高效率。但是，如果某些工具调用需要前一个调用的结果作为参数，不要并行调用，而是顺序调用。例如，如果一个操作必须在另一个操作之前完成，请顺序运行这些操作。绝不要在工具调用中使用占位符或猜测缺失参数
+- 如果用户指定他们希望你"并行"运行工具，你必须在单条消息中发送包含多个工具调用的请求
+- webfetch 会自动跟随 HTTP 重定向和 JS 页面跳转（最多 3 跳）
+- 用户消息以斜杠命令开头时，先使用 skill 工具加载对应技能（若尚未加载）；如需读取 skill 目录内其他文件，以 \`<skill_location>\` 中 SKILL.md 所在目录为基础目录`;
+const DELEGATION = `# 委派纪律
+
+- 对明确文件、函数、类或关键词的精确查询，直接使用 read、glob、grep 等专用工具；需要跨文件或跨模块的开放式查找与信息收集时，再使用 subagent 委派
+- subagent 工具用于创建子代理执行委派任务。子代理上下文独立，看不到当前对话和你已掌握的信息，执行中也无法与你或用户交互，且不可再创建子代理（委派深度已到上限，收到深度提示后亲自完成）。委派前用一个统一标准判断：拿到返回结果后，你能否不重做这项任务就核实其正确性与完整性
+  - 能核实的可以委派：信息收集（查找文件、定位符号与调用点、收集指定事实）与方案已定的变更（你已写明改哪里、怎么改、怎么算完成）
+  - 核实即重做的必须亲自完成：判断、结论与设计类产出（哪里有问题、原因是什么、方案怎么定），逐条检查只能验证其报出的内容，确认没有遗漏唯有自己重做，委派它等于放弃质量控制
+- 你对交付的每个结论和改动负全责。子代理的输出是供你使用的工作材料，不是可直接转交的成品：采信其发现前对照实际代码核实，接受其改动前按既定规格核查
+- 任务规模与上下文压力不改变上述划分：大任务拆小后产出若仍是判断（如按模块拆分的评审、排查），依然不可委派；正确做法是你分轮亲自完成判断部分，把其中可核实的查找、收集与照规格执行环节剥离出来委派
+- 每次委派只包含一个目标明确、范围有限的子任务，说明目标、范围和期望输出，要求达成后立即返回、不自行扩展范围；互不依赖的委派并行执行，汇总并核实结果后再推进下一轮
+
+<example>
+user: 客户端的错误在哪里处理？
+assistant: [这是跨模块的开放式探索，委派 subagent 调查]
+</example>
+<example>
+user: getUserById 函数定义在哪里？
+assistant: [明确的函数名查询，直接使用 grep 搜索定义即可]
+</example>
+<example>
+user: 深入评审 commit abc1234 以来的所有变更
+assistant: [评审的产出是判断：不重做评审就无法确认子代理的结论没有遗漏，必须亲自完成——运行 git log/diff 查看变更、read 相关文件并逐一分析，变更量大时分轮进行；其中可核实的子任务剥离出来委派，如"列出 FooService.create 的所有调用点"]
+</example>`;
+const CODE_REFERENCES = `# 代码引用
+
+引用特定函数或代码片段时，使用 \`file_path:line_number\` 格式，以便用户轻松导航到源代码位置。
+
+<example>
+user: 客户端的错误在哪里处理？
+assistant: 客户端连接在 \`connectToServer\` 函数中被标记为失败，位于 src/services/process.ts:712。
+</example>`;
+const TODO_SECTION = `# 任务管理
+
+你可以使用 todowrite tool 来管理和规划任务。经常使用这些工具来跟踪任务进度，并让用户了解你的进展。
+
+这些工具对于规划任务和将复杂的大型任务分解为更小的步骤也非常有用。如果在规划时不使用这个工具，你可能会忘记做重要的任务——这是不可接受的。
+
+关键的是，完成任务后应立即将 todo 标记为已完成。不要攒着多个任务一起标记完成。
+
+示例：
+
+<example>
+user: 运行构建并修复所有类型错误
+assistant: 我将使用 todowrite tool 写入以下 todo 列表：
+- 运行构建
+- 修复所有类型错误
+
+现在我将使用 bash 运行构建。
+
+看起来我发现了 10 个类型错误。我将使用 todowrite tool 写入 10 个 todo。
+
+将第一个 todo 标记为 in_progress
+
+让我从修复第一个开始...
+
+第一个已修复，将其标记为 completed，然后继续第二个...
+</example>
+在上面的示例中，助手完成了所有任务，包括 10 个错误修复以及运行构建。
+
+重要：在对话中始终使用 todowrite tool 来规划和跟踪任务。`;
+const SECTION_ORDERS_TBOX = {
+	TONE_OBJECTIVITY: 100,
+	TASK_EXECUTION: 150,
+	TOOL_DISCIPLINE: 200,
+	DELEGATION: 250,
+	CODE_REFERENCES: 300,
+	TODO_MANAGEMENT: 350,
+	USER_RULES: 400
+};
+/** 白名单二值（reminders-plugin-dissolution 定案）：真实用户输入语义。 */
+const USER_VOICE_KINDS = new Set(["user", "user-question-reply"]);
+/** plan 档权限说明文案（composition note 引导三层①；build 档空串不渲染）。 */
+function renderPermissionContext(mode, scratchDir) {
+	if (mode !== "read-only") return "";
+	return [
+		"# 权限模式：plan（只读）",
+		"",
+		`- 当前处于只读模式：文件写入与变更类 bash 命令会被内核拒绝（含系统临时目录）。`,
+		`- 需要临时验证（运行脚本、检查依赖、生成一次性产物）时，使用 scratch_bash / scratch_write / scratch_edit 三件工具——它们在会话私有的临时目录 \`${scratchDir}\` 中放行。产物的绝对路径即可直接引用。`,
+		`- 临时验证限于环境已有的依赖；不要尝试安装依赖（缓存目录写入会被拒绝）。`,
+		`- webfetch 与 curl 不得发起对目标系统有写入效果的调用。`,
+		`- 对项目的一切修改请写入计划，切回 build 模式后执行。`
+	].join("\n");
+}
+/** environment 三行（基线 env-static + env-git 精确并集；现算不 memoize）。
+* Working directory 行退役——dsh 0.2.1 原生 working-directory 服务注入
+* `Current working directory: "<path>".`（同信息超集 + 工具联动，subagent-native-adoption）。 */
+function renderEnvironmentContext(cwd) {
+	const gitState = existsSync(join(cwd, ".git")) ? "yes" : "no";
+	return [
+		`Platform: ${platform()}`,
+		`Workspace root folder: ${cwd}`,
+		`Is directory a git repo: ${gitState}`
+	].join("\n");
+}
+function apply(ctx, config = {}) {
+	const parsed = ConfigSchema.parse(config);
+	const rulesCache = /* @__PURE__ */ new Map();
+	const userRulesText = (scopeKey) => {
+		const cacheKey = String(scopeKey ?? "global");
+		if (rulesCache.has(cacheKey)) return rulesCache.get(cacheKey);
+		const lines = [];
+		for (const rule of parsed.rules ?? []) lines.push(`- ${rule}`);
+		try {
+			const rulesDir = join(resolveConfigDir(), "rules");
+			if (existsSync(rulesDir)) for (const entry of readdirSync(rulesDir).sort()) {
+				const fp = join(rulesDir, entry);
+				if (statSync(fp).isFile()) lines.push(`- ${stripJsonc(readFileSync(fp, "utf-8")).trim()}`);
+			}
+		} catch {}
+		const text = lines.length > 0 ? `# 用户规则\n\n${lines.join("\n")}` : "";
+		rulesCache.set(cacheKey, text);
+		return text;
+	};
+	const completeText = () => {
+		const raw = parsed.systemPrompt;
+		if (raw === void 0) return void 0;
+		if (raw.startsWith("file://")) {
+			const fp = raw.slice(7).replace(/^~(?=\/|$)/, homedir());
+			return existsSync(fp) ? readFileSync(fp, "utf-8") : void 0;
+		}
+		return raw;
+	};
+	const preStepHandler = async (payload, next) => {
+		const decision = await next();
+		if (decision.kind !== "enter") return decision;
+		const messages = decision.messages ?? [];
+		if (messages.some((m) => typeof m?.source?.kind !== "string")) return decision;
+		if (!messages.some((m) => USER_VOICE_KINDS.has(m.source.kind))) return decision;
+		const users = messages.filter((m) => USER_VOICE_KINDS.has(m.source.kind));
+		return {
+			kind: "enter",
+			messages: [...messages.filter((m) => !USER_VOICE_KINDS.has(m.source.kind)), ...users],
+			...decision.startsRequestSeries !== void 0 ? { startsRequestSeries: decision.startsRequestSeries } : {}
+		};
+	};
+	ctx.on("agent/pre-step", preStepHandler, { prepend: true });
+	ctx.inject(["systemPrompt"], (scope) => {
+		const sp = scope.systemPrompt;
+		const scopeGet = scope.get;
+		const tools = scopeGet?.call(scope, "tools") ?? void 0;
+		const projections = scopeGet?.call(scope, "sessionProjections") ?? void 0;
+		const sandboxModeOf = (c) => {
+			const session = c.agent?.session;
+			if (projections === void 0 || session === void 0) return void 0;
+			try {
+				return projections.stateOf(session, "sandboxMode");
+			} catch {
+				return;
+			}
+		};
+		for (const s of [
+			{
+				name: "tboxcode:tone-objectivity",
+				order: SECTION_ORDERS_TBOX.TONE_OBJECTIVITY,
+				text: TONE_OBJECTIVITY
+			},
+			{
+				name: "tboxcode:task-execution",
+				order: SECTION_ORDERS_TBOX.TASK_EXECUTION,
+				text: TASK_EXECUTION
+			},
+			{
+				name: "tboxcode:tool-discipline",
+				order: SECTION_ORDERS_TBOX.TOOL_DISCIPLINE,
+				text: TOOL_DISCIPLINE
+			},
+			{
+				name: "tboxcode:delegation",
+				order: SECTION_ORDERS_TBOX.DELEGATION,
+				text: DELEGATION
+			},
+			{
+				name: "tboxcode:code-references",
+				order: SECTION_ORDERS_TBOX.CODE_REFERENCES,
+				text: CODE_REFERENCES
+			}
+		]) sp.section(s);
+		sp.section({
+			name: "tboxcode:todo-management",
+			order: SECTION_ORDERS_TBOX.TODO_MANAGEMENT,
+			text: (c) => tools !== void 0 && tools.schemas(c.scope).some((t) => t.name === "todo_write") ? TODO_SECTION : ""
+		});
+		sp.section({
+			name: "tboxcode:user-rules",
+			order: SECTION_ORDERS_TBOX.USER_RULES,
+			text: (c) => userRulesText(c.scope)
+		});
+		const complete = completeText();
+		if (complete !== void 0) sp.section({
+			name: "tboxcode:complete",
+			order: SECTION_ORDERS_TBOX.USER_RULES + 50,
+			text: complete,
+			complete: true
+		});
+		const sandboxOrder = sp.getContextOrder("SANDBOX_POLICY");
+		sp.context({
+			name: "tboxcode:permission",
+			order: sandboxOrder,
+			text: (c) => {
+				const mode = sandboxModeOf(c);
+				if (mode === void 0) return "";
+				return renderPermissionContext(mode, scratchDirFor(c.agent?.session?.header?.id ?? "adhoc"));
+			}
+		});
+		sp.context({
+			name: "tboxcode:model",
+			order: sandboxOrder - 5,
+			text: (c) => {
+				if (c.agent === void 0) return "";
+				const sel = (scope.get?.("agentDefaultModel"))?.currentSelection?.();
+				if (sel?.provider === void 0 || sel?.model === void 0) return "";
+				return `Current model: ${sel.provider}/${sel.model}`;
+			}
+		});
+		sp.context({
+			name: "tboxcode:environment",
+			order: sandboxOrder - 10,
+			text: (c) => {
+				const cwd = c.agent?.session?.header?.cwd;
+				if (c.agent === void 0 || cwd === void 0) return "";
+				return renderEnvironmentContext(cwd);
+			}
+		});
+	});
+	return () => {};
+}
+
+//#endregion
+export { USER_VOICE_KINDS, apply, inject, name, renderEnvironmentContext, renderPermissionContext };

package/lib/remote-Ci33eojc.d.ts

@@ -0,0 +1,197 @@
+import { t as ConvergenceCore } from "./convergence-core-C1ZtU17g.js";
+import { a as SweepResult, r as RetentionScheduler } from "./retention-B2V8Plpx.js";
+import { TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
+import { Context } from "@deepseek-ai/cordis";
+
+//#region src/remote.d.ts
+declare module '@deepseek-ai/dsh-typert-protocol' {
+  interface RemoteErrorDetailsMap {
+    'tboxcode/agent-not-found': {
+      readonly agentId?: string;
+      readonly sessionId?: string;
+    };
+    'tboxcode/reload-unavailable': Record<string, never>;
+    'tboxcode/retention-unavailable': Record<string, never>;
+    'tboxcode/mode-unknown': {
+      readonly mode: string;
+    };
+  }
+}
+interface RemoteAgentLike {
+  readonly session: {
+    readonly header: {
+      readonly cwd?: string;
+    };
+  };
+}
+interface DefaultModelSelection {
+  provider?: unknown;
+  model?: unknown;
+  reasoningEffort?: unknown;
+}
+interface TboxcodeRemoteServices {
+  agents: {
+    get(sessionId: string): (RemoteAgentLike & Record<string, unknown>) | undefined;
+  };
+  commands: {
+    list(agent: unknown): ReadonlyArray<Record<string, unknown>>;
+    execute(agent: unknown, line: string, args: readonly string[], signal: AbortSignal): Promise<{
+      commandId?: string;
+    } | undefined>;
+  };
+  skills: {
+    snapshot(options: {
+      cwd?: string;
+    }): Promise<{
+      skills: ReadonlyArray<Record<string, unknown>>;
+    }>;
+  };
+  approval: {
+    setPolicy(agent: unknown, policy: unknown): unknown;
+  };
+  agentDefaultModel: {
+    currentSelection(): DefaultModelSelection;
+  };
+  sessions: {
+    get(sessionId: string): unknown;
+    flush(session: unknown): Promise<void>;
+  };
+  /** 持久头 stat（resume cwd 匹配面——冷会话 undefined 不抛）。 */
+  persistence: {
+    stat(sessionId: string): Promise<{
+      header: Record<string, unknown>;
+    } | undefined>;
+  };
+  /** 进程事件订阅（watch 流源——skills/change / agent/inbox/claimed / agent/error）。 */
+  on: (event: string, listener: (payload: unknown) => void) => () => void;
+  sandbox: {
+    setSandboxMode(session: unknown, mode: unknown): unknown;
+  };
+  convergence?: ConvergenceCore;
+  retention?: RetentionScheduler;
+  memoryUsage?: () => NodeJS.MemoryUsage;
+  uptime?: () => number;
+  now?: () => number;
+}
+declare function handleCommandsList(services: TboxcodeRemoteServices, request: {
+  agentId: string;
+}): ReadonlyArray<Record<string, unknown>>;
+declare function handleCommandsExecute(services: TboxcodeRemoteServices, request: {
+  agentId: string;
+  line: string;
+}, signal: AbortSignal): Promise<{
+  commandId?: string;
+} | undefined>;
+/** mode 通道（载体二）：translateMode（bridge-core 语义映射单源）→ 双 knob 落地。 */
+declare function handleMode(services: TboxcodeRemoteServices, request: {
+  agentId: string;
+  mode: string;
+}): {
+  sandbox: unknown;
+  approval: unknown;
+};
+/** 部署默认行（configOptions model 项 initialValue 面——未配置返回 undefined）。 */
+declare function handleDefaultSelection(services: TboxcodeRemoteServices): {
+  provider?: string;
+  model?: string;
+  reasoningEffort?: string;
+};
+declare function handleSkillsUserInvocable(services: TboxcodeRemoteServices, request: {
+  agentId: string;
+}): Promise<ReadonlyArray<Record<string, unknown>>>;
+declare function handleSessionsFlush(services: TboxcodeRemoteServices, request: {
+  sessionId: string;
+}): Promise<void>;
+/** 会话头 stat（resume cwd 匹配面——冷会话返 null 不抛；网关 persistence.stat 对位）。 */
+declare function handleSessionsStat(services: TboxcodeRemoteServices, request: {
+  sessionId: string;
+}): Promise<{
+  header: Record<string, unknown>;
+} | null>;
+/**
+ * skills/change 转发流（P5-3 定案：skills/change 不在 $events allowlist——
+ * 零上游变更的进程内桥接；payload-free seq 递增，消费方重取 commands.list）。
+ */
+declare function handleSkillsWatch(services: TboxcodeRemoteServices, signal: AbortSignal): AsyncIterable<{
+  seq: number;
+}>;
+/** watch 流载荷（agentWatch——claim 关联 + 失败分支两类）。 */
+type AgentWatchItem = {
+  kind: 'inboxClaimed';
+  sessionId: string;
+  messageId?: string;
+  turn: number;
+} | {
+  kind: 'error';
+  sessionId: string;
+  error: string;
+};
+/**
+ * agent/inbox/claimed + agent/error 转发流（P5-3 定案：journal turn/start 仅
+ * {turn} 无 messageId——prompt 完成相关性与失败分支必须走进程事件；两类聚合
+ * 单流，sessionId 经 agent 句柄防御性提取）。
+ */
+declare function handleAgentWatch(services: TboxcodeRemoteServices, signal: AbortSignal): AsyncIterable<AgentWatchItem>;
+/** 热载触发（convergence reloadNow 包装——忙时 RETRY_AFTER_TURN 拒绝语义透传）。 */
+declare function handleReload(services: TboxcodeRemoteServices): Promise<void>;
+/** health（内存观测指标源——doctor --server 画像；会话/冷热分布经 api session/list 面）。 */
+declare function handleHealth(services: TboxcodeRemoteServices): {
+  memory: {
+    rss: number;
+    heapUsed: number;
+    heapTotal: number;
+    external: number;
+  };
+  uptimeMs: number;
+  retentionLast?: SweepResult;
+};
+/** retention.run（手动触发——调度面之外的运维通道）。 */
+declare function handleRetentionRun(services: TboxcodeRemoteServices): Promise<SweepResult>;
+declare const name = "tboxcode-remote";
+declare const inject: readonly ["agents", "commands", "skills", "approval", "agentDefaultModel", "sessions", "sessionPersistence", "tboxcodeConvergence"];
+/** 宿主服务行（结构行——四链恒挂；sandbox 写函数经 ctx 进程内直调）。 */
+declare class TboxcodeRemoteGateway extends TypertRemoteService {
+  static inject: readonly ["agents", "commands", "skills", "approval", "agentDefaultModel", "sessions", "sessionPersistence", "tboxcodeConvergence"];
+  constructor(ctx: Context);
+  commandsList(request: {
+    agentId: string;
+  }): ReadonlyArray<Record<string, unknown>>;
+  commandsExecute(request: {
+    agentId: string;
+    line: string;
+  }, signal: AbortSignal): Promise<{
+    commandId?: string;
+  } | undefined>;
+  mode(request: {
+    agentId: string;
+    mode: string;
+  }): {
+    sandbox: unknown;
+    approval: unknown;
+  };
+  defaultSelection(): {
+    provider?: string;
+    model?: string;
+    reasoningEffort?: string;
+  };
+  skillsUserInvocable(request: {
+    agentId: string;
+  }): Promise<ReadonlyArray<Record<string, unknown>>>;
+  sessionsFlush(request: {
+    sessionId: string;
+  }): Promise<void>;
+  sessionsStat(request: {
+    sessionId: string;
+  }): Promise<{
+    header: Record<string, unknown>;
+  } | null>;
+  skillsWatch(signal: AbortSignal): AsyncIterable<{
+    seq: number;
+  }>;
+  agentWatch(signal: AbortSignal): AsyncIterable<AgentWatchItem>;
+  reload(): Promise<void>;
+  health(): ReturnType<typeof handleHealth>;
+  retentionRun(): Promise<SweepResult>;
+}
+//#endregion
+export { handleSkillsWatch as _, TboxcodeRemoteServices as a, handleCommandsList as c, handleMode as d, handleReload as f, handleSkillsUserInvocable as g, handleSessionsStat as h, TboxcodeRemoteGateway as i, handleDefaultSelection as l, handleSessionsFlush as m, DefaultModelSelection as n, handleAgentWatch as o, handleRetentionRun as p, RemoteAgentLike as r, handleCommandsExecute as s, AgentWatchItem as t, handleHealth as u, inject as v, name as y };