@fitlab-ai/agent-infra 0.9.1 → 0.9.3

package/README.md

@@ -5,7 +5,7 @@
 <h1 align="center">Agent Infra</h1>
 
 <p align="center">
-  Collaboration infrastructure for AI coding agents — skills, workflows, and sandboxes for Claude Code, Codex, Gemini CLI, and OpenCode.
+  Collaboration infrastructure for AI coding agents — skills, workflows, and sandboxes for Claude Code, Codex, Antigravity CLI, and OpenCode.
 </p>
 
 <p align="center">
@@ -28,7 +28,7 @@
 
 ## Why agent-infra?
 
-Teams increasingly mix Claude Code, Codex, Gemini CLI, OpenCode, and other AI TUIs in the same repository, but each tool tends to introduce its own commands, prompts, and local conventions. Without a shared layer, the result is fragmented workflows, duplicated setup, and task history that is difficult to audit.
+Teams increasingly mix Claude Code, Codex, Antigravity CLI, OpenCode, and other AI TUIs in the same repository, but each tool tends to introduce its own commands, prompts, and local conventions. Without a shared layer, the result is fragmented workflows, duplicated setup, and task history that is difficult to audit.
 
 agent-infra standardizes that shared infrastructure. It gives every supported AI TUI the same task lifecycle, the same skill vocabulary, the same project governance files, isolated development sandboxes, and the same upgrade path, so teams can switch tools without rebuilding process from scratch.
 
@@ -56,9 +56,9 @@ Once initialized, open the project in your AI TUI and install the latest skills:
 ```bash
 /import-issue 42           # AI reads the issue, creates a task, extracts requirements
 /analyze-task <task-id>    # AI scans the codebase, finds the root cause, writes analysis.md
-/review-analysis <task-id> # AI self-reviews: "Approved. 0 blockers — proceed to design."
+/review-analysis <task-id> # An isolated reviewer checks the analysis
 /plan-task <task-id>       # AI proposes a fix plan
-/review-plan <task-id>     # AI self-reviews the plan: "Approved. Ready for implementation."
+/review-plan <task-id>     # A fresh isolated reviewer checks the plan
 ```
 
 > **You review the plan and reply in natural language:**
@@ -72,7 +72,7 @@ Just fix it at the application layer in LoginService.
 
 ```bash
 /code-task <task-id>       # AI writes the fix, adds a test for user+tag@example.com — green
-/review-code <task-id>     # AI reviews its own code: "0 blockers, 1 minor (missing JSDoc)."
+/review-code <task-id>     # A fresh isolated reviewer reports one minor finding
 /code-task <task-id>       # AI fixes the minor issue and re-validates
 /commit
 /create-pr <task-id>       # PR opened, auto-linked to issue #42
@@ -81,11 +81,11 @@ Just fix it at the application layer in LoginService.
 
 **11 commands. 1 natural-language correction. From issue to merged PR.** That is the entire SOP — programming can have a standard operating procedure too.
 
-Every command above works the same way in Claude Code, Codex, Gemini CLI, and OpenCode. Switch tools mid-task — the workflow state follows. For what each skill does under the hood, see [Built-in AI Skills](./docs/en/skills.md).
+Every command above works the same way in Claude Code, Codex, Antigravity CLI, and OpenCode. Switch tools mid-task — the workflow state follows. For what each skill does under the hood, see [Built-in AI Skills](./docs/en/skills.md).
 
 ## Key Features
 
-- **Multi-AI collaboration**: one shared operating model for Claude Code, Codex, Gemini CLI, and OpenCode
+- **Multi-AI collaboration**: one shared operating model for Claude Code, Codex, Antigravity CLI, and OpenCode
 - **Bootstrap CLI + skill-driven execution**: initialize once, then let AI skills drive day-to-day work
 - **IM command bridge**: route Feishu messages to built-ins, read-only task views, sandbox management, and controlled lifecycle skill runs
 - **Bilingual project docs**: English-first docs with synchronized Chinese translations
@@ -141,7 +141,7 @@ ai init
 # or: agent-infra init
 ```
 
