@fitlab-ai/agent-infra 0.9.9 → 0.9.11

package/README.md

@@ -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 |
 |---------|---------|

package/README.zh-CN.md

@@ -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`），工作流语义保持一致。
 
 | 命令 | 用途 |
 |------|------|

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) {
@@ -157,6 +203,11 @@ else
             taskVerify(process.argv.slice(3));
             break;
         }
+        case 'task-validate': {
+            const { taskValidate } = await import('../lib/internal/task-validate.js');
+            taskValidate(process.argv.slice(3));
+            break;
+        }
         default:
             process.stdout.write(`${JSON.stringify({
                 status: 'failed',

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

@@ -145,25 +145,32 @@ function verifyLifecycleBuildIdentity(expected, actual) {
         return {
             ok: false,
             code: 'CODEX_LIFECYCLE_PROTOCOL_MISMATCH',
-            message: 'Codex lifecycle protocol version does not match'
+            message: 'Codex lifecycle protocol version does not match',
+            warnings: []
         };
     }
+    const warnings = [];
     if (actual.packageVersion !== expected.packageVersion
         || actual.internalExecutableBuildHash !== expected.internalExecutableBuildHash) {
-        return {
-            ok: false,
+        warnings.push({
             code: 'CODEX_LIFECYCLE_BUILD_MISMATCH',
-            message: 'Codex lifecycle executable build identity does not match'
-        };
+            message: 'Codex lifecycle executable build identity differs; rebuild the sandbox if the runtime is stale',
+            action: 'rebuild-sandbox'
+        });
     }
     if (actual.lifecycleContractHash !== expected.lifecycleContractHash) {
-        return {
-            ok: false,
+        warnings.push({
             code: 'CODEX_LIFECYCLE_CONTRACT_MISMATCH',
-            message: 'Codex lifecycle contract identity does not match'
-        };
+            message: 'Codex lifecycle contract identity differs; rebuild the sandbox if the runtime is stale',
+            action: 'rebuild-sandbox'
+        });
     }
-    return { ok: true, code: null, message: null };
+    return {
+        ok: true,
+        code: null,
+        message: null,
+        warnings: Object.freeze(warnings)
+    };
 }
 export { LIFECYCLE_PROTOCOL_VERSION, computeLifecycleBuildIdentity, isCanonicalLifecyclePackageVersion, isLifecycleProtocolVersion, readLifecycleManifestFiles, resolveLifecycleExecutableFiles, verifyLifecycleBuildIdentity };
 //# sourceMappingURL=build-identity.js.map

package/dist/lib/agent-clients/adapters/codex-lifecycle/controller-context.js

@@ -2,28 +2,11 @@ import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 import { getProcessIdentityState } from '../../../server/process-state.js';
-import { computeLifecycleBuildIdentity } from './build-identity.js';
+import { computeLifecycleBuildIdentity, verifyLifecycleBuildIdentity } from './build-identity.js';
 const HEX_256 = /^[a-f0-9]{64}$/u;
 function exactKeys(value, keys) {
     return Object.keys(value).sort().join(',') === [...keys].sort().join(',');
 }
-function digestProfiles(repoRoot) {
-    const files = [
-        path.join(repoRoot, '.codex', 'agents', 'agent-infra-lifecycle-executor.toml'),
-        path.join(repoRoot, '.codex', 'agents', 'agent-infra-lifecycle-reviewer.toml')
-    ];
-    const hash = crypto.createHash('sha256');
-    for (const file of files.sort()) {
-        const stat = fs.lstatSync(file);
-        if (!stat.isFile() || stat.isSymbolicLink())
-            throw new Error('CODEX_SANDBOX_CONTROLLER_BUNDLE_MISMATCH');
-        hash.update(path.basename(file));
-        hash.update('\0');
-        hash.update(fs.readFileSync(file));
-        hash.update('\0');
-    }
-    return hash.digest('hex');
-}
 function validProcess(value) {
     if (!value || typeof value !== 'object' || Array.isArray(value))
         return false;
@@ -53,7 +36,7 @@ function validateContext(value) {
     if (!exactKeys(context, [
         'buildIdentity', 'controlGeneration', 'controllerInstanceDigest', 'controllerLease',
         'controllerProcess', 'expiresAt', 'hookDefinitionHash', 'issuedAt',
-        'lifecycleProfilesHash', 'taskId', 'version'
+        'taskId', 'version'
     ])
         || context.version !== 2
         || typeof context.taskId !== 'string' || context.taskId.length === 0
@@ -68,13 +51,12 @@ function validateContext(value) {
         || !Number.isSafeInteger(context.expiresAt)
         || context.expiresAt <= context.issuedAt
         || !validBuildIdentity(context.buildIdentity)
-        || typeof context.hookDefinitionHash !== 'string' || !HEX_256.test(context.hookDefinitionHash)
-        || typeof context.lifecycleProfilesHash !== 'string' || !HEX_256.test(context.lifecycleProfilesHash)) {
+        || typeof context.hookDefinitionHash !== 'string' || !HEX_256.test(context.hookDefinitionHash)) {
         throw new Error('CODEX_SANDBOX_CONTROLLER_CONTEXT_INVALID');
     }
     return context;
 }
-export function contextFromControllerLease(lease, hashes) {
+export function contextFromControllerLease(lease, input) {
     return Object.freeze({
         version: 2,
         taskId: lease.taskId,
@@ -85,8 +67,7 @@ export function contextFromControllerLease(lease, hashes) {
         issuedAt: lease.issuedAt,
         expiresAt: lease.expiresAt,
         buildIdentity: lease.buildIdentity,
-        hookDefinitionHash: hashes.hookDefinitionHash,
-        lifecycleProfilesHash: hashes.lifecycleProfilesHash
+        hookDefinitionHash: input.hookDefinitionHash
     });
 }
 export function writeCodexSandboxControllerContext(contextPath, context) {
@@ -102,7 +83,7 @@ export function writeCodexSandboxControllerContext(contextPath, context) {
         fs.rmSync(temporary, { force: true });
     }
 }
-export function verifyCodexSandboxControllerContext(contextPath, options = {}) {
+export function verifyCodexSandboxControllerContextWithWarnings(contextPath, options = {}) {
     let stat;
     try {
         stat = fs.lstatSync(contextPath);
@@ -129,12 +110,11 @@ export function verifyCodexSandboxControllerContext(contextPath, options = {}) {
         || state !== 'alive') {
         throw new Error('CODEX_SANDBOX_CONTROLLER_CONTEXT_INVALID');
     }
-    if (JSON.stringify(computeLifecycleBuildIdentity(repoRoot)) !== JSON.stringify(context.buildIdentity)
-        || crypto.createHash('sha256').update(fs.readFileSync(path.join(repoRoot, '.codex', 'hooks.json'))).digest('hex') !== context.hookDefinitionHash
-        || digestProfiles(repoRoot) !== context.lifecycleProfilesHash) {
-        throw new Error('CODEX_SANDBOX_CONTROLLER_BUNDLE_MISMATCH');
-    }
-    return Object.freeze(context);
+    const currentBuildIdentity = computeLifecycleBuildIdentity(repoRoot);
+    const identity = verifyLifecycleBuildIdentity(context.buildIdentity, currentBuildIdentity);
+    if (!identity.ok)
+        throw new Error(`${identity.code}: ${identity.message}`);
+    return Object.freeze({ context: Object.freeze(context), warnings: identity.warnings });
 }
 export function controllerProofFromContext(context) {
     return Object.freeze({

package/dist/lib/agent-clients/adapters/codex-lifecycle/sandbox-controller.js

@@ -8,22 +8,8 @@ import * as toml from 'smol-toml';
 import { requestCodexControllerClose, requestCodexControllerOpen, requestCodexControllerVerify, requestSandboxControl } from '../../../sandbox/control/client.js';
 import { readSandboxControlStatus } from '../../../sandbox/control/state.js';
 import { getProcessStartTime } from '../../../server/process-state.js';
-import { computeLifecycleBuildIdentity } from './build-identity.js';
-import { contextFromControllerLease, controllerProofFromContext, verifyCodexSandboxControllerContext as verifyContextFile, writeCodexSandboxControllerContext } from './controller-context.js';
-function digestFiles(files) {
-    const hash = crypto.createHash('sha256');
-    for (const file of [...files].sort()) {
-        const stat = fs.lstatSync(file);
-        if (!stat.isFile() || stat.isSymbolicLink()) {
-            throw new Error('CODEX_SANDBOX_CONTROLLER_BUNDLE_MISMATCH');
-        }
-        hash.update(path.basename(file));
-        hash.update('\0');
-        hash.update(fs.readFileSync(file));
-        hash.update('\0');
-    }
-    return hash.digest('hex');
-}
+import { LIFECYCLE_PROTOCOL_VERSION } from './build-identity.js';
+import { contextFromControllerLease, controllerProofFromContext, verifyCodexSandboxControllerContextWithWarnings as verifyContextFileWithWarnings, writeCodexSandboxControllerContext } from './controller-context.js';
 function copyRegular(source, destination, mode) {
     const stat = fs.lstatSync(source);
     if (!stat.isFile() || stat.isSymbolicLink()) {
@@ -108,14 +94,15 @@ function verifyControl(taskId, control) {
     if (payload.taskId !== taskId)
         throw new Error('CODEX_SANDBOX_CONTROLLER_TASK_BINDING_INVALID');
 }
-function verifyCodexSandboxControllerContext(contextPath, options = {}) {
+function verifyCodexSandboxControllerContextWithWarnings(contextPath, options = {}) {
     const control = options.control ?? controlFromEnvironment();
-    const context = verifyContextFile(contextPath, {
+    const fileVerification = verifyContextFileWithWarnings(contextPath, {
         repoRoot: options.repoRoot,
         now: options.now,
         generation: control.generation,
         probeProcess: options.probeProcess
     });
+    const context = fileVerification.context;
     const verified = (options.requestControllerVerify ?? requestCodexControllerVerify)({
         controllerProof: controllerProofFromContext(context),
         ...control,
@@ -126,7 +113,10 @@ function verifyCodexSandboxControllerContext(contextPath, options = {}) {
         || verified.binding.controllerInstanceDigest !== context.controllerInstanceDigest) {
         throw new Error('CODEX_SANDBOX_CONTROLLER_CONTEXT_INVALID');
     }
-    return context;
+    return Object.freeze({
+        context,
+        warnings: fileVerification.warnings
+    });
 }
 function detectedCodexVersion() {
     const result = spawnSync('codex', ['--version'], { encoding: 'utf8' });
@@ -261,29 +251,21 @@ function prepareCodexSandboxController(input, options = {}) {
         copyRegular(hooks, path.join(home, 'hooks.json'), 0o600);
         copyRegular(executor, path.join(home, 'agents', path.basename(executor)), 0o600);
         copyRegular(reviewer, path.join(home, 'agents', path.basename(reviewer)), 0o600);
-        if (crypto.createHash('sha256').update(fs.readFileSync(path.join(home, 'hooks.json'))).digest('hex')
-            !== crypto.createHash('sha256').update(fs.readFileSync(hooks)).digest('hex')
-            || digestFiles([
-                path.join(home, 'agents', path.basename(executor)),
-                path.join(home, 'agents', path.basename(reviewer))
-            ]) !== digestFiles([executor, reviewer])) {
-            throw new Error('CODEX_SANDBOX_CONTROLLER_BUNDLE_MISMATCH');
-        }
-        const buildIdentity = computeLifecycleBuildIdentity(repoRoot);
         const opened = (options.openController ?? requestCodexControllerOpen)({
             controllerProcess: { pid: process.pid, startTime: parentStartTime },
             ...control,
             timeoutMs: 30_000
         });
         const taskId = opened.lease.taskId;
+        if (opened.lease.buildIdentity.protocolVersion !== LIFECYCLE_PROTOCOL_VERSION) {
+            throw new Error('CODEX_LIFECYCLE_PROTOCOL_MISMATCH: Codex lifecycle protocol version does not match');
+        }
         context = contextFromControllerLease(opened.lease, {
-            hookDefinitionHash: crypto.createHash('sha256').update(fs.readFileSync(hooks)).digest('hex'),
-            lifecycleProfilesHash: digestFiles([executor, reviewer])
+            hookDefinitionHash: crypto.createHash('sha256').update(fs.readFileSync(hooks)).digest('hex')
         });
         if (opened.lease.controlGeneration !== control.generation
             || opened.lease.controllerProcess.pid !== process.pid
-            || opened.lease.controllerProcess.startTime !== parentStartTime
-            || JSON.stringify(opened.lease.buildIdentity) !== JSON.stringify(buildIdentity)) {
+            || opened.lease.controllerProcess.startTime !== parentStartTime) {
             throw new Error('SANDBOX_CONTROL_RESULT_INVALID');
         }
         (options.verifyTaskBinding ?? verifyControl)(taskId, control);
@@ -383,5 +365,5 @@ async function runCodexSandboxController(input, options = {}) {
         prepared.cleanup();
     }
 }
-export { prepareCodexSandboxController, runCodexSandboxController, verifyCodexSandboxControllerContext, controllerProofFromContext };
+export { prepareCodexSandboxController, runCodexSandboxController, verifyCodexSandboxControllerContextWithWarnings, controllerProofFromContext };
 //# sourceMappingURL=sandbox-controller.js.map

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

@@ -30,6 +30,8 @@ function resolveHostCatalogPath(value, hostHomeDir) {
     }
 }
 const CODEX_DISABLED_FEATURE_FLAGS = ['apps', 'enable_mcp_apps'];
+const SANDBOX_CODEX_HOOKS_PATH = '/workspace/.codex/hooks.json';
+const CODEX_HOOK_TRUST_HASH = /^sha256:[a-f0-9]{64}$/;
 function removeCodexMcpServers(sandboxParsed) {
     if (!Object.hasOwn(sandboxParsed, 'mcp_servers')) {
         return false;
@@ -61,19 +63,58 @@ function inheritDisabledCodexFeatureFlags(sandboxParsed, hostParsed) {
     }
     return changed;
 }
-function ensureCodexModelInheritance(toolDir, hostHomeDir, containerCodexDir = '/home/devuser/.codex') {
-    if (!hostHomeDir) {
-        return;
+function inheritCodexHookTrustState(sandboxParsed, hostParsed, hostProjectDir) {
+    if (!hostProjectDir) {
+        return false;
     }
-    const hostConfigPath = path.join(hostHomeDir, '.codex', 'config.toml');
-    if (!fs.existsSync(hostConfigPath)) {
-        return;
+    if (Object.hasOwn(sandboxParsed, 'hooks') && !isJsonObjectRecord(sandboxParsed.hooks)) {
+        return false;
     }
-    let hostParsed;
-    try {
-        hostParsed = toml.parse(fs.readFileSync(hostConfigPath, 'utf8'));
+    const sandboxHooks = sandboxParsed.hooks ?? {};
+    if (Object.hasOwn(sandboxHooks, 'state') && !isJsonObjectRecord(sandboxHooks.state)) {
+        return false;
     }
-    catch {
+    const sandboxState = sandboxHooks.state ?? {};
+    const sandboxPrefix = `${SANDBOX_CODEX_HOOKS_PATH}:`;
+    const nextState = Object.fromEntries(Object.entries(sandboxState).filter(([key]) => !key.startsWith(sandboxPrefix)));
+    const hostState = isJsonObjectRecord(hostParsed.hooks)
+        && isJsonObjectRecord(hostParsed.hooks.state)
+        ? hostParsed.hooks.state
+        : {};
+    const hostPrefix = `${path.join(hostProjectDir, '.codex', 'hooks.json')}:`;
+    for (const [key, value] of Object.entries(hostState)) {
+        if (!key.startsWith(hostPrefix) || !isJsonObjectRecord(value)) {
+            continue;
+        }
+        const trustedHash = value.trusted_hash;
+        if (typeof trustedHash !== 'string' || !CODEX_HOOK_TRUST_HASH.test(trustedHash)) {
+            continue;
+        }
+        nextState[`${sandboxPrefix}${key.slice(hostPrefix.length)}`] = {
+            trusted_hash: trustedHash,
+            ...(typeof value.enabled === 'boolean' ? { enabled: value.enabled } : {})
+        };
+    }
+    if (JSON.stringify(sandboxState) === JSON.stringify(nextState)) {
+        return false;
+    }
+    if (Object.keys(nextState).length > 0) {
+        sandboxHooks.state = nextState;
+        sandboxParsed.hooks = sandboxHooks;
+    }
+    else {
+        delete sandboxHooks.state;
+        if (Object.keys(sandboxHooks).length > 0) {
+            sandboxParsed.hooks = sandboxHooks;
+        }
+        else {
+            delete sandboxParsed.hooks;
+        }
+    }
+    return true;
+}
+function ensureCodexModelInheritance(toolDir, hostHomeDir, containerCodexDir = '/home/devuser/.codex', hostProjectDir) {
+    if (!hostHomeDir) {
         return;
     }
     const sandboxConfigPath = path.join(toolDir, 'config.toml');
@@ -87,8 +128,25 @@ function ensureCodexModelInheritance(toolDir, hostHomeDir, containerCodexDir = '
             return;
         }
     }
+    const hostConfigPath = path.join(hostHomeDir, '.codex', 'config.toml');
+    let hostParsed = null;
+    if (fs.existsSync(hostConfigPath)) {
+        try {
+            hostParsed = toml.parse(fs.readFileSync(hostConfigPath, 'utf8'));
+        }
+        catch {
+            // An unavailable host trust source must not leave previously projected trust active.
+        }
+    }
+    if (!hostParsed) {
+        if (inheritCodexHookTrustState(sandboxParsed, {}, hostProjectDir)) {
+            fs.writeFileSync(sandboxConfigPath, `${toml.stringify(sandboxParsed)}\n`, 'utf8');
+        }
+        return;
+    }
     let changed = removeCodexMcpServers(sandboxParsed);
     changed = inheritDisabledCodexFeatureFlags(sandboxParsed, hostParsed) || changed;
+    changed = inheritCodexHookTrustState(sandboxParsed, hostParsed, hostProjectDir) || changed;
     const inheritSpecs = [
         ['model', 'string'],
         ['model_reasoning_effort', 'string'],
@@ -151,7 +209,10 @@ const codexBeforeContainerCreateHook = {
                 message: 'Codex sandbox hook requires its resolved tool state.'
             };
         }
-        ensureCodexModelInheritance(entry.dir, create.hostHome, entry.tool.containerMount);
+        const hostProjectDir = typeof context.config?.repoRoot === 'string'
+            ? context.config.repoRoot
+            : undefined;
+        ensureCodexModelInheritance(entry.dir, create.hostHome, entry.tool.containerMount, hostProjectDir);
         ensureCodexWorkspaceTrust(entry.dir);
         return { status: 'ready' };
     }

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

@@ -3,11 +3,13 @@ import { claudeCodeAdapter } from './claude-code.js';
 import { codexAdapter } from './codex.js';
 import { antigravityCliAdapter } from './antigravity-cli.js';
 import { opencodeAdapter } from './opencode.js';
+import { traecliAdapter } from './traecli.js';
 const adaptersById = new Map([
     claudeCodeAdapter,
     codexAdapter,
     antigravityCliAdapter,
-    opencodeAdapter
+    opencodeAdapter,
+    traecliAdapter
 ].map((adapter) => [adapter.id, adapter]));
 const BUILTIN_AGENT_CLIENT_ADAPTERS = Object.freeze(AGENT_CLIENT_IDS.map((id) => {
     const adapter = adaptersById.get(id);

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) {