@aiti-ai/aiti-omp-agent 0.0.0-stage → 0.1.7

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 aiti-ai contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/external-governance.ts

@@ -0,0 +1,138 @@
+/**
+ * external-cli-governance —— 外部 CLI provider 的治理模式（共享源，复制到各扩展目录部署）
+ *
+ * 来源：pi-subagents 0.58 外部 runner 的治理模式抄写（MIT），适配本仓库 provider 槽。
+ * 权威源：pi-web-ext/_shared/external-cli-governance.ts（改动后同步到各扩展副本）。
+ * 当前副本：aiti-{claude-code,codex,pi,acp}-agent/external-governance.ts
+ *
+ * 四件治理：
+ *   1. env allowlist（governanceEnv）——spawn 只透传白名单环境变量，父进程的
+ *      其他密钥（各家 API key/auth token）不再泄入子 CLI 进程。
+ *   2. preflight（preflightCli）——启动前探测二进制存在 + 版本（带 TTL 缓存），
+ *      fail-loud 提示替代运行时 spawn ENOENT。
+ *   3. 能力收窄文案表（CAPABILITY_NOTICE 模式）——不支持的能力带人话理由
+ *      （我们 provider 槽 capabilities 布尔位之上的文案层，guard 消费后续接）。
+ *   4. 读写分型（READONLY_TOOL_ARGS 模式）——只读变体显式声明（-writer 后缀
+ *      反向约定：默认只读，writer 才放开写）。
+ */
+
+import { execFile } from "node:child_process";
+
+// ---------------------------------------------------------------------------
+// 1) env allowlist
+// ---------------------------------------------------------------------------
+
+/** 所有外部 CLI 通用的基础白名单（系统定位 + 代理 + TLS）。 */
+export const BASE_ENV_ALLOW = [
+	"PATH", "HOME", "USERPROFILE", "USER", "LOGNAME", "TMPDIR", "TEMP", "TMP",
+	"LANG", "LC_ALL", "TERM",
+	"HTTP_PROXY", "HTTPS_PROXY", "NO_PROXY",
+	"http_proxy", "https_proxy", "no_proxy",
+	"SSL_CERT_FILE", "SSL_CERT_DIR",
+] as const;
+
+/** 各 CLI 专属键（与 pi-subagents claude-code adapter 对齐 + 本仓库常用 provider）。 */
+export const CLI_ENV_ALLOW: Record<string, string[]> = {
+	"claude-code": [
+		"CLAUDE_CONFIG_DIR",
+		"ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN", "ANTHROPIC_BASE_URL",
+		"CLAUDE_CODE_OAUTH_TOKEN", "CLAUDE_CODE_USE_BEDROCK", "CLAUDE_CODE_USE_VERTEX",
+		"CLAUDE_CODE_USE_FOUNDRY",
+		"AWS_PROFILE", "AWS_REGION", "AWS_DEFAULT_REGION",
+		"AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY", "AWS_SESSION_TOKEN", "AWS_BEARER_TOKEN_BEDROCK",
+		"GOOGLE_APPLICATION_CREDENTIALS", "CLOUD_ML_REGION", "ANTHROPIC_VERTEX_PROJECT_ID",
+	],
+	"codex": [
+		"OPENAI_API_KEY", "OPENAI_BASE_URL", "CODEX_HOME", "CODEX_API_KEY",
+		// 自定义 provider 认证（~/.codex/config.toml 的 model_providers.*.env_key），
+		// 如 openrouter 桥接 provider——缺了它轮次直接 turn.failed（Missing environment variable）。
+		"OPENROUTER_API_KEY",
+	],
+	"pi": [
+		// pi 自身及其 provider 认证走 agent 目录（models.json/auth.json），
+		// 环境变量只留运行时与常见 provider 前缀（防误伤自定义 provider）。
+		"PI_CODING_AGENT_DIR", "PI_WEB_PKG_DIR",
+		"ANTHROPIC_API_KEY", "OPENAI_API_KEY", "GOOGLE_API_KEY", "GEMINI_API_KEY",
+		"ZAI_API_KEY", "DEEPSEEK_API_KEY", "MOONSHOT_API_KEY", "KIMI_API_KEY",
+		"QWEN_API_KEY", "DASHSCOPE_API_KEY", "OPENROUTER_API_KEY",
+		"SILICONFLOW_API_KEY", "XAI_API_KEY", "GROQ_API_KEY", "MISTRAL_API_KEY",
+	],
+	"acp": [
+		"ACP_*",
+	],
+};
+
+/**
+ * 生成治理后的子进程 env：白名单键（精确 + `前缀*` 通配）+ extra 覆盖。
+ * 替代 `env: { ...process.env }` 的全量透传。
+ */
+export function governanceEnv(cli: keyof typeof CLI_ENV_ALLOW | string, extra?: Record<string, string>): Record<string, string> {
+	const allow = [...BASE_ENV_ALLOW, ...(CLI_ENV_ALLOW[cli as string] ?? [])];
+	const out: Record<string, string> = {};
+	for (const k of Object.keys(process.env)) {
+		const hit = allow.some((a) => (a.endsWith("*") ? k.startsWith(a.slice(0, -1)) : k === a));
+		if (hit && process.env[k] !== undefined) out[k] = process.env[k] as string;
+	}
+	return { ...out, ...(extra ?? {}) };
+}
+
+// ---------------------------------------------------------------------------
+// 2) preflight
+// ---------------------------------------------------------------------------
+
+const preflightCache = new Map<string, { at: number; version: string | null; ok: boolean }>();
+
+/**
+ * 启动前探测：二进制可执行 + 可选版本（`--version`）。TTL 缓存，失败不缓存负面结果以外的信息。
+ * 返回 { ok, version, error }——ok=false 时 error 是给人看的失败原因（fail-loud）。
+ */
+export function preflightCli(bin: string, opts: { versionArgs?: string[]; timeoutMs?: number; ttlMs?: number } = {}): Promise<{ ok: boolean; version: string | null; error?: string }> {
+	const ttl = opts.ttlMs ?? 60_000;
+	const cached = preflightCache.get(bin);
+	if (cached && Date.now() - cached.at < ttl) {
+		return Promise.resolve(cached.ok
+			? { ok: true, version: cached.version }
+			: { ok: false, version: null, error: cached.version ?? `${bin} 探测失败` });
+	}
+	return new Promise((resolve) => {
+		execFile(bin, opts.versionArgs ?? ["--version"], { timeout: opts.timeoutMs ?? 5_000 }, (err, stdout) => {
+			if (err) {
+				const msg = String((err as NodeJS.ErrnoException).code) === "ENOENT"
+					? `${bin} 未安装或不在 PATH`
+					: `${bin} 探测失败: ${err.message.split("\n")[0]}`;
+				preflightCache.set(bin, { at: Date.now(), version: msg, ok: false });
+				resolve({ ok: false, version: null, error: msg });
+				return;
+			}
+			const version = String(stdout).trim().split("\n")[0]?.slice(0, 64) ?? null;
+			preflightCache.set(bin, { at: Date.now(), version, ok: true });
+			resolve({ ok: true, version });
+		});
+	});
+}
+
+// ---------------------------------------------------------------------------
+// 3) 能力收窄文案表（模式示例——provider 按需声明，guard 消费后续接）
+// ---------------------------------------------------------------------------
+
+/** 不支持能力的人话理由（替代裸 false；provider 的 capabilities 旁路声明）。 */
+export interface CapabilityNotices {
+	[capability: string]: string;
+}
+
+/** one-shot stdin 型外部 CLI 的通用收窄理由（pi-subagents external-cli-contract 对齐）。 */
+export const ONESHOT_CLI_NOTICES: CapabilityNotices = {
+	steer: "one-shot stdin 模式在启动后关闭输入，无法接受运行中导向消息。",
+	fork: "外部 CLI 会话无原生 fork 语义（无 pi session 树）。",
+	compact: "外部 CLI 不暴露上下文压缩接口。",
+	setActiveTools: "外部 CLI 的工具白名单只能启动时声明，不能运行中切换。",
+};
+
+// ---------------------------------------------------------------------------
+// 4) 读写分型
+// ---------------------------------------------------------------------------
+
+/** 只读变体的 CLI 参数（writer 变体反向约定：默认只读，writer 才放开写）。 */
+export const READONLY_TOOL_ARGS: Record<string, string[]> = {
+	"claude-code": ["--allowedTools", "Read,Glob,Grep"],
+};