-The CLI collects project metadata, installs the `update-agent-infra` seed command for all supported AI TUIs, and generates `.agents/.airc.json`.
+The CLI collects project metadata, lets you select the enabled Agent Clients, installs their `update-agent-infra` seed commands, and generates `.agents/.airc.json`.
 
 > `ai` is a shorthand for `agent-infra`. Both commands are equivalent.
 
@@ -153,23 +153,36 @@ Open the project in any AI TUI and run `update-agent-infra`:
 |-----|---------|
 | Claude Code | `/update-agent-infra` |
 | Codex | `$update-agent-infra` |
-| Gemini CLI | `/{{project}}:update-agent-infra` |
+| Antigravity CLI | `/update-agent-infra` |
 | OpenCode | `/update-agent-infra` |
 
 This detects the packaged template version and renders all managed files. The same command is used both for first-time setup and for future template upgrades.
 
 ## Core Commands
 
-The most-used lifecycle commands, in delivery order. The command prefix varies by TUI (`/skill` in Claude Code/OpenCode, `$skill` in Codex, `/{{project}}:skill` in Gemini CLI); the workflow semantics stay the same.
+Manage the four built-in Agent Clients independently from the project lifecycle:
+
+```bash
+ai agent-client list
+ai agent-client status
+ai agent-client enable codex
+ai agent-client disable antigravity-cli
+ai agent-client configure
+```
+
+The most-used lifecycle commands, in delivery order. The command prefix varies by TUI (`/skill` in Claude Code/Antigravity/OpenCode and `$skill` in Codex); the workflow semantics stay the same.
 
 | Command | Purpose |
 |---------|---------|
 | `create-task` / `import-issue` | Start a task from a description or a GitHub Issue |
+| `run-task` | Resume the lifecycle with fresh isolated executors/reviewers when the selected client exposes verified actual model/effort evidence; current built-in clients, including Claude Code and Codex, fail closed before delegation because their native start events do not expose all required evidence |
 | `analyze-task` → `review-analysis` | Capture scope and risks, then review the analysis |
 | `plan-task` → `review-plan` | Design the approach, then review the plan |
 | `code-task` → `review-code` | Implement and test, then run a structured code review |
 | `commit` → `create-pr` → `complete-task` | Commit, open a PR, and archive the task |
 
+Start with one atomic role policy, for example: `$run-task 42 --executor-model <id> --executor-reasoning-effort <value> --reviewer-model <id> --reviewer-reasoning-effort <value>`. Both roles may use the same model. With no explicit policy, `run-task` reads the current Agent Client's optional `agentClients[].orchestration`; if neither source is complete, it shows the host model-selection guidance before creating any run. Re-entry uses the persisted v2 policy.
+
 See the full catalog — task status, release, security, and project-maintenance skills — in [Built-in AI Skills](./docs/en/skills.md).
 
 ## What You Get
@@ -185,7 +198,6 @@ my-project/
 │   ├── workflows/         # 4 prebuilt workflows
 │   └── templates/         # Task and artifact templates
 ├── .claude/               # Claude Code config and commands
