@fitlab-ai/agent-infra 0.9.10 → 0.9.12

package/README.md

@@ -71,11 +71,11 @@ Just fix it at the application layer in LoginService.
 > AI re-runs `/plan-task` to update the plan accordingly and confirms.
 
 ```bash
-/code-task <task-id>       # AI writes the fix, adds a test for user+tag@example.com — green
+/code-task <task-id>       # AI writes the fix, tests it, and creates a local checkpoint commit
 /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
+/code-task <task-id>       # AI fixes the minor issue, re-validates, and creates a new checkpoint
+/review-code <task-id>     # The reviewer approves the current checkpoint
+/create-pr <task-id>       # The reviewed branch is published to its task-bound target; PR links issue #42
 /complete-task <task-id>   # task archived
 ```
 
@@ -121,6 +121,15 @@ brew install fitlab-ai/tap/agent-infra
 
 ### Updating agent-infra
 
+```bash
+ai update
+```
+
+`ai update` updates the installed agent-infra CLI. In an initialized project,
+use `ai sync` to refresh project seed files and the file registry.
+
+The equivalent package-manager commands remain:
+
 ```bash
 npm update -g @fitlab-ai/agent-infra
 # or, if installed via Homebrew:
@@ -142,7 +151,7 @@ ai init
 # or: agent-infra init
 ```
 
-The CLI collects project metadata, lets you select the enabled Agent Clients, installs their `update-agent-infra` seed commands, and generates `.agents/.airc.json`.
+The CLI collects project metadata, lets you select the enabled Agent Clients, installs any client-specific `update-agent-infra` seed commands, and generates `.agents/.airc.json`.
 
 > `ai` is a shorthand for `agent-infra`. Both commands are equivalent.
 
@@ -156,12 +165,13 @@ Open the project in any AI TUI and run `update-agent-infra`:
 | Codex | `$update-agent-infra` |
 | Antigravity CLI | `/update-agent-infra` |
 | OpenCode | `/update-agent-infra` |
+| TraeCode CLI | `/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
 
-Manage the four built-in Agent Clients independently from the project lifecycle:
+Manage the five built-in Agent Clients independently from the project lifecycle:
 
 ```bash
 ai agent-client list
@@ -171,7 +181,7 @@ 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.
+The most-used lifecycle commands, in delivery order. The command prefix varies by TUI (`/skill` in Claude Code/Antigravity/OpenCode/TraeCode and `$skill` in Codex); the workflow semantics stay the same.
 
 | Command | Purpose |
 |---------|---------|
@@ -179,8 +189,8 @@ The most-used lifecycle commands, in delivery order. The command prefix varies b
 | `run-task` | Resume the lifecycle with fresh isolated executors/reviewers when the selected client exposes verified actual model/effort evidence; Codex now has an experimental Hooks + App Server evidence channel, but orchestration remains disabled until that channel is connected to delegation receipts |
 | `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 |
+| `code-task` → `review-code` | Implement and test; `code-task` creates a local checkpoint, then a structured review checks that checkpoint |
+| `create-pr` → `complete-task` | Publish the approved checkpoint to the task-bound target branch, then archive after merge and final gates |
 
 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 run policy. Finish or clear active runs before upgrading agent-infra; unsupported disk state fails closed without rewriting.
 

package/README.zh-CN.md

@@ -70,11 +70,11 @@ agent-infra 的目标就是把这层共享基础设施标准化。它为所有
 > AI 按你的要求重跑 `/plan-task` 更新方案并确认。
 
 ```bash
-/code-task <task-id>       # AI 编写修复代码，添加 user+tag@example.com 测试 —— 通过
+/code-task <task-id>       # AI 编写修复代码、测试，并创建本地 checkpoint commit
 /review-code <task-id>     # fresh 隔离 reviewer 报告一个次要问题