package/fork-rpc/cli-resolve.ts

@@ -0,0 +1,79 @@
+/**
+ * cli-resolve.ts — fork CLI 解析（载体无关）。
+ * 拆自 aiti-pi-agent 的 pi-rpc-spawn.ts：resolveForkCli / resolveBun / which。
+ */
+
+import { existsSync, statSync } from "node:fs";
+import { join } from "node:path";
+import type { PiForkSpec } from "./spec.ts";
+
+export interface ResolvedForkCli {
+  /** 实际执行的解释器（node / bun）。 */
+  runner: string;
+  /** 解释器参数（通常 [cliPath]；PATH 可执行直跑时 []）。 */
+  args: string[];
+  /** 人类可读的解析来源（日志/报错用）。 */
+  origin: string;
+}
+
+/**
+ * 解析 fork CLI。解析顺序：
+ *   1) spec.cliEnvVar 显式指定（绝对路径，交给 runtime 解释）
+ *   2) spec.bundledCli()（pi：pi-web 包内 SDK cli.js，node 解释）
+ *   3) PATH 上的 spec.pathBin（绝对路径 → runtime 解释；找不到 → null）
+ *
+ * fork 未装时返回 null：provider 照常注册，createSession 报清晰错误（不阻塞列表）。
+ */
+export function resolveForkCli(spec: PiForkSpec): ResolvedForkCli | null {
+  const explicit = process.env[spec.cliEnvVar];
+  if (explicit && existsSync(explicit)) {
+    return { runner: spec.runtime === "bun" ? resolveBun() : process.execPath, args: [explicit], origin: `env ${spec.cliEnvVar}` };
+  }
+  const bundled = spec.bundledCli?.();
+  if (bundled) {
+    return { runner: process.execPath, args: [bundled], origin: "bundled SDK" };
+  }
+  const onPath = which(spec.pathBin);
+  if (onPath) {
+    return { runner: spec.runtime === "bun" ? resolveBun() : process.execPath, args: [onPath], origin: `PATH ${spec.pathBin}` };
+  }
+  // 兜底：bun 全局安装目录（systemd 等服务进程 PATH 通常不含 ~/.bun/bin）
+  const bunGlobalBin = join(process.env.HOME || "", ".bun", "bin", spec.pathBin);
+  if (spec.runtime === "bun" && existsSync(bunGlobalBin)) {
+    return { runner: resolveBun(), args: [bunGlobalBin], origin: "~/.bun/bin" };
+  }
+  return null;
+}
+
+/** bun 解释器解析：env BUN → PATH bun。找不到返回 "bun"（让 spawn 报 ENOENT，fail loud）。 */
+export function resolveBun(): string {
+  return process.env.BUN || "bun";
+}
+
+/** PATH 查找可执行文件（同步；Windows 兼容：`;` 分隔 + PATHEXT 后缀 + isFile 校验；
+ *  POSIX 额外要求可执行位）。找不到返回 undefined。 */
+export function which(bin: string): string | undefined {
+  const isWin = process.platform === "win32";
+  const pathDirs = (process.env.PATH ?? "").split(isWin ? ";" : ":").filter(Boolean);
+  // Windows 还要试 PATHEXT 后缀（pi.cmd / pi.exe …）；首项空串 = 精确名优先
+  const exts = isWin ? ["", ...(process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";")] : [""];
+  for (const dir of pathDirs) {
+    for (const ext of exts) {
+      const candidate = join(dir, bin + ext);
+      if (isExecutableFile(candidate)) return candidate;
+    }
+  }
+  return undefined;
+}
+
+/** 候选必须是文件（目录命名的同名项不算）且可执行（POSIX 查可执行位）。 */
+function isExecutableFile(path: string): boolean {
+  let st;
+  try {
+    st = statSync(path);
+  } catch {
+    return false;
+  }
+  if (!st.isFile()) return false;
+  return process.platform === "win32" || (st.mode & 0o111) !== 0;
+}