-├── .gemini/               # Gemini CLI config and commands
 ├── .opencode/             # OpenCode config and commands
 └── AGENTS.md              # Universal AI agent instructions
 ```
@@ -197,6 +209,7 @@ In-depth guides live under [`docs/en/`](./docs/en/README.md):
 - [Architecture Overview](./docs/en/architecture.md) — bootstrap CLI, end-to-end flow, layered architecture
 - [Platform Support](./docs/en/platform-support.md) — macOS, Linux, Windows; sandbox engines and resources
 - [Sandbox](./docs/en/sandbox.md) — sandbox aliases, host-sandbox file exchange, user-level dotfiles channel
+- [Benchmark Contract and Threat Model](./docs/en/benchmark.md) — versioned benchmark schemas, trust boundaries, and security guarantees
 - [Feishu Bridge](./docs/en/feishu-bridge.md) — configure the Feishu long-connection adapter, command routing, permissions, and TUI selection
 - [Built-in AI Skills](./docs/en/skills.md) — the full skill catalog by use case
 - [Custom Skills](./docs/en/custom-skills.md) — create and sync project-specific skills

package/README.zh-CN.md

@@ -5,7 +5,7 @@
 <h1 align="center">Agent Infra</h1>
 
 <p align="center">
-  AI 编程代理的协作基础设施 —— 为 Claude Code、Codex、Gemini CLI、OpenCode 提供 skills、工作流和沙箱。
+  AI 编程代理的协作基础设施 —— 为 Claude Code、Codex、Antigravity CLI、OpenCode 提供 skills、工作流和沙箱。
 </p>
 
 <p align="center">
@@ -28,7 +28,7 @@
 
 ## 为什么需要 agent-infra？
 
-越来越多的团队会在同一个仓库里混用 Claude Code、Codex、Gemini CLI、OpenCode 等 AI TUI，但每个工具往往都会带来自己的命令体系、提示词习惯和本地约定。缺少共享层时，结果通常是工作流割裂、初始化重复、任务历史难以追踪。
+越来越多的团队会在同一个仓库里混用 Claude Code、Codex、Antigravity CLI、OpenCode 等 AI TUI，但每个工具往往都会带来自己的命令体系、提示词习惯和本地约定。缺少共享层时，结果通常是工作流割裂、初始化重复、任务历史难以追踪。
 
 agent-infra 的目标就是把这层共享基础设施标准化。它为所有支持的 AI TUI 提供统一的任务生命周期、统一的 skill 词汇、统一的项目治理文件、隔离的开发沙箱以及统一的升级路径，让团队切换工具时不必重新发明流程。
 
@@ -55,9 +55,9 @@ agent-infra 的目标就是把这层共享基础设施标准化。它为所有
 ```bash
 /import-issue 42           # AI 读取 Issue，创建任务，提取需求
 /analyze-task <task-id>    # AI 扫描代码库，定位根因，输出 analysis.md
-/review-analysis <task-id> # AI 自审：“通过。0 阻塞项 —— 可进入方案设计。”
+/review-analysis <task-id> # 隔离 reviewer 审查分析产物
 /plan-task <task-id>       # AI 提出修复方案
-/review-plan <task-id>     # AI 自审方案：“通过，可进入编码。”
+/review-plan <task-id>     # fresh 隔离 reviewer 审查方案
 ```
 
 > **你审查方案后用自然语言回复：**
@@ -71,7 +71,7 @@ agent-infra 的目标就是把这层共享基础设施标准化。它为所有
 
 ```bash
 /code-task <task-id>       # AI 编写修复代码，添加 user+tag@example.com 测试 —— 通过
-/review-code <task-id>     # AI 审查自己的实现：“0 阻塞项，1 次要（缺少 JSDoc）。”
+/review-code <task-id>     # fresh 隔离 reviewer 报告一个次要问题
 /code-task <task-id>       # AI 修复次要问题并重新验证
 /commit
 /create-pr <task-id>       # PR 已创建，自动关联 Issue #42
@@ -80,11 +80,11 @@ agent-infra 的目标就是把这层共享基础设施标准化。它为所有
 
 **11 条命令，1 次自然语言纠正，从 Issue 到合并 PR。** 这就是完整的 SOP —— 编程也可以有标准作业流程。
 
-以上每条命令在 Claude Code、Codex、Gemini CLI、OpenCode 中完全通用。任务进行到一半切换工具，工作流状态照常延续。每个 skill 背后做了什么，见 [内置 AI Skills](./docs/zh-CN/skills.md)。
+以上每条命令在 Claude Code、Codex、Antigravity CLI、OpenCode 中完全通用。任务进行到一半切换工具，工作流状态照常延续。每个 skill 背后做了什么，见 [内置 AI Skills](./docs/zh-CN/skills.md)。
 
 ## 核心特性
 