-/code-task <task-id>       # AI 修复次要问题并重新验证
-/commit
-/create-pr <task-id>       # PR 已创建，自动关联 Issue #42
+/code-task <task-id>       # AI 修复次要问题、重新验证，并创建新的 checkpoint
+/review-code <task-id>     # reviewer 审查并通过当前 checkpoint
+/create-pr <task-id>       # 将已审查分支发布到任务绑定目标分支；PR 自动关联 Issue #42
 /complete-task <task-id>   # 任务归档
 ```
 
@@ -120,6 +120,15 @@ brew install fitlab-ai/tap/agent-infra
 
 ### 更新 agent-infra
 
+```bash
+ai update
+```
+
+`ai update` 用于更新已安装的 agent-infra CLI。在已初始化项目中，使用
+`ai sync` 刷新项目 seed files 和文件注册表。
+
+对应的包管理器命令仍然是：
+
 ```bash
 npm update -g @fitlab-ai/agent-infra
 # 或者通过 Homebrew 安装时：
@@ -141,7 +150,7 @@ ai init
 # 或：agent-infra init
 ```
 
-CLI 会收集项目元数据，让你选择启用的 Agent Client，为其安装 `update-agent-infra` 种子命令，并生成 `.agents/.airc.json`。
+CLI 会收集项目元数据，让你选择启用的 Agent Client，安装该客户端需要的 `update-agent-infra` 种子命令，并生成 `.agents/.airc.json`。
 
 > `ai` 是 `agent-infra` 的简写命令，两者等价。
 
@@ -155,12 +164,13 @@ CLI 会收集项目元数据，让你选择启用的 Agent Client，为其安装
 | Codex | `$update-agent-infra` |
 | Antigravity CLI | `/update-agent-infra` |
 | OpenCode | `/update-agent-infra` |
+| TraeCode CLI | `/update-agent-infra` |
 
 该命令会检测当前打包模板版本并渲染所有受管理文件。首次安装和后续升级都使用同一条命令。
 
 ## 核心命令
 
-以下命令用于独立管理四个内建 Agent Client：
+以下命令用于独立管理五个内建 Agent Client：
 
 ```bash
 ai agent-client list
