@fitlab-ai/agent-infra 0.9.8 → 0.9.10

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

@@ -6,11 +6,22 @@ import path from 'node:path';
 import semver from 'semver';
 import * as toml from 'smol-toml';
 
-import { requestSandboxControl } from '../../../sandbox/control/client.ts';
+import {
+  requestCodexControllerClose,
+  requestCodexControllerOpen,
+  requestCodexControllerVerify,
+  requestSandboxControl
+} from '../../../sandbox/control/client.ts';
 import { readSandboxControlStatus } from '../../../sandbox/control/state.ts';
-import { getProcessStartTime, isProcessAlive } from '../../../server/process-state.ts';
-import { computeLifecycleBuildIdentity } from './build-identity.ts';
-import type { LifecycleBuildIdentity } from './build-identity.ts';
+import { getProcessStartTime, type ProcessIdentity } from '../../../server/process-state.ts';
+import { LIFECYCLE_PROTOCOL_VERSION, type LifecycleIdentityWarning } from './build-identity.ts';
+import {
+  contextFromControllerLease,
+  controllerProofFromContext,
+  verifyCodexSandboxControllerContextWithWarnings as verifyContextFileWithWarnings,
+  writeCodexSandboxControllerContext,
+  type CodexSandboxControllerContextV2
+} from './controller-context.ts';
 
 type ControllerControl = Readonly<{
   token: string;
@@ -20,23 +31,7 @@ type ControllerControl = Readonly<{
   runtimeDir: string;
 }>;
 
-type CodexSandboxControllerContext = Readonly<{
-  version: 1;
-  taskId: string;
-  controlGeneration: string;
-  controllerInstanceDigest: string;
-  parentPid: number;
-  parentStartTime: number;
-  issuedAt: number;
-  expiresAt: number;
-  buildIdentity: LifecycleBuildIdentity;
-  hookDefinitionHash: string;
-  lifecycleProfilesHash: string;
-}>;
-
 type ControllerInput = Readonly<{
-  taskId: string;
-  taskRef: string;
   executorModel?: string;
   executorReasoningEffort?: string;
   reviewerModel?: string;
@@ -51,6 +46,8 @@ type ControllerOptions = Readonly<{
   now?: () => number;
   codexVersion?: () => string;
   verifyTaskBinding?: (taskId: string, control: ControllerControl) => void;
+  openController?: typeof requestCodexControllerOpen;
+  closeController?: typeof requestCodexControllerClose;
   environment?: NodeJS.ProcessEnv;
 }>;
 
@@ -60,26 +57,18 @@ type PreparedCodexSandboxController = Readonly<{
   env: NodeJS.ProcessEnv;
   home: string;
   contextPath: string;
-  context: CodexSandboxControllerContext;
+  context: CodexSandboxControllerContextV2;
   cleanup: () => void;
 }>;
 
-const CONTEXT_TTL_MS = 4 * 60 * 60 * 1_000;
-
-function digestFiles(files: readonly string[]): string {
-  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');
-}
+type VerifyContextOptions = Readonly<{
+  repoRoot?: string;
+  now?: number;
+  generation?: string;
+  probeProcess?: (identity: ProcessIdentity) => 'alive' | 'dead' | 'unknown';
+  control?: ControllerControl;
+  requestControllerVerify?: typeof requestCodexControllerVerify;
+}>;
 
 function copyRegular(source: string, destination: string, mode: number): void {
   const stat = fs.lstatSync(source);
@@ -162,6 +151,34 @@ function verifyControl(taskId: string, control: ControllerControl): void {
   if (payload.taskId !== taskId) throw new Error('CODEX_SANDBOX_CONTROLLER_TASK_BINDING_INVALID');
 }
 
+function verifyCodexSandboxControllerContextWithWarnings(
+  contextPath: string,
+  options: VerifyContextOptions = {}
+): Readonly<{ context: CodexSandboxControllerContextV2; warnings: readonly LifecycleIdentityWarning[] }> {
+  const control = options.control ?? controlFromEnvironment();
+  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,
+    timeoutMs: 30_000
+  });
+  if (verified.binding.taskId !== context.taskId
+    || verified.binding.controlGeneration !== context.controlGeneration
+    || verified.binding.controllerInstanceDigest !== context.controllerInstanceDigest) {
+    throw new Error('CODEX_SANDBOX_CONTROLLER_CONTEXT_INVALID');
+  }
+  return Object.freeze({
+    context,
+    warnings: fileVerification.warnings
+  });
+}
+
 function detectedCodexVersion(): string {
   const result = spawnSync('codex', ['--version'], { encoding: 'utf8' });
   const version = /codex-cli\s+(\d+\.\d+\.\d+)/u.exec(result.stdout ?? '')?.[1];
@@ -256,7 +273,6 @@ function prepareCodexSandboxController(
   const repoRoot = path.resolve(options.repoRoot ?? process.cwd());
   const sourceHome = path.resolve(options.codexHome ?? process.env.CODEX_HOME ?? path.join(os.homedir(), '.codex'));
   const control = options.control ?? controlFromEnvironment();
-  (options.verifyTaskBinding ?? verifyControl)(input.taskId, control);
   const version = (options.codexVersion ?? detectedCodexVersion)();
   if (!semver.gte(version, '0.147.0')) throw new Error('CODEX_SANDBOX_CONTROLLER_CODEX_UNSUPPORTED');
 
@@ -265,46 +281,33 @@ function prepareCodexSandboxController(
   fs.mkdirSync(runtimeRoot, { recursive: true, mode: 0o700 });
   fs.chmodSync(runtimeRoot, 0o700);
   const key = crypto.createHash('sha256')
-    .update(`${input.taskId}\0${control.generation}`)
+    .update(`${process.pid}\0${control.generation}`)
     .digest('hex');
-  const leasePath = path.join(runtimeRoot, `${key}.lease.json`);
-  if (fs.existsSync(leasePath)) {
-    const lease = JSON.parse(fs.readFileSync(leasePath, 'utf8')) as { pid?: number; startTime?: number };
-    if (Number.isSafeInteger(lease.pid) && typeof lease.startTime === 'number'
-      && getProcessStartTime(lease.pid!) === lease.startTime) {
-      throw new Error('CODEX_SANDBOX_CONTROLLER_BUSY');
-    }
-    fs.unlinkSync(leasePath);
-  }
-
   const parentStartTime = getProcessStartTime(process.pid);
   if (!parentStartTime) throw new Error('CODEX_SANDBOX_CONTROLLER_PROCESS_IDENTITY_INVALID');
-  const instanceDigest = crypto.randomBytes(32).toString('hex');
-  fs.writeFileSync(leasePath, `${JSON.stringify({
-    version: 1,
-    pid: process.pid,
-    startTime: parentStartTime,
-    taskId: input.taskId,
-    generation: control.generation,
-    instanceDigest
-  })}\n`, { mode: 0o600, flag: 'wx' });
-
   const home = fs.mkdtempSync(path.join(runtimeRoot, `${key}-`));
   fs.chmodSync(home, 0o700);
   let cleaned = false;
+  let context: CodexSandboxControllerContextV2 | null = null;
   const cleanup = () => {
     if (cleaned) return;
     cleaned = true;
+    if (context) {
+      try {
+        (options.closeController ?? requestCodexControllerClose)({
+          controllerProcess: context.controllerProcess,
+          controllerProof: controllerProofFromContext(context),
+          ...control,
+          timeoutMs: 30_000
+        });
+      } catch {
+        // The wrapper is exiting; dead-process recovery safely handles an unknown close result.
+      }
+    }
     const relative = path.relative(runtimeRoot, home);
     if (!relative.startsWith('..') && !path.isAbsolute(relative)) {
       fs.rmSync(home, { recursive: true, force: true });
     }
-    try {
-      const lease = JSON.parse(fs.readFileSync(leasePath, 'utf8')) as { instanceDigest?: string };
-      if (lease.instanceDigest === instanceDigest) fs.unlinkSync(leasePath);
-    } catch {
-      // A missing or replaced lease is owned by another cleanup path.
-    }
   };
 
   try {
@@ -323,32 +326,27 @@ function prepareCodexSandboxController(
     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 now = (options.now ?? Date.now)();
-    const context: CodexSandboxControllerContext = Object.freeze({
-      version: 1,
-      taskId: input.taskId,
-      controlGeneration: control.generation,
-      controllerInstanceDigest: instanceDigest,
-      parentPid: process.pid,
-      parentStartTime,
-      issuedAt: now,
-      expiresAt: now + CONTEXT_TTL_MS,
-      buildIdentity,
-      hookDefinitionHash: crypto.createHash('sha256').update(fs.readFileSync(hooks)).digest('hex'),
-      lifecycleProfilesHash: digestFiles([executor, reviewer])
+    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')
     });
+    if (opened.lease.controlGeneration !== control.generation
+      || opened.lease.controllerProcess.pid !== process.pid
+      || opened.lease.controllerProcess.startTime !== parentStartTime) {
+      throw new Error('SANDBOX_CONTROL_RESULT_INVALID');
+    }
+    (options.verifyTaskBinding ?? verifyControl)(taskId, control);
     const contextPath = path.join(home, 'controller-context.json');
-    fs.writeFileSync(contextPath, `${JSON.stringify(context, null, 2)}\n`, { mode: 0o600 });
+    writeCodexSandboxControllerContext(contextPath, context);
 
     const shimDir = path.join(home, 'bin');
     fs.mkdirSync(shimDir, { mode: 0o700 });
@@ -364,7 +362,7 @@ function prepareCodexSandboxController(
       input.reviewerModel ? `--reviewer-model ${input.reviewerModel}` : '',
       input.reviewerReasoningEffort ? `--reviewer-reasoning-effort ${input.reviewerReasoningEffort}` : ''
     ].filter(Boolean).join(' ');
-    const prompt = `$run-task ${input.taskRef}${policy ? ` ${policy}` : ''}`;
+    const prompt = `$run-task ${taskId}${policy ? ` ${policy}` : ''}`;
     const args = Object.freeze([
       'exec',
       '--enable', 'hooks',
@@ -379,7 +377,7 @@ function prepareCodexSandboxController(
       home,
       shimDir,
       contextPath,
-      input.taskId,
+      taskId,
       control,
       providerEnvironment,
       options.environment ?? process.env
@@ -399,32 +397,6 @@ function prepareCodexSandboxController(
   }
 }
 
-function verifyCodexSandboxControllerContext(
-  contextPath: string,
-  taskId: string,
-  options: Readonly<{ repoRoot?: string; now?: number; generation?: string }> = {}
-): CodexSandboxControllerContext {
-  const stat = fs.lstatSync(contextPath);
-  if (!stat.isFile() || stat.isSymbolicLink() || (stat.mode & 0o077) !== 0) {
-    throw new Error('CODEX_SANDBOX_CONTROLLER_CONTEXT_INVALID');
-  }
-  const context = JSON.parse(fs.readFileSync(contextPath, 'utf8')) as CodexSandboxControllerContext;
-  const generation = options.generation ?? process.env.AGENT_INFRA_CONTROL_GENERATION;
-  if (context.version !== 1
-    || context.taskId !== taskId
-    || context.controlGeneration !== generation
-    || context.expiresAt < (options.now ?? Date.now())
-    || getProcessStartTime(context.parentPid) !== context.parentStartTime
-    || !isProcessAlive(context.parentPid)) {
-    throw new Error('CODEX_SANDBOX_CONTROLLER_CONTEXT_INVALID');
-  }
-  const current = computeLifecycleBuildIdentity(options.repoRoot ?? process.cwd());
-  if (JSON.stringify(current) !== JSON.stringify(context.buildIdentity)) {
-    throw new Error('CODEX_SANDBOX_CONTROLLER_BUNDLE_MISMATCH');
-  }
-  return Object.freeze(context);
-}
-
 async function runCodexSandboxController(
   input: ControllerInput,
   options: ControllerOptions = {}
@@ -469,10 +441,11 @@ async function runCodexSandboxController(
 export {
   prepareCodexSandboxController,
   runCodexSandboxController,
-  verifyCodexSandboxControllerContext
+  verifyCodexSandboxControllerContextWithWarnings,
+  controllerProofFromContext
 };
 export type {
-  CodexSandboxControllerContext,
+  CodexSandboxControllerContextV2 as CodexSandboxControllerContext,
   ControllerControl,
   ControllerInput,
   ControllerOptions,

package/lib/agent-clients/adapters/codex-sandbox.ts

@@ -37,6 +37,8 @@ function resolveHostCatalogPath(value: unknown, hostHomeDir: string): string | n
 }
 
 const CODEX_DISABLED_FEATURE_FLAGS = ['apps', 'enable_mcp_apps'] as const;
+const SANDBOX_CODEX_HOOKS_PATH = '/workspace/.codex/hooks.json';
+const CODEX_HOOK_TRUST_HASH = /^sha256:[a-f0-9]{64}$/;
 
 function removeCodexMcpServers(sandboxParsed: JsonObject): boolean {
   if (!Object.hasOwn(sandboxParsed, 'mcp_servers')) {
@@ -75,27 +77,75 @@ function inheritDisabledCodexFeatureFlags(
   return changed;
 }
 
+function inheritCodexHookTrustState(
+  sandboxParsed: JsonObject,
+  hostParsed: JsonObject,
+  hostProjectDir?: string
+): boolean {
+  if (!hostProjectDir) {
+    return false;
+  }
+
+  if (Object.hasOwn(sandboxParsed, 'hooks') && !isJsonObjectRecord(sandboxParsed.hooks)) {
+    return false;
+  }
+  const sandboxHooks = (sandboxParsed.hooks as JsonObject | undefined) ?? {};
+  if (Object.hasOwn(sandboxHooks, 'state') && !isJsonObjectRecord(sandboxHooks.state)) {
+    return false;
+  }
+
+  const sandboxState = (sandboxHooks.state as JsonObject | undefined) ?? {};
+  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: string,
   hostHomeDir?: string,
-  containerCodexDir: string = '/home/devuser/.codex'
+  containerCodexDir: string = '/home/devuser/.codex',
+  hostProjectDir?: string
 ): void {
   if (!hostHomeDir) {
     return;
   }
 
-  const hostConfigPath = path.join(hostHomeDir, '.codex', 'config.toml');
-  if (!fs.existsSync(hostConfigPath)) {
-    return;
-  }
-
-  let hostParsed: JsonObject;
-  try {
-    hostParsed = toml.parse(fs.readFileSync(hostConfigPath, 'utf8')) as JsonObject;
-  } catch {
-    return;
-  }
-
   const sandboxConfigPath = path.join(toolDir, 'config.toml');
   // This rewrites sandbox-side TOML and drops comments; the host config stays untouched.
   let sandboxParsed: JsonObject = {};
@@ -107,8 +157,25 @@ function ensureCodexModelInheritance(
     }
   }
 
+  const hostConfigPath = path.join(hostHomeDir, '.codex', 'config.toml');
+  let hostParsed: JsonObject | null = null;
+  if (fs.existsSync(hostConfigPath)) {
+    try {
+      hostParsed = toml.parse(fs.readFileSync(hostConfigPath, 'utf8')) as JsonObject;
+    } 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: Array<readonly [string, 'string' | 'number']> = [
     ['model', 'string'],
@@ -180,7 +247,15 @@ const codexBeforeContainerCreateHook: AgentClientSandboxHook = {
         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/lib/agent-clients/adapters/index.ts

@@ -4,13 +4,15 @@ import { claudeCodeAdapter } from './claude-code.ts';
 import { codexAdapter } from './codex.ts';
 import { antigravityCliAdapter } from './antigravity-cli.ts';
 import { opencodeAdapter } from './opencode.ts';
+import { traecliAdapter } from './traecli.ts';
 
 const adaptersById = new Map(
   [
     claudeCodeAdapter,
     codexAdapter,
     antigravityCliAdapter,
-    opencodeAdapter
+    opencodeAdapter,
+    traecliAdapter
   ].map((adapter) => [adapter.id, adapter])
 );
 

package/lib/agent-clients/adapters/traecli.ts

@@ -0,0 +1,67 @@
+import { defineAgentClientAdapter } from '../adapter.ts';
+import { hostJoin } from '../../sandbox/engines/wsl2-paths.ts';
+
+const traecliAdapter = defineAgentClientAdapter({
+  id: 'traecli',
+  displayName: 'TraeCode CLI',
+  invocation: '/${skillName}',
+  capabilities: {
+    instructions: { level: 'compatible' },
+    skills: { level: 'compatible' },
+    commands: { level: 'integrated' },
+    hooks: { level: 'compatible' },
+    subagents: { level: 'experimental' },
+    orchestration: { level: 'experimental' },
+    sandbox: { level: 'integrated' },
+    verification: { level: 'compatible' }
+  },
+  modelSelection: {
+    kind: 'interactive-only',
+    command: '/model',
+    guidance: 'Use the host model picker for the complete model and reasoning-effort catalog.'
+  },
+  delegationEvidence: {
+    actualModel: 'unavailable',
+    actualReasoningEffort: 'unavailable'
+  },
+  project: {
+    ownedPathPrefixes: ['.trae/'],
+    managed: ['.trae/skills/'],
+    merged: [],
+    ejected: [],
+    seedCommands: [{
+      templates: {
+        en: '.trae/skills/update-agent-infra.en.md',
+        'zh-CN': '.trae/skills/update-agent-infra.zh-CN.md'
+      },
+      target: '.trae/skills/update-agent-infra.md'
+    }],
+    customCommand: {
+      target: '.trae/skills/${skillName}.md',
+      frontmatter: {},
+      includeUsage: true,
+      inheritDisableModelInvocation: true
+    }
+  },
+  sandbox: {
+    createTool: ({ home }) => ({
+      id: 'traecli',
+      name: 'TraeCode CLI',
+      install: {
+        type: 'shell',
+        cmd: 'curl -fsSL https://trae.cn/trae-cli/install_v2.sh | bash'
+      },
+      sandboxBase: hostJoin(home, '.agent-infra', 'sandboxes', 'traecli'),
+      containerMount: '/home/devuser/.trae',
+      versionCmd: 'traecli --version',
+      setupHint: 'Run traecli login inside the container to authenticate.'
+    }),
+    aliases: [
+      { name: 'traecli-yolo', command: 'traecli --dangerously-bypass-approvals-and-sandbox; tput ed' },
+      { name: 'ty', command: 'traecli --dangerously-bypass-approvals-and-sandbox; tput ed' }
+    ],
+    hooks: []
+  }
+});
+
+export { traecliAdapter };

package/lib/agent-clients/tokens.ts

@@ -3,7 +3,7 @@
 // internal commands and the rendering side share one definition. Historical
 // Gemini tokens remain read-only and are handled by classifyAgent below.
 export const KNOWN_AI_AGENTS: ReadonlySet<string> =
-  new Set(['claude', 'codex', 'antigravity', 'opencode', 'cursor']);
+  new Set(['claude', 'codex', 'antigravity', 'opencode', 'cursor', 'traecli']);
 
 // Long name -> short name mapping (HD-4, decision A): `claude-code` reuses the
 // existing orchestration precedent, and `antigravity-cli` is the active
@@ -14,7 +14,7 @@ export const AGENT_LONG_NAMES: Readonly<Record<string, string>> = {
 };
 
 export const AGENT_USAGE_HINT =
-  "agent must be a short token (claude/codex/antigravity/opencode/cursor), " +
+  "agent must be a short token (claude/codex/antigravity/opencode/cursor/traecli), " +
   "a long name (claude-code -> claude, antigravity-cli -> antigravity), or 'human'";
 
 // Read-side historical compatibility for activity-log rendering: `gemini` and

package/lib/agent-clients/types.ts

@@ -2,7 +2,8 @@ const AGENT_CLIENT_IDS = [
   'claude-code',
   'codex',
   'antigravity-cli',
-  'opencode'
+  'opencode',
+  'traecli'
 ] as const;
 
 type AgentClientId = (typeof AGENT_CLIENT_IDS)[number];

package/lib/defaults.json

@@ -22,6 +22,11 @@
       "id": "opencode",
       "enabled": true,
       "installInSandbox": true
+    },
+    {
+      "id": "traecli",
+      "enabled": true,
+      "installInSandbox": true
     }
   ],
   "sandbox": {

package/lib/git/workflow.ts

@@ -105,7 +105,7 @@ function commitExplicitPaths(input: { cwd: string; paths: readonly string[]; mes
   return { status: 'applied' as const, changed: true, snapshot: after.snapshot, operations: [{ name: 'stage', status: 'applied' as const }, { name: 'commit', status: 'applied' as const }], error: null };
 }
 
-function pushGitRefs(input: { cwd: string; remote: string; refs: readonly string[] }, runner: GitRunner = defaultRunner) {
+function pushGitRefs(input: { cwd: string; remote: string; refs: readonly string[]; expectedSha?: string }, runner: GitRunner = defaultRunner) {
   if (!input.remote || input.refs.length === 0) return { status: 'failed' as const, changed: false, snapshot: inspectGitWorkflow(input.cwd, runner).snapshot, operations: [], error: { code: 'GIT_PUSH_INPUT_INVALID', message: 'Remote and refs are required' } };
   const operations: GitOperation[] = [];
   for (const ref of input.refs) {
@@ -120,7 +120,16 @@ function pushGitRefs(input: { cwd: string; remote: string; refs: readonly string
     }
     const canonical = ref.startsWith('refs/') ? ref : `refs/heads/${ref}`;
     const remoteFact = run(runner, input.cwd, ['ls-remote', '--exit-code', input.remote, canonical]);
-    operations.push({ name: 'push', ref, status: remoteFact.status === 0 ? 'applied' : 'failed', message: remoteFact.status === 0 ? undefined : 'Remote ref verification failed' });
+    const remoteSha = remoteFact.status === 0 ? remoteFact.stdout.trim().split(/\s+/)[0] ?? null : null;
+    const verified = remoteFact.status === 0 && (!input.expectedSha || remoteSha === input.expectedSha);
+    operations.push({
+      name: 'push',
+      ref,
+      status: verified ? 'applied' : 'failed',
+      message: verified ? undefined : input.expectedSha
+        ? `Remote ref verification failed: expected ${input.expectedSha}, received ${remoteSha ?? 'unavailable'}`
+        : 'Remote ref verification failed'
+    });
   }
   const failures = operations.filter((item) => item.status === 'failed').length;
   return { status: failures === 0 ? 'applied' as const : failures === operations.length ? 'failed' as const : 'degraded' as const, changed: failures < operations.length, snapshot: inspectGitWorkflow(input.cwd, runner).snapshot, operations, error: failures ? { code: 'GIT_PUSH_PARTIAL', message: `${failures} ref push operation(s) failed` } : null };

package/lib/internal/codex-lifecycle.ts

@@ -11,9 +11,10 @@ import {
 import { createCodexLifecycleStore } from '../agent-clients/adapters/codex-lifecycle/store.ts';
 import { createCodexCapabilityStore } from '../agent-clients/adapters/codex-lifecycle/capability-store.ts';
 import { computeLifecycleBuildIdentity } from '../agent-clients/adapters/codex-lifecycle/build-identity.ts';
-import { verifyCodexSandboxControllerContext } from '../agent-clients/adapters/codex-lifecycle/sandbox-controller.ts';
+import { verifyCodexSandboxControllerContextWithWarnings } from '../agent-clients/adapters/codex-lifecycle/sandbox-controller.ts';
 import type { CodexLifecycleEvent } from '../agent-clients/adapters/codex-lifecycle/evidence.ts';
 import { resolveTaskRef } from '../task/resolve-ref.ts';
+import { hasSealableOrchestrationDelegation } from '../task/orchestration.ts';
 import {
   activateCodexOrchestrationDelegation,
   activateCodexSpawnDelegation,
@@ -100,7 +101,7 @@ function hookDefinitionHash(): string {
 function controllerBinding(taskId: string) {
   const contextPath = process.env.AGENT_INFRA_CODEX_CONTROLLER_CONTEXT;
   if (!contextPath) return undefined;
-  const context = verifyCodexSandboxControllerContext(contextPath, taskId, { repoRoot: process.cwd() });
+  const context = verifyCodexSandboxControllerContextWithWarnings(contextPath, { repoRoot: process.cwd() }).context;
   return {
     instanceDigest: context.controllerInstanceDigest,
     controlGeneration: context.controlGeneration
@@ -139,7 +140,8 @@ function recordFromPayload(phase: string, payload: unknown): CodexLifecycleEvent
     sessionId: text('sessionId'),
     turnId: text('turnId'),
     childThreadId: text('childThreadId'),
-    nativeAgent: text('nativeAgent')
+    nativeAgent: text('nativeAgent'),
+    source: 'hook'
   };
   if (phase === 'subagent-stop') return {
     type: 'hook-stop',
@@ -326,8 +328,17 @@ async function codexLifecycle(args: string[] = []): Promise<void> {
       }
       const result = store.apply(event);
       if (parsed.values['--bridge'] === 'true' && event.type === 'hook-stop') {
-        const bridged = await sealCodexOrchestrationDelegation(event.childThreadId, { store });
-        outputBridgeResult(bridged);
+        if (!hasSealableOrchestrationDelegation('codex', event.childThreadId, { repoRoot: process.cwd() })) {
+          output({ status: 'ignored', changed: false, evidence: null, diagnostics: [], error: null });
+          return;
+        }
+        output({
+          status: result.state.status,
+          changed: true,
+          evidence: result.state,
+          diagnostics: [],
+          error: result.state.error
+        });
         return;
       }
       output({ status: result.state.status, changed: true, evidence: result.state, diagnostics: [], error: result.state.error });
@@ -350,7 +361,9 @@ async function codexLifecycle(args: string[] = []): Promise<void> {
       return;
     }
     if (parsed.operation === 'resolve-stop') {
-      const terminal = await resolveCodexTerminal(childThreadId);
+      const stopTurnId = store.read(childThreadId).state.stop?.turnId;
+      if (!stopTurnId) throw new Error('Codex lifecycle stop hook is not available');
+      const terminal = await resolveCodexTerminal(childThreadId, stopTurnId);
       const latest = store.apply(terminal);
       if (latest.state.status !== 'stop-ready') {
         throw new Error(`Codex lifecycle stop evidence is not ready (status=${latest.state.status})`);