@fitlab-ai/agent-infra 0.11.11 → 0.11.13

package/dist/bin/internal-cli.js

@@ -111,12 +111,12 @@ if (!controlRouted && !taskViewGuardFailed && internalRouteRegistered)
             break;
         }
         case 'codex-lifecycle': {
-            const { codexLifecycle } = await import('../lib/internal/codex-lifecycle.js');
+            const { codexLifecycle } = await import('../lib/agent-clients/adapters/codex-lifecycle/cli.js');
             await codexLifecycle(process.argv.slice(3));
             break;
         }
         case 'codex-sandbox-controller': {
-            const { codexSandboxController } = await import('../lib/internal/codex-sandbox-controller.js');
+            const { codexSandboxController } = await import('../lib/agent-clients/adapters/codex-lifecycle/sandbox-controller-cli.js');
             await codexSandboxController(process.argv.slice(3));
             break;
         }

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

@@ -211,7 +211,10 @@ function defineAgentClientAdapter(candidate) {
     const evidence = candidate.delegationEvidence;
     if (!evidence
         || !['host-event', 'app-server', 'unavailable'].includes(evidence.actualModel)
-        || !['host-event', 'app-server', 'spawn-ack', 'unavailable'].includes(evidence.actualReasoningEffort)) {
+        || !['host-event', 'app-server', 'spawn-ack', 'unavailable'].includes(evidence.actualReasoningEffort)
+        || ['spawnModeRequired', 'actualModelRequired', 'actualReasoningEffortRequired', 'fallbackReasonRequired']
+            .some((key) => evidence[key] !== undefined
+            && typeof evidence[key] !== 'boolean')) {
         throw new Error(`Agent Client '${candidate.id}' has invalid delegation evidence`);
     }
     if (typeof candidate.project !== 'object'
@@ -431,6 +434,9 @@ function defineAgentClientAdapter(candidate) {
         ...(candidate.orchestrationAdapter === undefined
             ? {}
             : { orchestrationAdapter: Object.freeze({ ...candidate.orchestrationAdapter }) }),
+        ...(candidate.sandboxControlOperation === undefined
+            ? {}
+            : { sandboxControlOperation: Object.freeze({ ...candidate.sandboxControlOperation }) }),
         project: Object.freeze({
             ownedPathPrefixes: Object.freeze(paths),
             ...projectAssets,

package/dist/lib/agent-clients/adapters/claude-code.js

@@ -22,7 +22,11 @@ const claudeCodeAdapter = defineAgentClientAdapter({
     },
     delegationEvidence: {
         actualModel: 'host-event',
-        actualReasoningEffort: 'spawn-ack'
+        actualReasoningEffort: 'spawn-ack',
+        spawnModeRequired: false,
+        actualModelRequired: false,
+        actualReasoningEffortRequired: false,
+        fallbackReasonRequired: false
     },
     project: {
         ownedPathPrefixes: ['.claude/'],

package/dist/lib/agent-clients/adapters/codex-lifecycle/app-server.js

@@ -4,7 +4,9 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import semver from 'semver';
-import { resolveAgentRuntimeStoreRoot } from '../../../runtime/agent-runtime.js';
+import { parseCodexLifecycleBinding } from './binding.js';
+import { hasActiveCodexLifecycleEvidence } from './store.js';
+import { resolveTaskContext, resolveTaskRef } from '../../../task/resolve-ref.js';
 const LIFECYCLE_HOOKS = Object.freeze([
     Object.freeze({ event: 'PreToolUse', matcher: '^collaborationspawn_agent$', phase: 'pre-tool' }),
     Object.freeze({ event: 'PostToolUse', matcher: '', phase: 'post-tool' }),
@@ -25,16 +27,15 @@ function object(value) {
 function nonEmpty(value) {
     return typeof value === 'string' && value.trim() ? value : null;
 }
-function resolveCodexSpawnedChild(transcriptPath, expected) {
+function readRolloutRecords(transcriptPath, sessionId) {
     const name = path.basename(transcriptPath);
-    if (!transcriptPath || (!name.endsWith(`-${expected.sessionId}.jsonl`) && name !== `${expected.sessionId}.jsonl`)) {
+    if (!transcriptPath || (!name.endsWith(`-${sessionId}.jsonl`) && name !== `${sessionId}.jsonl`)) {
         throw new Error('Codex parent rollout path is invalid');
     }
     const stat = fs.lstatSync(transcriptPath);
     if (!stat.isFile() || stat.isSymbolicLink())
         throw new Error('Codex parent rollout is not a regular file');
-    const maxBytes = 8 * 1024 * 1024;
-    const offset = Math.max(0, stat.size - maxBytes);
+    const offset = Math.max(0, stat.size - 8 * 1024 * 1024);
     const buffer = Buffer.alloc(stat.size - offset);
     const descriptor = fs.openSync(transcriptPath, 'r');
     try {
@@ -46,37 +47,48 @@ function resolveCodexSpawnedChild(transcriptPath, expected) {
     let text = buffer.toString('utf8');
     if (offset)
         text = text.slice(text.indexOf('\n') + 1);
-    const records = text.split(/\r?\n/).filter(Boolean).map((line) => object(JSON.parse(line))).filter(Boolean);
-    const calls = records.filter((record) => {
-        const payload = object(record?.payload);
-        return record?.type === 'response_item'
-            && payload?.type === 'function_call'
-            && payload.call_id === expected.toolUseId
-            && payload.namespace === 'collaboration'
-            && payload.name === 'spawn_agent';
-    });
+    return text.split(/\r?\n/u).filter(Boolean).map((line) => object(JSON.parse(line))).filter((record) => Boolean(record));
+}
+function isExpectedSpawnCall(record, expected) {
+    const payload = object(record.payload);
+    return record.type === 'response_item'
+        && payload?.type === 'function_call'
+        && payload.call_id === expected.toolUseId
+        && payload.namespace === 'collaboration'
+        && payload.name === 'spawn_agent';
+}
+function spawnArgsMatch(args, expected) {
+    return args?.agent_type === expected.nativeAgent
+        && args.task_name === expected.taskName
+        && (!expected.requestedModel || args.model === expected.requestedModel)
+        && (!expected.requestedReasoningEffort || args.reasoning_effort === expected.requestedReasoningEffort);
+}
+function isExpectedChildActivity(record, expected) {
+    const payload = object(record.payload);
+    const item = object(payload?.item);
+    return record.type === 'event_msg'
+        && payload?.type === 'item_completed'
+        && payload.thread_id === expected.sessionId
+        && payload.turn_id === expected.turnId
+        && item?.type === 'SubAgentActivity'
+        && item.id === expected.toolUseId
+        && item.kind === 'started'
+        && item.agent_path === `/root/${expected.taskName}`
+        && Boolean(nonEmpty(item.agent_thread_id));
+}
+function resolveCodexSpawnedChild(transcriptPath, expected) {
+    if (!parseCodexLifecycleBinding(expected.taskName)) {
+        throw new Error('Codex spawn task_name does not carry a valid lifecycle binding');
+    }
+    const records = readRolloutRecords(transcriptPath, expected.sessionId);
+    const calls = records.filter((record) => isExpectedSpawnCall(record, expected));
     if (calls.length !== 1)
         throw new Error('Codex parent rollout spawn call was not found uniquely');
     const call = object(calls[0]?.payload);
     const args = object(JSON.parse(nonEmpty(call?.arguments) ?? '{}'));
-    if (args?.agent_type !== expected.nativeAgent
-        || args.task_name !== expected.taskName
-        || (expected.requestedModel && args.model !== expected.requestedModel)
-        || (expected.requestedReasoningEffort && args.reasoning_effort !== expected.requestedReasoningEffort))
+    if (!spawnArgsMatch(args, expected))
         throw new Error('Codex parent rollout spawn identity does not match the hook event');
-    const activities = records.filter((record) => {
-        const payload = object(record?.payload);
-        const item = object(payload?.item);
-        return record?.type === 'event_msg'
-            && payload?.type === 'item_completed'
-            && payload.thread_id === expected.sessionId
-            && payload.turn_id === expected.turnId
-            && item?.type === 'SubAgentActivity'
-            && item.id === expected.toolUseId
-            && item.kind === 'started'
-            && item.agent_path === `/root/${expected.taskName}`
-            && nonEmpty(item.agent_thread_id);
-    });
+    const activities = records.filter((record) => isExpectedChildActivity(record, expected));
     if (activities.length !== 1)
         throw new Error('Codex parent rollout child activity was not found uniquely');
     return nonEmpty(object(object(activities[0]?.payload)?.item)?.agent_thread_id);
@@ -141,27 +153,6 @@ function parseCodexHooksList(value, repoRoot, expectedSource = 'direct-host') {
         throw new Error('CODEX_PREFLIGHT_HOOKS_NOT_LOADED: lifecycle hooks are not loaded for this workspace');
     return Object.freeze(hooks);
 }
-function hasCodexRuntimeLiveness(runtimeRoot, hookDefinitionHash, identity) {
-    if (!identity || !fs.existsSync(runtimeRoot))
-        return false;
-    return fs.readdirSync(runtimeRoot)
-        .filter((name) => /^[a-f0-9]{64}\.json$/.test(name))
-        .some((name) => {
-        try {
-            const record = object(JSON.parse(fs.readFileSync(path.join(runtimeRoot, name), 'utf8')));
-            const state = object(record?.state);
-            const spawnEvent = object(state?.spawn);
-            return !['invalid', 'expired'].includes(String(state?.status))
-                && spawnEvent?.hookDefinitionHash === hookDefinitionHash
-                && spawnEvent.sessionId === identity.sessionId
-                && spawnEvent.turnId === identity.turnId
-                && spawnEvent.toolUseId === identity.toolUseId;
-        }
-        catch {
-            return false;
-        }
-    });
-}
 function parseCodexThreadResolution(readValue, rolloutRecords) {
     const readRoot = object(readValue);
     const thread = object(readRoot?.thread);
@@ -215,6 +206,17 @@ function parseCodexThreadResolution(readValue, rolloutRecords) {
         })
     });
 }
+function resolvePreflightTaskDir(repoRoot, taskId) {
+    try {
+        const context = taskId
+            ? resolveTaskRef(taskId, { repoRoot })
+            : resolveTaskContext(undefined, { repoRoot });
+        return context.ok ? context.taskDir : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 function readCodexRolloutRecords(readValue, childThreadId) {
     const thread = object(object(readValue)?.thread);
     const rolloutPath = nonEmpty(thread?.path);
@@ -491,7 +493,24 @@ async function resolveCodexTerminal(childThreadId, expectedTurnIdOrOptions = {},
         transport.close();
     }
 }
-async function preflightCodexLifecycleEvidence(repoRoot = process.cwd(), runtimeIdentity) {
+async function preflightCodexLifecycleEvidence(repoRoot = process.cwd(), runtimeIdentity, taskId) {
+    const { cliVersion, hooksRaw } = validateStaticCodexPreflight(repoRoot);
+    const hookDefinitionHash = crypto.createHash('sha256').update(hooksRaw).digest('hex');
+    const taskDir = resolvePreflightTaskDir(repoRoot, taskId);
+    const runtimeLiveness = Boolean(taskDir && runtimeIdentity
+        && hasActiveCodexLifecycleEvidence(taskDir, { hookDefinitionHash, identity: runtimeIdentity }));
+    const host = await discoverLifecycleHooks(repoRoot);
+    return Object.freeze({
+        cliVersion,
+        hookDefinitionHash,
+        staticReady: true,
+        discoveredHooks: host.discoveredHooks,
+        hookProvenance: host.hookProvenance,
+        runtimeLiveness,
+        diagnostics: host.diagnostics
+    });
+}
+function validateStaticCodexPreflight(repoRoot) {
     const versionRun = spawnSync('codex', ['--version'], { encoding: 'utf8' });
     const match = /codex-cli\s+(\d+\.\d+\.\d+)/.exec(versionRun.stdout ?? '');
     if (versionRun.status !== 0 || !match?.[1] || !semver.gte(match[1], '0.147.0')) {
@@ -519,9 +538,9 @@ async function preflightCodexLifecycleEvidence(repoRoot = process.cwd(), runtime
     finally {
         fs.rmSync(schemaDir, { recursive: true, force: true });
     }
-    const hookDefinitionHash = crypto.createHash('sha256').update(hooksRaw).digest('hex');
-    const runtimeRoot = resolveAgentRuntimeStoreRoot({ repoRoot, store: 'lifecycle' });
-    const runtimeLiveness = hasCodexRuntimeLiveness(runtimeRoot, hookDefinitionHash, runtimeIdentity);
+    return { cliVersion: match[1], hooksRaw };
+}
+async function discoverLifecycleHooks(repoRoot) {
     const transport = new CodexAppServerTransport();
     transport.start();
     let discoveredHooks;
@@ -548,10 +567,7 @@ async function preflightCodexLifecycleEvidence(repoRoot = process.cwd(), runtime
     const hookSource = process.env.AGENT_INFRA_CODEX_CONTROLLER_CONTEXT
         ? 'isolated-user'
         : source === 'managed' ? 'managed' : 'project';
-    return Object.freeze({
-        cliVersion: match[1],
-        hookDefinitionHash,
-        staticReady: true,
+    return {
         discoveredHooks,
         hookProvenance: Object.freeze({
             hookSource,
@@ -563,9 +579,8 @@ async function preflightCodexLifecycleEvidence(repoRoot = process.cwd(), runtime
                 currentHash: hook.currentHash
             })))).digest('hex')
         }),
-        runtimeLiveness,
         diagnostics: transport.diagnostics
-    });
+    };
 }
-export { CodexAppServerTransport, hasCodexRuntimeLiveness, parseCodexModelReroute, parseCodexHooksList, parseCodexThreadResolution, parseCodexTurnCompleted, resolveCodexSpawnedChild, preflightCodexLifecycleEvidence, resolveCodexTerminal, resolveCodexThread, validateCodexLifecycleHookConfig };
+export { CodexAppServerTransport, parseCodexModelReroute, parseCodexHooksList, parseCodexThreadResolution, parseCodexTurnCompleted, resolveCodexSpawnedChild, preflightCodexLifecycleEvidence, resolveCodexTerminal, resolveCodexThread, validateCodexLifecycleHookConfig };
 //# sourceMappingURL=app-server.js.map

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

@@ -0,0 +1,114 @@
+import { managedDelegationRole } from '../../../task/delegation-receipts.js';
+const MARKER_PREFIX = '__agent_infra_binding_';
+const BASE32_ALPHABET = 'abcdefghijklmnopqrstuvwxyz234567';
+const TASK_ID_PATTERN = /^TASK-[0-9]{8}-[0-9]{6}$/u;
+const SAFE_LABEL_PATTERN = /^[a-z0-9_]{1,80}$/u;
+const SAFE_ID_PATTERN = /^[A-Za-z0-9_-]{1,128}$/u;
+function assertSafeTaskName(taskName) {
+    if (Buffer.byteLength(taskName, 'utf8') > 255 || !/^[a-z0-9_]+$/u.test(taskName)) {
+        throw new Error('Codex task_name must use lowercase letters, digits, and underscores within 255 bytes');
+    }
+}
+function encodeTaskNamePayload(value) {
+    let buffer = 0;
+    let bits = 0;
+    let encoded = '';
+    for (const byte of Buffer.from(value, 'utf8')) {
+        buffer = (buffer << 8) | byte;
+        bits += 8;
+        while (bits >= 5) {
+            encoded += BASE32_ALPHABET[(buffer >>> (bits - 5)) & 31];
+            bits -= 5;
+        }
+    }
+    if (bits)
+        encoded += BASE32_ALPHABET[(buffer << (5 - bits)) & 31];
+    return encoded;
+}
+function decodeTaskNamePayload(encoded) {
+    let buffer = 0;
+    let bits = 0;
+    const bytes = [];
+    for (const character of encoded) {
+        const value = BASE32_ALPHABET.indexOf(character);
+        if (value < 0)
+            return null;
+        buffer = (buffer << 5) | value;
+        bits += 5;
+        if (bits >= 8) {
+            bytes.push((buffer >>> (bits - 8)) & 255);
+            bits -= 8;
+        }
+    }
+    if (bits && (buffer & ((1 << bits) - 1)) !== 0)
+        return null;
+    const decoded = Buffer.from(bytes).toString('utf8');
+    return encodeTaskNamePayload(decoded) === encoded ? decoded : null;
+}
+function encodeCodexLifecycleBinding(binding) {
+    if (!TASK_ID_PATTERN.test(binding.taskId)
+        || !SAFE_ID_PATTERN.test(binding.runId)
+        || !SAFE_ID_PATTERN.test(binding.receiptId)) {
+        throw new Error('Codex lifecycle task binding is invalid');
+    }
+    return `${MARKER_PREFIX}${encodeTaskNamePayload(JSON.stringify(binding))}`;
+}
+function appendCodexLifecycleBinding(label, binding) {
+    if (!SAFE_LABEL_PATTERN.test(label))
+        throw new Error('Codex task_name label is invalid');
+    const taskName = `${label}${encodeCodexLifecycleBinding(binding)}`;
+    assertSafeTaskName(taskName);
+    return taskName;
+}
+function parseCodexLifecycleBinding(taskName) {
+    assertSafeTaskName(taskName);
+    const markerIndex = taskName.lastIndexOf(MARKER_PREFIX);
+    if (markerIndex < 1)
+        return null;
+    const label = taskName.slice(0, markerIndex);
+    const encoded = taskName.slice(markerIndex + MARKER_PREFIX.length);
+    if (!SAFE_LABEL_PATTERN.test(label) || !/^[a-z2-7]+$/u.test(encoded))
+        return null;
+    try {
+        const decoded = decodeTaskNamePayload(encoded);
+        if (!decoded)
+            return null;
+        const value = JSON.parse(decoded);
+        if (Object.keys(value).sort().join(',') !== 'receiptId,runId,taskId'
+            || typeof value.taskId !== 'string' || !TASK_ID_PATTERN.test(value.taskId)
+            || typeof value.runId !== 'string' || !SAFE_ID_PATTERN.test(value.runId)
+            || typeof value.receiptId !== 'string' || !SAFE_ID_PATTERN.test(value.receiptId))
+            return null;
+        return Object.freeze({
+            taskName,
+            label,
+            binding: Object.freeze({ taskId: value.taskId, runId: value.runId, receiptId: value.receiptId })
+        });
+    }
+    catch {
+        return null;
+    }
+}
+function verifyCodexLifecycleTaskBinding(binding, run, nativeAgent, expected = {}) {
+    if (!codexReceiptMatchesBinding(binding, run, nativeAgent, expected)) {
+        throw new Error('Codex lifecycle task binding does not match the current pending receipt');
+    }
+}
+function codexReceiptMatchesBinding(binding, run, nativeAgent, expected) {
+    const receipt = run.pendingDelegation;
+    return Boolean(receipt)
+        && run.status === 'running'
+        && run.runId === binding.runId
+        && receipt.runId === binding.runId
+        && receipt.id === binding.receiptId
+        && receipt.client === 'codex'
+        && receipt.status === 'prepared'
+        && managedDelegationRole(nativeAgent) === receipt.role
+        && requestedBindingMatches(receipt, expected);
+}
+function requestedBindingMatches(receipt, expected) {
+    return (!expected.requestedModel || receipt.requestedModel === expected.requestedModel)
+        && (!expected.requestedReasoningEffort || receipt.requestedReasoningEffort === expected.requestedReasoningEffort);
+}
+export { appendCodexLifecycleBinding, encodeCodexLifecycleBinding, parseCodexLifecycleBinding, verifyCodexLifecycleTaskBinding };
+//# sourceMappingURL=binding.js.map