@@ -170,7 +180,7 @@ ai agent-client disable antigravity-cli
 ai agent-client configure
 ```
 
-最常用的生命周期命令，按交付顺序排列。命令前缀因 TUI 而异（Claude Code/Antigravity/OpenCode 用 `/skill`，Codex 用 `$skill`），工作流语义保持一致。
+最常用的生命周期命令，按交付顺序排列。命令前缀因 TUI 而异（Claude Code/Antigravity/OpenCode/TraeCode 用 `/skill`，Codex 用 `$skill`），工作流语义保持一致。
 
 | 命令 | 用途 |
 |------|------|
@@ -178,8 +188,8 @@ ai agent-client configure
 | `run-task` | 当所选客户端能提供已验证的 actual model/effort 证据时，用 fresh 隔离 executor/reviewer 续跑生命周期；Codex 现已具备实验性的 Hooks + App Server 证据通道，但在该通道接入 delegation receipt 前仍不会启用 orchestration |
 | `analyze-task` → `review-analysis` | 明确范围与风险，再审查分析 |
 | `plan-task` → `review-plan` | 设计实现路径，再审查方案 |
-| `code-task` → `review-code` | 实现并测试，再执行结构化代码审查 |
-| `commit` → `create-pr` → `complete-task` | 提交、创建 PR、归档任务 |
+| `code-task` → `review-code` | 实现并测试；`code-task` 创建本地 checkpoint，再由结构化审查检视该 checkpoint |
+| `create-pr` → `complete-task` | 将已通过审查的 checkpoint 发布到任务绑定目标分支，并在合并和最终门禁通过后归档 |
 
 启动时可提供原子角色策略，例如：`$run-task 42 --executor-model <id> --executor-reasoning-effort <值> --reviewer-model <id> --reviewer-reasoning-effort <值>`。两个角色可以使用同一模型。完全没有显式策略时，`run-task` 读取当前 Agent Client 可选的 `agentClients[].orchestration`；两个来源都不完整时，会在创建任何 run 前展示宿主模型选择指引。重入使用已持久化的 run 策略。升级 agent-infra 前必须完成或清空 active run；不受支持的磁盘状态会失败关闭且不改写。
 

package/bin/cli.ts

@@ -21,12 +21,13 @@ Commands:
   decide          Record a ruling; code-stage decisions require explicit implementation intent
   help            Show this help message
   init            Initialize a new project with update-agent-infra seed command
-  merge           Merge tasks from another workspace directory (active/blocked/completed/archive)
+  merge           Merge tasks from another current workspace directory (active/blocked/completed/archive)
   run             Schedule a lifecycle skill in the task sandbox tmux session
   sandbox, s      Manage Docker-based AI sandboxes
   server          Run the local AI collaboration daemon (start/stop/status/logs)
   task, t         Read-only views of .agents/workspace tasks
-  update          Update seed files and sync file registry for an existing project
+  sync            Update seed files and sync file registry for an existing project
+  update          Update the agent-infra CLI itself
   version         Show version
 
 'ai' and 'agent-infra' are interchangeable; 'ai' is the shorter form.
@@ -171,10 +172,22 @@ switch (command) {
     break;
   }
   case 'update': {
-    const imported = await importCommand('../lib/update.ts');
+    const imported = await importCommand('../lib/self-update.ts');
     if (!imported) break;
     const { cmdUpdate } = imported;
-    await cmdUpdate().catch((e: unknown) => {
+    const code = await cmdUpdate().catch((e: unknown) => {
+      process.stderr.write(`Error: ${errorMessage(e)}\n`);
+      process.exitCode = 1;
+      return 1;
+    });
+    if (code !== 0) process.exitCode = code;
+    break;
+  }
+  case 'sync': {
+    const imported = await importCommand('../lib/update.ts');
+    if (!imported) break;
+    const { cmdSync } = imported;
+    await cmdSync().catch((e: unknown) => {
       process.stderr.write(`Error: ${errorMessage(e)}\n`);
       process.exitCode = 1;
     });

package/dist/bin/cli.js

@@ -25,12 +25,13 @@ Commands:
   decide          Record a ruling; code-stage decisions require explicit implementation intent
   help            Show this help message
   init            Initialize a new project with update-agent-infra seed command
-  merge           Merge tasks from another workspace directory (active/blocked/completed/archive)
+  merge           Merge tasks from another current workspace directory (active/blocked/completed/archive)
   run             Schedule a lifecycle skill in the task sandbox tmux session
   sandbox, s      Manage Docker-based AI sandboxes
   server          Run the local AI collaboration daemon (start/stop/status/logs)
   task, t         Read-only views of .agents/workspace tasks
-  update          Update seed files and sync file registry for an existing project
+  sync            Update seed files and sync file registry for an existing project
+  update          Update the agent-infra CLI itself
   version         Show version
 
 'ai' and 'agent-infra' are interchangeable; 'ai' is the shorter form.
@@ -182,11 +183,25 @@ switch (command) {
         break;
     }
     case 'update': {
-        const imported = await importCommand('../lib/update.ts');
+        const imported = await importCommand('../lib/self-update.ts');
         if (!imported)
             break;
         const { cmdUpdate } = imported;
-        await cmdUpdate().catch((e) => {
+        const code = await cmdUpdate().catch((e) => {
+            process.stderr.write(`Error: ${errorMessage(e)}\n`);
+            process.exitCode = 1;
+            return 1;
+        });
+        if (code !== 0)
+            process.exitCode = code;
+        break;
+    }
+    case 'sync': {
+        const imported = await importCommand('../lib/update.ts');
+        if (!imported)
+            break;
+        const { cmdSync } = imported;
+        await cmdSync().catch((e) => {
             process.stderr.write(`Error: ${errorMessage(e)}\n`);
             process.exitCode = 1;
         });

package/dist/bin/internal-cli.js

@@ -5,10 +5,56 @@ if (major < 22 || (major === 22 && minor < 9)) {
     process.exit(1);
 }
 const command = process.argv[2] || '';
-if (process.env.AGENT_INFRA_CONTROL_TOKEN
-    && (command === 'task-lifecycle' || command === 'task-orchestration' || command === 'task-finalization')) {
-    const { sandboxControl } = await import('../lib/internal/sandbox-control.js');
-    await sandboxControl(['client', command, ...process.argv.slice(3)]);
+const taskControlCommand = command === 'task-lifecycle' || command === 'task-orchestration' || command === 'task-finalization';
+function taskControlTransportFailure(message) {
+    process.stdout.write(`${JSON.stringify({
+        status: 'failed', changed: false,
+        error: { code: 'TASK_CONTROL_TRANSPORT_INVALID', message }
+    })}\n`);
+    process.exit(1);
+}
+if (taskControlCommand) {
+    const env = process.env;
+    const executorMarked = Boolean(env.AGENT_INFRA_EXECUTOR_MANIFEST);
+    const controlKeys = [
+        'AGENT_INFRA_CONTROL_TOKEN', 'AGENT_INFRA_CONTROL_GENERATION',
+        'AGENT_INFRA_CONTROL_DIR', 'AGENT_INFRA_CONTROL_STATUS_DIR'
+    ];
+    const hasControlMarker = controlKeys.some((key) => Boolean(env[key]))
+        || Boolean(env.AGENT_INFRA_CONTROL_CONTROLLER_BINDING);
+    const taskBindingMarker = hasControlMarker && Boolean(env.AGENT_INFRA_TASK_ID);
+    const hasCompleteClientConfig = controlKeys.every((key) => Boolean(env[key]))
+        && !env.AGENT_INFRA_CONTROL_CONTROLLER_BINDING
+        && (!taskBindingMarker || Boolean(env.AGENT_INFRA_RUNTIME_DIR));
+    if (executorMarked) {
+        taskControlTransportFailure('executor context is only valid for sandbox-control execute');
+    }
+    if ((hasControlMarker || taskBindingMarker) && !hasCompleteClientConfig) {
+        taskControlTransportFailure('sandbox client control configuration is incomplete or conflicting');
+    }
+    if (hasCompleteClientConfig) {
+        const { sandboxControl } = await import('../lib/internal/sandbox-control.js');
+        await sandboxControl(['client', command, ...process.argv.slice(3)]);
+    }
+    else {
+        switch (command) {
+            case 'task-orchestration': {
+                const { taskOrchestration } = await import('../lib/internal/task-orchestration.js');
+                await taskOrchestration(process.argv.slice(3));
+                break;
+            }
+            case 'task-lifecycle': {
+                const { taskLifecycle } = await import('../lib/internal/task-lifecycle.js');
+                taskLifecycle(process.argv.slice(3));
+                break;
+            }
+            case 'task-finalization': {
+                const { taskFinalization } = await import('../lib/internal/task-finalization.js');
+                taskFinalization(process.argv.slice(3));
+                break;
+            }
+        }
+    }
 }
 else
     switch (command) {
@@ -42,6 +88,11 @@ else
             gitWorkflow(process.argv.slice(3));
             break;
         }
+        case 'task-delivery': {
+            const { taskDelivery } = await import('../lib/internal/task-delivery.js');
+            taskDelivery(process.argv.slice(3));
+            break;
+        }
         case 'release-workflow': {
             const { releaseWorkflow } = await import('../lib/internal/release-workflow.js');
             await releaseWorkflow(process.argv.slice(3));

package/dist/lib/agent-client.js

@@ -96,7 +96,6 @@ async function cmdAgentClient(args) {
                 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`);