package/fork-rpc/remote-queue.ts

@@ -0,0 +1,140 @@
+/**
+ * remote-queue — 远端 pi 协议队列的 queueManage 适配层（共享层，副本随扩展部署——改动须双向同步；
+ * docs/aiti-remote-queue-and-sidecar-plan.md §2）。
+ *
+ * 适用形态：pi RPC 子进程（aiti-pi-agent）与其超集 fork omp（aiti-omp-agent）——队列由
+ * 子进程持有，协议原生支持 clear_queue（返回清空前文本，与 pi-web core clearQueue 同契约）
+ * 与 steer/follow_up 重注入；子进程经 RPC 流转发 queue_update 帧（含完整文本数组）。
+ *
+ * 镜像正确性：handle 生命周期 == 子进程生命周期，双方同起点（皆空），无重连缺口——
+ * 镜像只从 observeFrame 喂入的 queue_update 帧维护。get_state 仅有 pendingMessageCount
+ * （无文本），不存在「拉全量」原语，重连场景不在本层适配范围。
+ *
+ * 变更类操作语义（与 pi-web core rpc-manager move_queue 同款）：镜像算出新序 →
+ * clear_queue 全量清空 → 按新序重注入。运行中 steer 重注入可能被立即消费的竞态
+ * 为该策略既有语义（clear+re-enqueue 在单请求内原子性足够）。
+ */
+
+export interface RemoteQueueManageReq {
+  action: "list" | "clear" | "move" | "convert" | "remove" | "recall" | "requeue";
+  kind?: "steer" | "followUp";
+  from?: number;
+  to?: number;
+  index?: number;
+  targetKind?: "steer" | "followUp";
+  text?: string;
+}
+
+export interface RemoteQueueManageResult {
+  steering: string[];
+  followUp: string[];
+  entry?: { text: string };
+  /** remove 时返回（对齐 backend-queue / pi-web core QueueTrashItem 的文本字段）。 */
+  removed?: { text: string };
+}
+
+export interface RemotePiQueue {
+  /** handle.onFrame 里喂入子进程帧；只消费 queue_update（镜像维护，不重复广播——原帧由 handle 照常 emit）。 */
+  observeFrame(msg: Record<string, unknown>): void;
+  /** SessionHandle.queueManage 直转发。 */
+  queueManage(req: RemoteQueueManageReq): Promise<RemoteQueueManageResult>;
+  /** 当前镜像快照（steer/followUp 两组文本）。 */
+  snapshot(): { steering: string[]; followUp: string[] };
+}
+
+export function createRemotePiQueueSupport(opts: {
+  /** 子进程 clear_queue 请求（返回清空前文本；上游不支持时 fail-loud 由调用方人话化）。 */
+  clearRemote(): Promise<{ steering?: string[]; followUp?: string[] }>;
+  /** 重注入单条（kind=steer → steer 命令；followUp → follow_up 命令）。 */
+  reinject(text: string, kind: "steer" | "followUp"): Promise<void>;
+}): RemotePiQueue {
+  let mirror: { steering: string[]; followUp: string[] } = { steering: [], followUp: [] };
+
+  const snapshot = () => ({ steering: [...mirror.steering], followUp: [...mirror.followUp] });
+
+  const observeFrame = (msg: Record<string, unknown>): void => {
+    if (msg.type !== "queue_update") return;
+    mirror = {
+      steering: Array.isArray(msg.steering) ? (msg.steering as string[]).map(String) : [],
+      followUp: Array.isArray(msg.followUp) ? (msg.followUp as string[]).map(String) : [],
+    };
+  };
+
+  /** 变更类共用骨架：对镜像副本计算新序 → 远端全量清空 → 按新序重注入 → 镜像落为新序。 */
+  const mutate = async (
+    plan: (cur: { steering: string[]; followUp: string[] }) => { steering: string[]; followUp: string[] },
+  ): Promise<void> => {
+    const next = plan(snapshot());
+    await opts.clearRemote();
+    for (const text of next.steering) await opts.reinject(text, "steer");
+    for (const text of next.followUp) await opts.reinject(text, "followUp");
+    mirror = { steering: [...next.steering], followUp: [...next.followUp] };
+  };
+
+  const at = (arr: string[], i: number | undefined): number => {
+    const n = Number(i);
+    if (!Number.isInteger(n) || n < 0 || n >= arr.length) throw new Error("队列索引越界");
+    return n;
+  };
+
+  const queueManage = async (req: RemoteQueueManageReq): Promise<RemoteQueueManageResult> => {
+    if (req.action === "list") return { ...snapshot() };
+    switch (req.action) {
+      case "clear": {
+        // 远端权威清空：返回值 = 清空前文本（即「清掉了什么」，snapshot 语义不适用）
+        const cleared = await opts.clearRemote();
+        mirror = { steering: [], followUp: [] };
+        return { steering: (cleared.steering ?? []).map(String), followUp: (cleared.followUp ?? []).map(String) };
+      }
+      case "remove":
+      case "recall": {
+        const cur = snapshot();
+        const group = req.kind === "steer" ? cur.steering : cur.followUp;
+        const [picked] = group.splice(at(group, req.index), 1);
+        await mutate(() => cur);
+        return {
+          steering: cur.steering,
+          followUp: cur.followUp,
+          entry: { text: picked },
+          ...(req.action === "remove" ? { removed: { text: picked } } : {}),
+        };
+      }
+      case "move": {
+        const cur = snapshot();
+        const group = req.kind === "steer" ? cur.steering : cur.followUp;
+        // 两个索引都在删除前对原长度校验（pi-web core move_queue 同款语义）
+        const from = at(group, req.from);
+        const to = at(group, req.to);
+        const [moved] = group.splice(from, 1);
+        group.splice(to, 0, moved);
+        await mutate(() => cur);
+        return { steering: cur.steering, followUp: cur.followUp };
+      }
+      case "requeue": {
+        const cur = snapshot();
+        const group = req.kind === "steer" ? cur.steering : cur.followUp;
+        const i = Number(req.index);
+        const text = String(req.text ?? "");
+        if (!Number.isInteger(i) || i < 0 || i > group.length) throw new Error("队列索引越界");
+        if (!text.trim()) throw new Error("requeue 需要非空文本");
+        group.splice(i, 0, text);
+        await mutate(() => cur);
+        return { steering: cur.steering, followUp: cur.followUp };
+      }
+      case "convert": {
+        const target = req.targetKind === "followUp" ? "followUp" : "steer";
+        const kind = req.kind === "steer" ? "steer" : "followUp";
+        if (target === kind) throw new Error("convert 需要不同于当前的 targetKind");
+        const cur = snapshot();
+        const [picked] = (kind === "steer" ? cur.steering : cur.followUp).splice(at(kind === "steer" ? cur.steering : cur.followUp, req.index), 1);
+        (target === "steer" ? cur.steering : cur.followUp).push(picked);
+        await mutate(() => cur);
+        return { steering: cur.steering, followUp: cur.followUp, entry: { text: picked } };
+      }
+      default:
+        throw new Error(`queueManage: 未知 action "${String(req.action)}"`);
+    }
+  };
+
+  return { observeFrame, queueManage, snapshot };
+}