-- **多 AI 协作**：为 Claude Code、Codex、Gemini CLI、OpenCode 提供统一的协作模型
+- **多 AI 协作**：为 Claude Code、Codex、Antigravity CLI、OpenCode 提供统一的协作模型
 - **引导 CLI + skill 驱动执行**：初始化一次，后续日常操作交给 AI skills
 - **IM 命令桥接**：把飞书消息路由到内置命令、任务只读视图、沙箱管理和受控生命周期 skill 执行
 - **双语文档**：英文为主文档，配套同步的中文版本
@@ -140,7 +140,7 @@ ai init
 # 或：agent-infra init
 ```
 
-CLI 会收集项目元数据，向所有支持的 AI TUI 安装 `update-agent-infra` 种子命令，并生成 `.agents/.airc.json`。
+CLI 会收集项目元数据，让你选择启用的 Agent Client，为其安装 `update-agent-infra` 种子命令，并生成 `.agents/.airc.json`。
 
 > `ai` 是 `agent-infra` 的简写命令，两者等价。
 
@@ -152,23 +152,36 @@ CLI 会收集项目元数据，向所有支持的 AI TUI 安装 `update-agent-in
 |-----|------|
 | Claude Code | `/update-agent-infra` |
 | Codex | `$update-agent-infra` |
-| Gemini CLI | `/{{project}}:update-agent-infra` |
+| Antigravity CLI | `/update-agent-infra` |
 | OpenCode | `/update-agent-infra` |
 
 该命令会检测当前打包模板版本并渲染所有受管理文件。首次安装和后续升级都使用同一条命令。
 
 ## 核心命令
 
-最常用的生命周期命令，按交付顺序排列。命令前缀因 TUI 而异（Claude Code/OpenCode 用 `/skill`，Codex 用 `$skill`，Gemini CLI 用 `/{{project}}:skill`），工作流语义保持一致。
+以下命令用于独立管理四个内建 Agent Client：
+
+```bash
+ai agent-client list
+ai agent-client status
+ai agent-client enable codex
+ai agent-client disable antigravity-cli
+ai agent-client configure
+```
+
+最常用的生命周期命令，按交付顺序排列。命令前缀因 TUI 而异（Claude Code/Antigravity/OpenCode 用 `/skill`，Codex 用 `$skill`），工作流语义保持一致。
 
 | 命令 | 用途 |
 |------|------|
 | `create-task` / `import-issue` | 从描述或 GitHub Issue 创建任务 |
+| `run-task` | 当所选客户端能提供已验证的 actual model/effort 证据时，用 fresh 隔离 executor/reviewer 续跑生命周期；当前内建客户端（含 Claude Code 与 Codex）因原生 start 事件未暴露全部必需证据，会在委派前失败关闭 |
 | `analyze-task` → `review-analysis` | 明确范围与风险，再审查分析 |
 | `plan-task` → `review-plan` | 设计实现路径，再审查方案 |
 | `code-task` → `review-code` | 实现并测试，再执行结构化代码审查 |
 | `commit` → `create-pr` → `complete-task` | 提交、创建 PR、归档任务 |
 
+启动时可提供原子角色策略，例如：`$run-task 42 --executor-model <id> --executor-reasoning-effort <值> --reviewer-model <id> --reviewer-reasoning-effort <值>`。两个角色可以使用同一模型。完全没有显式策略时，`run-task` 读取当前 Agent Client 可选的 `agentClients[].orchestration`；两个来源都不完整时，会在创建任何 run 前展示宿主模型选择指引。重入使用已持久化的 v2 策略。
+
 完整清单（任务状态、发布、安全、项目维护等 skill）见 [内置 AI Skills](./docs/zh-CN/skills.md)。
 
 ## 安装效果
@@ -184,7 +197,6 @@ my-project/
 │   ├── workflows/         # 4 个预置工作流
 │   └── templates/         # 任务与产物模板
 ├── .claude/               # Claude Code 配置与命令