package/dist/lib/agent-clients/adapters/codex-lifecycle/build-identity.js

@@ -16,20 +16,63 @@ function isLifecycleProtocolVersion(value) {
 function normalizeRelativePath(value) {
     return value.replaceAll('\\', '/');
 }
+function isSafeLifecyclePath(value) {
+    return exactText(value)
+        && value === normalizeRelativePath(value)
+        && !path.isAbsolute(value)
+        && !/^[A-Za-z]:[\\/]/u.test(value)
+        && !value.split('/').includes('..');
+}
+function isLifecycleLauncherLine(value) {
+    return typeof value === 'string'
+        && value.length > 1
+        && value.slice(0, -1).trim() === value.slice(0, -1)
+        && value.startsWith('#!')
+        && value.endsWith('\n')
+        && value.indexOf('\n') === value.length - 1
+        && !value.includes('\r');
+}
+function readLifecycleLauncherShebang(value, executableFiles) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error('Lifecycle manifest launcher shebang policy is invalid');
+    }
+    const policy = value;
+    if (!isSafeLifecyclePath(policy.sourceFile)
+        || !isSafeLifecyclePath(policy.compiledFile)
+        || !isLifecycleLauncherLine(policy.canonicalLine)
+        || !Array.isArray(policy.acceptedLines)
+        || !policy.acceptedLines.every(isLifecycleLauncherLine)
+        || new Set(policy.acceptedLines).size !== policy.acceptedLines.length
+        || !policy.acceptedLines.includes(policy.canonicalLine)
+        || !executableFiles.includes(policy.sourceFile)
+        || policy.compiledFile !== normalizeRelativePath(path.join('dist', policy.sourceFile.endsWith('.ts')
+            ? policy.sourceFile.replace(/\.ts$/u, '.js')
+            : policy.sourceFile))) {
+        throw new Error('Lifecycle manifest launcher shebang policy is invalid');
+    }
+    return Object.freeze({
+        sourceFile: policy.sourceFile,
+        compiledFile: policy.compiledFile,
+        canonicalLine: policy.canonicalLine,
+        acceptedLines: Object.freeze([...policy.acceptedLines])
+    });
+}
 function readLifecycleManifestFiles(packageRoot) {
     const file = path.join(packageRoot, 'lib', 'agent-clients', 'adapters', 'codex-lifecycle', 'manifest-files.json');
     const value = JSON.parse(fs.readFileSync(file, 'utf8'));
     if (!Array.isArray(value.executableFiles)
         || !Array.isArray(value.contractFiles)
-        || !value.executableFiles.every(exactText)
-        || !value.contractFiles.every(exactText)
+        || !value.executableFiles.every(isSafeLifecyclePath)
+        || !value.contractFiles.every(isSafeLifecyclePath)
         || new Set(value.executableFiles).size !== value.executableFiles.length
         || new Set(value.contractFiles).size !== value.contractFiles.length) {
         throw new Error('Lifecycle manifest file list is invalid');
     }
+    const executableFiles = Object.freeze([...value.executableFiles]);
     return Object.freeze({
-        executableFiles: Object.freeze([...value.executableFiles]),
-        contractFiles: Object.freeze([...value.contractFiles])
+        executableFiles,
+        contractFiles: Object.freeze([...value.contractFiles]),
+        launcherShebang: readLifecycleLauncherShebang(value.launcherShebang, executableFiles)
     });
 }
 function executablePackageRoot() {
@@ -47,7 +90,22 @@ function executablePackageRoot() {
         current = parent;
     }
 }