package/fork-rpc/spec.ts

@@ -0,0 +1,106 @@
+/**
+ * spec.ts — pi 系 fork 家族的类型与能力声明（载体无关，无 fork 语义之外的逻辑）。
+ * 拆自 aiti-pi-agent 的 pi-rpc-spawn.ts：类型/常量原样迁移；registerFork/listForks
+ * （家族注册机制）随拆分退役——每个扩展各自声明自己的 spec。
+ */
+
+// ============================================================================
+// 家族差异声明
+// ============================================================================
+
+export interface PiForkCommands {
+  /** fork 元语命令名：pi=fork；omp=branch。 */
+  fork: "fork" | "branch";
+  /** fork 消息查询命令名（本引擎暂未消费，声明给后续 viewer 用）。 */
+  getForkMessages: "get_fork_messages" | "get_branch_messages";
+  /** 命令清单查询命令名：pi=get_commands；omp=get_available_commands。 */
+  getCommands: "get_commands" | "get_available_commands";
+  /** 是否支持 get_entries（pi true；omp false → 走 get_messages）。 */
+  hasGetEntries: boolean;
+  /** 是否有启动 ready 握手帧（omp true；pi 无 → 300ms sleep 兜底）。 */
+  hasReadyFrame: boolean;
+  /** get_state 是否含 contextUsage（omp true）。 */
+  hasContextUsage: boolean;
+  /** get_state 是否含 dumpTools（omp true）。 */
+  hasDumpTools: boolean;
+  /** 是否支持宿主工具注入（omp set_host_tools / host_tool_call｜result｜cancel）。 */
+  hasHostTools: boolean;
+  /** 是否支持 OAuth 登录 RPC（omp get_login_providers/login → open_url 帧；pi 无）。 */
+  hasLogin: boolean;
+  /** A09：subagent RPC 面（omp get_subagents/set_subagent_subscription/get_subagent_messages；pi 无）。 */
+  hasSubagents: boolean;
+}
+
+export interface PiForkSpec {
+  /** 家族成员 id（= provider type 后缀：spawn / omp-spawn）。 */
+  id: string;
+  /** Backend 下拉 UI label。 */
+  label: string;
+  /** Backend 下拉位次（SessionProvider.order）。 */
+  order: number;
+  /** agentKey（all-sessions 认领键；omp 会话落 ~/.omp，不认领 pi 历史）。 */
+  agentKey?: string;
+  /** 执行运行时：node → 显式 process.execPath 解释 cli.js；bun → 显式 bun 解释。 */
+  runtime: "node" | "bun";
+  /** PATH 上的 CLI 名（pi / omp）。 */
+  pathBin: string;
+  /** 显式 CLI 覆盖 env 变量名（如 OMP_CLI）。 */
+  cliEnvVar: string;
+  /** 包内自带 SDK cli.js 路径（pi 专用：PI_WEB_PKG_DIR）；无则不启用该解析层。 */
+  bundledCli?(): string | undefined;
+  commands: PiForkCommands;
+}
+
+/**
+ * 宿主工具定义（omp host tools）：宿主注入给 fork 子进程的工具；agent 调用时经
+ * `host_tool_call` 帧回传宿主执行，宿主以 `host_tool_result` 应答（omp 独有能力）。
+ */
+export interface HostToolDefinition {
+  name: string;
+  label?: string;
+  description: string;
+  /** JSON Schema（omp RpcHostToolDefinition.parameters）。 */
+  parameters: Record<string, unknown>;
+  /** 宿主执行体：返回文本结果；抛错 → isError 结果帧。 */
+  execute(args: Record<string, unknown>, signal: AbortSignal): Promise<string>;
+}
+
+/** Handle 能力位（SessionCapabilities 的 fork 家族子集，前端据此渲染操作面）。 */
+export interface ForkCapabilities extends Record<string, boolean> {}
+
+/** 由 spec.commands 派生能力位（pi/omp 各扩展以此声明 maxCapabilities）。 */
+export function capabilitiesFor(spec: PiForkSpec): ForkCapabilities {
+  return {
+    steer: true,
+    followUp: true,
+    // 队列 keeper 全 CRUD（remote-queue 共享层：clear_queue 原生 + clear/重注入变更策略，
+    // docs/aiti-remote-queue-and-sidecar-plan.md §2）
+    queueManage: true,
+    // steering 条目同样可撤回/移动/转换（变更即 clear+重注入）——宿主据此放开队列面板
+    // steer 行的行级操作；zcode 那类「已注入对端进程、协议收不回」的后端不声明
+    steerQueueManage: true,
+    getMessages: true,
+    contextUsage: spec.commands.hasContextUsage, // omp get_state.contextUsage；pi RPC 无
+    setModel: true,
+    setThinkingLevel: true,
+    fork: true,
+    renameSession: true,
+    compact: true,
+    executeBash: true,
+    setActiveTools: false, // 两系 RPC 均无（待实测协议面，见拆分计划 B5）
+    navigateTree: false,
+    deleteSession: false,
+    getCommands: true,
+    listModels: true,
+    listTools: spec.commands.hasDumpTools, // omp get_state.dumpTools；pi RPC 无（待实测）
+    // 进阶能力（2026-09-14 拆分时盘点）：respondInteraction 已实现，补声明；
+    // respondPermission/getUsage/fileAttachments 待实测协议面后补（B5）。
+    respondInteraction: true,
+    subagents: spec.commands.hasSubagents,
+    respondPermission: false,
+    getUsage: false,
+    fileAttachments: false,
+    respondProviderHeaders: false, // zcode 专属
+    setPermissionMode: false, // cc-connect 专属
+  };
+}