-├── .gemini/               # Gemini CLI 配置与命令
 ├── .opencode/             # OpenCode 配置与命令
 └── AGENTS.md              # 通用 AI agent 指令
 ```
@@ -196,6 +208,7 @@ my-project/
 - [架构概览](./docs/zh-CN/architecture.md) — 引导 CLI、端到端流程、分层架构
 - [平台支持](./docs/zh-CN/platform-support.md) — macOS、Linux、Windows；沙箱引擎与资源配置
 - [沙箱](./docs/zh-CN/sandbox.md) — 沙箱 aliases、宿主-沙箱文件交换、用户级 dotfiles 通道
+- [Benchmark 契约与威胁模型](./docs/zh-CN/benchmark.md) — 版本化 benchmark schema、信任边界与安全保证
 - [飞书桥接](./docs/zh-CN/feishu-bridge.md) — 配置飞书长连接 adapter、命令路由、权限和 TUI 选择
 - [内置 AI Skills](./docs/zh-CN/skills.md) — 按使用场景分组的完整 skill 清单
 - [自定义 Skills](./docs/zh-CN/custom-skills.md) — 创建并同步项目专属 skill

package/bin/cli.ts

@@ -15,6 +15,7 @@ const USAGE = `agent-infra ${VERSION} - bootstrap AI collaboration infrastructur
 Usage: ai <command> [options]
 
 Commands:
+  agent-client    List, inspect, enable, disable, or configure Agent Clients
   cp <ssh-alias>  Copy local clipboard image to a remote macOS clipboard or Linux sandbox over SSH
   decide          Record a ruling; code-stage decisions require explicit implementation intent
   help            Show this help message