-function hashFiles(root, files) {
+function normalizeLifecycleLauncherBytes(relative, content, policy) {
+    const normalized = normalizeRelativePath(relative);
+    if (normalized !== policy.sourceFile && normalized !== policy.compiledFile)
+        return content;
+    const lineEnd = content.indexOf(0x0a);
+    if (lineEnd < 0)
+        return content;
+    const firstLine = content.subarray(0, lineEnd + 1);
+    if (!policy.acceptedLines.some((line) => Buffer.from(line).equals(firstLine)))
+        return content;
+    return Buffer.concat([
+        Buffer.from(policy.canonicalLine),
+        content.subarray(lineEnd + 1)
+    ]);
+}
+function hashFiles(root, files, launcherShebang) {
     const hash = crypto.createHash('sha256');
     for (const relative of [...new Set(files.map(normalizeRelativePath))].sort()) {
         if (path.isAbsolute(relative) || relative.split(/[\\/]/u).includes('..')) {
@@ -60,7 +118,10 @@ function hashFiles(root, files) {
         }
         hash.update(relative);
         hash.update('\0');
-        hash.update(fs.readFileSync(file));
+        const content = fs.readFileSync(file);
+        hash.update(launcherShebang
+            ? normalizeLifecycleLauncherBytes(relative, content, launcherShebang)
+            : content);
         hash.update('\0');
     }
     return hash.digest('hex');
@@ -107,7 +168,7 @@ function computeLifecycleBuildIdentity(repoRoot, options = {}) {
         throw new Error('Lifecycle package version is invalid');
     let internalExecutableBuildHash;
     if (options.executableFiles) {
-        internalExecutableBuildHash = hashFiles(repoRoot, options.executableFiles);
+        internalExecutableBuildHash = hashFiles(repoRoot, options.executableFiles, defaults.launcherShebang);
     }
     else {
         const manifestFile = path.join(executableRoot, 'dist', 'lifecycle-build-manifest.json');
@@ -121,17 +182,17 @@ function computeLifecycleBuildIdentity(repoRoot, options = {}) {
             }
             if (fileURLToPath(import.meta.url).split(path.sep).includes('dist')) {
                 const compiledFiles = defaults.executableFiles.map((file) => file.endsWith('.ts') ? path.join('dist', file.replace(/\.ts$/u, '.js')) : file);
-                if (hashFiles(executableRoot, resolveLifecycleExecutableFiles(executableRoot, compiledFiles)) !== manifest.internalExecutableBuildHash) {
+                if (hashFiles(executableRoot, resolveLifecycleExecutableFiles(executableRoot, compiledFiles), defaults.launcherShebang) !== manifest.internalExecutableBuildHash) {
                     throw new Error('Lifecycle compiled executable build does not match its manifest');
                 }
             }
-            else if (hashFiles(executableRoot, resolveLifecycleExecutableFiles(executableRoot, defaults.executableFiles)) !== manifest.sourceInputHash) {
+            else if (hashFiles(executableRoot, resolveLifecycleExecutableFiles(executableRoot, defaults.executableFiles), defaults.launcherShebang) !== manifest.sourceInputHash) {
                 throw new Error('Lifecycle executable build manifest is stale or invalid');
             }
             internalExecutableBuildHash = manifest.internalExecutableBuildHash;
         }
         else
-            internalExecutableBuildHash = hashFiles(executableRoot, resolveLifecycleExecutableFiles(executableRoot, defaults.executableFiles));
+            internalExecutableBuildHash = hashFiles(executableRoot, resolveLifecycleExecutableFiles(executableRoot, defaults.executableFiles), defaults.launcherShebang);
     }
     return Object.freeze({
         protocolVersion: LIFECYCLE_PROTOCOL_VERSION,

package/dist/lib/agent-clients/adapters/opencode-sandbox.js

@@ -20,12 +20,8 @@ function ensureOpenCodeSandboxState(toolDir, hostHome, hostEnv = {}) {
     const canonicalConfigDir = path.join(toolDir, '.xdg', 'config', 'opencode');
     const canonicalStateDir = path.join(toolDir, '.xdg', 'state', 'opencode');
     const canonicalConfigPath = path.join(canonicalConfigDir, 'opencode.json');
-    const legacyConfigPath = path.join(toolDir, 'opencode.json');
     fs.mkdirSync(canonicalConfigDir, { recursive: true });
     fs.mkdirSync(canonicalStateDir, { recursive: true });
-    if (!fs.existsSync(canonicalConfigPath) && fs.existsSync(legacyConfigPath)) {
-        fs.copyFileSync(legacyConfigPath, canonicalConfigPath, fs.constants.COPYFILE_EXCL);
-    }
     const hostConfigRoot = resolveXdgRoot(hostEnv.XDG_CONFIG_HOME, path.join(hostHome, '.config'));
     const hostConfig = readJsonObject(path.join(hostConfigRoot, 'opencode', 'opencode.json'));
     if (!hostConfig) {

package/dist/lib/agent-clients/adapters/traecli.js

@@ -24,22 +24,21 @@ const traecliAdapter = defineAgentClientAdapter({
         actualReasoningEffort: 'unavailable'
     },
     project: {
-        ownedPathPrefixes: ['.trae/'],
-        managed: ['.trae/skills/'],
+        ownedPathPrefixes: ['.traecli/'],
+        managed: ['.traecli/commands/'],
         merged: [],
         ejected: [],
         seedCommands: [{
                 templates: {
-                    en: '.trae/skills/update-agent-infra.en.md',
-                    'zh-CN': '.trae/skills/update-agent-infra.zh-CN.md'
+                    en: '.traecli/commands/update-agent-infra.en.md',
+                    'zh-CN': '.traecli/commands/update-agent-infra.zh-CN.md'
                 },
-                target: '.trae/skills/update-agent-infra.md'
+                target: '.traecli/commands/update-agent-infra.md'
             }],
         customCommand: {
-            target: '.trae/skills/${skillName}.md',
+            target: '.traecli/commands/${skillName}.md',
             frontmatter: {},
-            includeUsage: true,
-            inheritDisableModelInvocation: true
+            argumentsToken: '$ARGUMENTS'
         }
     },
     sandbox: {

package/dist/lib/agent-clients/config.js

@@ -101,114 +101,29 @@ function serializeAgentClients(state) {
             : {})
     }));
 }
-function projectLegacyTuis(value, diagnostics) {
-    if (!Array.isArray(value)) {
-        return Object.fromEntries(AGENT_CLIENT_IDS.map((id) => [id, true]));
-    }
-    const enabled = new Set();
-    for (const [index, candidate] of value.entries()) {
-        if (isAgentClientId(candidate)) {
-            enabled.add(candidate);
-        }
-        else {
-            diagnostics.push({
-                code: 'LEGACY_VALUE_IGNORED',
-                path: `tuis[${index}]`
-            });
-        }
-    }
-    return Object.fromEntries(AGENT_CLIENT_IDS.map((id) => [id, enabled.has(id)]));
-}
-function projectLegacySandbox(value, diagnostics) {
-    if (!Array.isArray(value) || value.length === 0) {
-        return {
-            installed: Object.fromEntries(AGENT_CLIENT_IDS.map((id) => [id, true])),
-            clientSignals: new Set(),
-            remainingTools: Array.isArray(value) ? [] : undefined
-        };
-    }
-    const installed = new Set();
-    const remainingTools = [];
-    for (const [index, candidate] of value.entries()) {
-        if (isAgentClientId(candidate)) {
-            installed.add(candidate);
-        }
-        else if (typeof candidate === 'string') {
-            remainingTools.push(candidate);
-        }
-        else {
-            diagnostics.push({
-                code: 'LEGACY_VALUE_IGNORED',
-                path: `sandbox.tools[${index}]`
-            });
-        }
-    }
-    return {
-        installed: Object.fromEntries(AGENT_CLIENT_IDS.map((id) => [id, installed.has(id)])),
-        clientSignals: installed,
-        remainingTools
-    };
-}
-function stateFromLegacy(enabled, installed) {
-    return Object.fromEntries(AGENT_CLIENT_IDS.map((id) => [
-        id,
-        {
-            enabled: enabled[id],
-            installInSandbox: installed[id]
-        }
-    ]));
-}
-function sameCanonicalOrder(value) {
-    return Array.isArray(value)
-        && value.every((entry, index) => isRecord(entry) && entry.id === AGENT_CLIENT_IDS[index]);
-}
 function normalizeAgentClients(input) {
-    const diagnostics = [];
-    const hasCanonical = hasOwn(input, 'agentClients');
-    const hasLegacyTuis = hasOwn(input, 'tuis');
-    const sandbox = isRecord(input.sandbox) ? input.sandbox : undefined;
-    const hasLegacySandboxTools = sandbox !== undefined && hasOwn(sandbox, 'tools');
-    const tuiProjection = projectLegacyTuis(input.tuis, diagnostics);
-    const sandboxProjection = projectLegacySandbox(sandbox?.tools, diagnostics);
-    if (!hasCanonical) {
-        const state = stateFromLegacy(tuiProjection, sandboxProjection.installed);
-        return {
-            source: 'legacy',
-            state,
-            canonical: serializeAgentClients(state),
-            remainingSandboxTools: sandboxProjection.remainingTools,
-            removeLegacyTuis: hasLegacyTuis,
-            changed: true,
-            diagnostics
-        };
-    }
+    if (!hasOwn(input, 'agentClients'))
+        fail('MISSING_AGENT_CLIENT', 'agentClients');
     const state = parseCanonical(input.agentClients);
-    if (hasLegacyTuis) {
-        for (const id of AGENT_CLIENT_IDS) {
-            if (state[id].enabled !== tuiProjection[id]) {
-                fail('LEGACY_CONFLICT', 'tuis');
-            }
+    for (const [index, id] of AGENT_CLIENT_IDS.entries()) {
+        const entry = Array.isArray(input.agentClients) ? input.agentClients[index] : undefined;
+        if (!isRecord(entry) || entry.id !== id) {
+            fail('INVALID_AGENT_CLIENTS', `agentClients[${index}].id`);
         }
     }
-    if (hasLegacySandboxTools) {
-        for (const id of sandboxProjection.clientSignals) {
-            if (!state[id].installInSandbox) {
-                fail('LEGACY_CONFLICT', 'sandbox.tools');
+    if (hasOwn(input, 'tuis'))
+        fail('INVALID_AGENT_CLIENTS', 'tuis');
+    const sandbox = isRecord(input.sandbox) ? input.sandbox : undefined;
+    if (Array.isArray(sandbox?.tools)) {
+        for (const [index, tool] of sandbox.tools.entries()) {
+            if (isAgentClientId(tool)) {
+                fail('INVALID_AGENT_CLIENTS', `sandbox.tools[${index}]`);
             }
         }
     }
     return {
-        source: 'canonical',
         state,
-        canonical: serializeAgentClients(state),
-        remainingSandboxTools: hasLegacySandboxTools
-            ? sandboxProjection.remainingTools
-            : undefined,
-        removeLegacyTuis: hasLegacyTuis,
-        changed: hasLegacyTuis
-            || sandboxProjection.clientSignals.size > 0
-            || !sameCanonicalOrder(input.agentClients),
-        diagnostics
+        canonical: serializeAgentClients(state)
     };
 }
 export { AgentClientConfigError, normalizeAgentClients, serializeAgentClients };

package/dist/lib/agent-clients/reconcile.js

@@ -71,15 +71,6 @@ function planAgentClientReconciliation(input) {
     });
     const nextConfig = structuredClone(input.config);
     nextConfig.agentClients = serializeAgentClients(desired);
-    delete nextConfig.tuis;
-    if (normalized.remainingSandboxTools !== undefined) {
-        const sandbox = isRecord(nextConfig.sandbox) ? { ...nextConfig.sandbox } : {};
-        sandbox.tools = [
-            'agent-infra',
-            ...normalized.remainingSandboxTools.filter((tool) => tool !== 'agent-infra')
-        ];
-        nextConfig.sandbox = sandbox;
-    }
     const existingFiles = isRecord(nextConfig.files) ? nextConfig.files : {};
     const existingBaselines = isRecord(existingFiles.managedBaselines)
         ? existingFiles.managedBaselines
@@ -161,14 +152,13 @@ function planAgentClientReconciliation(input) {
     const changed = JSON.stringify(nextConfig) !== JSON.stringify(input.config)
         || actionableSeed;
     return Object.freeze({
-        source: normalized.source,
         before: normalized.state,
         desired,
         nextConfig,
         projectAssets,
         seedOperations: Object.freeze(seedOperations),
         nextSteps,
-        diagnostics: Object.freeze([...normalized.diagnostics, ...custom.diagnostics]),
+        diagnostics: Object.freeze([...custom.diagnostics]),
         changed,
         projectRoot: input.projectRoot,
         configPath: path.join(input.projectRoot, '.agents', '.airc.json')