@@ -71,6 +72,17 @@ async function importCommand(importPath: string) {
 }
 
 switch (command) {
+  case 'agent-client': {
+    const imported = await importCommand('../lib/agent-client.ts');
+    if (!imported) break;
+    const { cmdAgentClient } = imported;
+    const code = await cmdAgentClient(process.argv.slice(3)).catch((e: unknown) => {
+      process.stderr.write(`Error: ${errorMessage(e)}\n`);
+      return 1;
+    });
+    if (code) process.exitCode = code;
+    break;
+  }
   case 'cp': {
     const imported = await importCommand('../lib/cp.ts');
     if (!imported) break;

package/dist/bin/cli.js

@@ -19,6 +19,7 @@ const USAGE = `agent-infra ${VERSION} - bootstrap AI collaboration infrastructur
 Usage: ai <command> [options]
 
 Commands:
+  agent-client    List, inspect, enable, disable, or configure Agent Clients
   cp <ssh-alias>  Copy local clipboard image to a remote macOS clipboard or Linux sandbox over SSH
   decide          Record a ruling; code-stage decisions require explicit implementation intent
   help            Show this help message
@@ -69,6 +70,19 @@ async function importCommand(importPath) {
     }
 }
 switch (command) {
+    case 'agent-client': {
+        const imported = await importCommand('../lib/agent-client.ts');
+        if (!imported)
+            break;
+        const { cmdAgentClient } = imported;
+        const code = await cmdAgentClient(process.argv.slice(3)).catch((e) => {
+            process.stderr.write(`Error: ${errorMessage(e)}\n`);
+            return 1;
+        });
+        if (code)
+            process.exitCode = code;
+        break;
+    }
     case 'cp': {
         const imported = await importCommand('../lib/cp.ts');
         if (!imported)

package/dist/bin/internal-cli.js

@@ -6,6 +6,11 @@ if (major < 22 || (major === 22 && minor < 9)) {
 }
 const command = process.argv[2] || '';
 switch (command) {
+    case 'agent-client': {
+        const { agentClient } = await import('../lib/internal/agent-client.js');
+        agentClient(process.argv.slice(3));
+        break;
+    }
     case 'git-workflow': {
         const { gitWorkflow } = await import('../lib/internal/git-workflow.js');
         gitWorkflow(process.argv.slice(3));
@@ -41,6 +46,16 @@ switch (command) {
         platformPr(process.argv.slice(3));
         break;
     }
+    case 'platform-pr-review': {
+        const { platformPrReview } = await import('../lib/internal/platform-pr-review.js');
+        platformPrReview(process.argv.slice(3));
+        break;
+    }
+    case 'pr-review-grade': {
+        const { prReviewGrade } = await import('../lib/internal/pr-review-grade.js');
+        prReviewGrade(process.argv.slice(3));
+        break;
+    }
     case 'platform-checks': {
         const { platformChecks } = await import('../lib/internal/platform-checks.js');
         await platformChecks(process.argv.slice(3));
@@ -61,11 +76,26 @@ switch (command) {
         taskWarning(process.argv.slice(3));
         break;
     }
+    case 'task-activity': {
+        const { taskActivity } = await import('../lib/internal/task-activity.js');
+        taskActivity(process.argv.slice(3));
+        break;
+    }
     case 'task-artifact': {
         const { taskArtifact } = await import('../lib/internal/task-artifact.js');
         taskArtifact(process.argv.slice(3));
         break;
     }
+    case 'task-orchestration': {
+        const { taskOrchestration } = await import('../lib/internal/task-orchestration.js');
+        taskOrchestration(process.argv.slice(3));
+        break;
+    }
+    case 'task-review': {
+        const { taskReview } = await import('../lib/internal/task-review.js');
+        taskReview(process.argv.slice(3));
+        break;
+    }
     case 'task-event': {
         const { taskEvent } = await import('../lib/internal/task-event.js');
         taskEvent(process.argv.slice(3));

package/dist/lib/agent-client.js

@@ -0,0 +1,163 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { AgentClientConfigError, normalizeAgentClients } from './agent-clients/config.js';
+import { applyAgentClientReconciliation, planAgentClientReconciliation } from './agent-clients/reconcile.js';
+import { listAgentClientAdapters } from './agent-clients/registry.js';
+import { AGENT_CLIENT_IDS, isAgentClientId } from './agent-clients/types.js';
+import { closePrompt, multiSelect } from './prompt.js';
+import { resolveTemplateDir } from './paths.js';
+const USAGE = `Usage: ai agent-client <operation>
+
+Operations:
+  list                 List built-in Agent Clients
+  status               Show project integration and sandbox state
+  enable <client-id>   Enable project integration only
+  disable <client-id>  Disable project integration only
+  configure            Configure integration and sandbox state interactively
+`;
+class AgentClientCommandError extends Error {
+    code;
+    constructor(code, message) {
+        super(`${code}: ${message}`);
+        this.name = 'AgentClientCommandError';
+        this.code = code;
+    }
+}
+function readConfig(projectRoot) {
+    const configPath = path.join(projectRoot, '.agents', '.airc.json');
+    if (!fs.existsSync(configPath)) {
+        throw new AgentClientCommandError('AGENT_CLIENT_CONFIG_NOT_FOUND', 'No .agents/.airc.json found. Run "ai init" first.');
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    }
+    catch (error) {
+        throw new AgentClientCommandError('AGENT_CLIENT_CONFIG_INVALID', error instanceof Error ? error.message : String(error));
+    }
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        throw new AgentClientCommandError('AGENT_CLIENT_CONFIG_INVALID', 'configuration root must be an object');
+    }
+    return parsed;
+}
+function choices() {
+    return listAgentClientAdapters().map((adapter) => ({
+        id: adapter.id,
+        label: adapter.displayName
+    }));
+}
+function selected(state, field) {
+    return AGENT_CLIENT_IDS.filter((id) => state[id][field]);
+}
+function workflowPlan(projectRoot, config, mutation) {
+    const templateRoot = resolveTemplateDir();
+    if (!templateRoot) {
+        throw new AgentClientCommandError('AGENT_CLIENT_TEMPLATE_NOT_FOUND', 'Template directory not found');
+    }
+    const platform = config.platform;
+    const platformType = typeof platform === 'object' && platform !== null && 'type' in platform
+        ? String(platform.type ?? 'github')
+        : 'github';
+    return planAgentClientReconciliation({
+        config,
+        mutation,
+        projectRoot,
+        templateRoot,
+        platformType,
+        language: String(config.language ?? 'en')
+    });
+}
+function printState(state) {
+    for (const adapter of listAgentClientAdapters()) {
+        const value = state[adapter.id];
+        process.stdout.write(`  ${adapter.id}: enabled=${String(value.enabled)} installInSandbox=${String(value.installInSandbox)}\n`);
+    }
+}
+async function cmdAgentClient(args) {
+    const operation = args[0];
+    if (!operation || operation === '--help' || operation === '-h' || operation === 'help') {
+        process.stdout.write(USAGE);
+        return 0;
+    }
+    if (operation === 'list') {
+        if (args.length !== 1) {
+            throw new AgentClientCommandError('AGENT_CLIENT_ARGUMENT_INVALID', 'list accepts no arguments');
+        }
+        for (const adapter of listAgentClientAdapters()) {
+            process.stdout.write(`${adapter.id}\t${adapter.displayName}\t${adapter.invocation}\tcommands=${adapter.capabilities.commands.level}\tsandbox=${adapter.capabilities.sandbox.level}\n`);
+        }
+        return 0;
+    }
+    const projectRoot = process.cwd();
+    const config = readConfig(projectRoot);
+    try {
+        if (operation === 'status') {
+            if (args.length !== 1) {
+                throw new AgentClientCommandError('AGENT_CLIENT_ARGUMENT_INVALID', 'status accepts no arguments');
+            }
+            const plan = workflowPlan(projectRoot, config, { type: 'none' });
+            process.stdout.write(`source: ${plan.source}\n`);
+            printState(plan.desired);
+            for (const seed of plan.seedOperations) {
+                process.stdout.write(`  seed ${seed.target}: ${seed.kind}\n`);
+            }
+            for (const diagnostic of plan.diagnostics) {
+                process.stdout.write(`  diagnostic ${diagnostic.code} at ${diagnostic.path}\n`);
+            }
+            return 0;
+        }
+        if (operation === 'enable' || operation === 'disable') {
+            if (args.length !== 2) {
+                throw new AgentClientCommandError('AGENT_CLIENT_ARGUMENT_INVALID', `${operation} requires exactly one client id`);
+            }
+            const id = args[1];
+            if (!isAgentClientId(id)) {
+                throw new AgentClientCommandError('UNKNOWN_AGENT_CLIENT', `Unknown Agent Client '${String(id)}'`);
+            }
+            const plan = workflowPlan(projectRoot, config, {
+                type: 'set-enabled',
+                id,
+                value: operation === 'enable'
+            });
+            process.stdout.write('Before:\n');
+            printState(plan.before);
+            const result = applyAgentClientReconciliation(plan);
+            process.stdout.write('After:\n');
+            printState(plan.desired);
+            process.stdout.write(`Result: ${result.status}; applied=${result.applied.length}; protected=${result.protected.length}\n`);
+            return 0;
+        }
+        if (operation === 'configure') {
+            if (args.length !== 1) {
+                throw new AgentClientCommandError('AGENT_CLIENT_ARGUMENT_INVALID', 'configure accepts no arguments');
+            }
+            const normalized = normalizeAgentClients(config);
+            let enabled;
+            let installed;
+            try {
+                enabled = await multiSelect('Agent Client project integrations', choices(), selected(normalized.state, 'enabled'));
+                installed = await multiSelect('Agent Clients installed in sandbox', choices(), selected(normalized.state, 'installInSandbox'));
+            }
+            finally {
+                closePrompt();
+            }
+            const state = Object.fromEntries(AGENT_CLIENT_IDS.map((id) => [id, {
+                    enabled: enabled.includes(id),
+                    installInSandbox: installed.includes(id)
+                }]));
+            const plan = workflowPlan(projectRoot, config, { type: 'replace-state', state });
+            const result = applyAgentClientReconciliation(plan);
+            process.stdout.write(`Result: ${result.status}; applied=${result.applied.length}; protected=${result.protected.length}\n`);
+            return 0;
+        }
+        throw new AgentClientCommandError('AGENT_CLIENT_OPERATION_INVALID', `Unknown operation '${operation}'`);
+    }
+    catch (error) {
+        if (error instanceof AgentClientConfigError) {
+            throw new AgentClientCommandError(error.code, error.message);
+        }
+        throw error;
+    }
+}
+export { AgentClientCommandError, cmdAgentClient };
+//# sourceMappingURL=agent-client.js.map