@fitlab-ai/agent-infra 0.9.4 → 0.9.6

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

@@ -0,0 +1,175 @@
+function createCodexLifecycleState(cliVersion) {
+    if (!cliVersion.trim())
+        throw new Error('Codex CLI version is required');
+    return Object.freeze({
+        schemaVersion: 1,
+        cliVersion,
+        status: 'empty',
+        spawn: null,
+        child: null,
+        thread: null,
+        settings: null,
+        reroute: null,
+        terminal: null,
+        stop: null,
+        startEvidence: null,
+        stopEvidence: null,
+        error: null
+    });
+}
+function invalid(state, code, message) {
+    return Object.freeze({
+        ...state,
+        status: 'invalid',
+        startEvidence: null,
+        stopEvidence: null,
+        error: Object.freeze({ code, message })
+    });
+}
+function same(left, right) {
+    return JSON.stringify(left) === JSON.stringify(right);
+}
+function requiredStrings(event) {
+    return Object.entries(event).every(([key, value]) => key === 'forkedFromId'
+        || (typeof value !== 'string' || value.trim() !== ''));
+}
+function derive(state) {
+    const { spawn, child, thread, settings, reroute, terminal, stop } = state;
+    if (spawn && child && (spawn.sessionId !== child.parentThreadId
+        || spawn.nativeAgent !== child.nativeAgent)) {
+        return invalid(state, 'CODEX_EVIDENCE_IDENTITY_MISMATCH', 'hook spawn and child identity do not match');
+    }
+    if (child && child.sessionId !== child.parentThreadId) {
+        return invalid(state, 'CODEX_EVIDENCE_IDENTITY_MISMATCH', 'child event session does not match the parent thread');
+    }
+    if (child && thread && child.childThreadId !== thread.childThreadId) {
+        return invalid(state, 'CODEX_EVIDENCE_IDENTITY_MISMATCH', 'hook and App Server child identity do not match');
+    }
+    if (child && thread && child.nativeAgent !== thread.nativeAgent) {
+        return invalid(state, 'CODEX_EVIDENCE_IDENTITY_MISMATCH', 'hook and App Server agent roles do not match');
+    }
+    if (child && thread && child.parentThreadId !== thread.parentThreadId) {
+        return invalid(state, 'CODEX_EVIDENCE_PARENT_MISMATCH', 'hook and App Server parent identity do not match');
+    }
+    if (spawn && thread && (thread.parentThreadId !== spawn.sessionId
+        || thread.sourceParentThreadId !== spawn.sessionId)) {
+        return invalid(state, 'CODEX_EVIDENCE_PARENT_MISMATCH', 'App Server parent identity does not match the spawning session');
+    }
+    if (spawn && thread && spawn.nativeAgent !== thread.nativeAgent) {
+        return invalid(state, 'CODEX_EVIDENCE_IDENTITY_MISMATCH', 'spawn and App Server agent roles do not match');
+    }
+    if (thread?.forkedFromId !== null && thread?.forkedFromId !== undefined) {
+        return invalid(state, 'CODEX_EVIDENCE_FORK_FORBIDDEN', 'forked child threads are not fresh lifecycle evidence');
+    }
+    if (settings && child && settings.childThreadId !== child.childThreadId) {
+        return invalid(state, 'CODEX_EVIDENCE_IDENTITY_MISMATCH', 'resolved settings belong to a different child');
+    }
+    if (reroute && child && reroute.childThreadId !== child.childThreadId) {
+        return invalid(state, 'CODEX_EVIDENCE_IDENTITY_MISMATCH', 'model reroute belongs to a different child');
+    }
+    if (spawn?.requestedModel && settings && spawn.requestedModel !== settings.model) {
+        if (!reroute
+            || reroute.fromModel !== spawn.requestedModel
+            || reroute.toModel !== settings.model
+            || !reroute.reason.trim()) {
+            return invalid(state, 'CODEX_EVIDENCE_MODEL_UNEXPLAINED', 'resolved model differs without a matching host reroute');
+        }
+    }
+    if (spawn?.requestedReasoningEffort
+        && settings
+        && spawn.requestedReasoningEffort !== settings.reasoningEffort) {
+        return invalid(state, 'CODEX_EVIDENCE_EFFORT_UNEXPLAINED', 'resolved reasoning effort differs without structured host evidence');
+    }
+    if (terminal && terminal.status !== 'completed') {
+        return invalid(state, 'CODEX_EVIDENCE_TERMINAL_INVALID', `child turn ended as '${terminal.status}'`);
+    }
+    if (terminal && child && terminal.childThreadId !== child.childThreadId) {
+        return invalid(state, 'CODEX_EVIDENCE_IDENTITY_MISMATCH', 'terminal event belongs to a different child');
+    }
+    if (stop && child && (stop.sessionId !== child.sessionId
+        || stop.turnId !== child.turnId
+        || stop.childThreadId !== child.childThreadId
+        || stop.nativeAgent !== child.nativeAgent)) {
+        return invalid(state, 'CODEX_EVIDENCE_IDENTITY_MISMATCH', 'hook stop identity does not match the child');
+    }
+    let startEvidence = null;
+    if (spawn && child && thread && settings) {
+        startEvidence = Object.freeze({
+            schemaVersion: 1,
+            cliVersion: state.cliVersion,
+            parentThreadId: spawn.sessionId,
+            parentTurnId: spawn.turnId,
+            spawnToolUseId: spawn.toolUseId,
+            childThreadId: child.childThreadId,
+            nativeAgent: child.nativeAgent,
+            spawnMode: 'fresh',
+            actualModel: Object.freeze({ value: settings.model, source: 'codex-app-server-settings' }),
+            actualReasoningEffort: Object.freeze({ value: settings.reasoningEffort, source: 'codex-app-server-settings' }),
+            modelFallbackReason: reroute?.reason ?? null,
+            reasoningEffortFallbackReason: null,
+            hookDefinitionHash: spawn.hookDefinitionHash
+        });
+    }
+    let stopEvidence = null;
+    if (startEvidence && terminal?.status === 'completed' && stop) {
+        stopEvidence = Object.freeze({
+            schemaVersion: 1,
+            childThreadId: startEvidence.childThreadId,
+            turnId: terminal.turnId,
+            terminalStatus: 'completed',
+            hookStopObserved: stop.source !== 'parent-rollout'
+        });
+    }
+    const status = stopEvidence
+        ? 'stop-ready'
+        : terminal
+            ? 'observed-terminal'
+            : startEvidence
+                ? 'start-ready'
+                : child
+                    ? 'observed-child'
+                    : spawn
+                        ? 'observed-spawn'
+                        : 'empty';
+    return Object.freeze({ ...state, status, startEvidence, stopEvidence, error: null });
+}
+function reduceCodexLifecycleEvent(state, event) {
+    if (state.status === 'invalid' || state.status === 'expired')
+        return state;
+    if (!requiredStrings(event)) {
+        return invalid(state, 'CODEX_EVIDENCE_FIELD_MISSING', 'lifecycle event contains an empty required field');
+    }
+    const key = {
+        'hook-spawn': 'spawn',
+        'hook-child': 'child',
+        'app-thread': 'thread',
+        'app-settings': 'settings',
+        'app-reroute': 'reroute',
+        'app-terminal': 'terminal',
+        'hook-stop': 'stop'
+    }[event.type];
+    const existing = state[key];
+    if (existing) {
+        if (same(existing, event))
+            return state;
+        return invalid(state, 'CODEX_EVIDENCE_REPLAY_CONFLICT', `conflicting '${event.type}' event`);
+    }
+    return derive(Object.freeze({ ...state, [key]: Object.freeze({ ...event }) }));
+}
+function expireCodexLifecycleState(state) {
+    if (!['observed-spawn', 'observed-child', 'start-ready', 'observed-terminal'].includes(state.status)) {
+        return state;
+    }
+    return Object.freeze({
+        ...state,
+        status: 'expired',
+        startEvidence: null,
+        stopEvidence: null,
+        error: Object.freeze({
+            code: 'CODEX_EVIDENCE_EXPIRED',
+            message: 'Codex lifecycle evidence expired before completion'
+        })
+    });
+}
+export { createCodexLifecycleState, expireCodexLifecycleState, reduceCodexLifecycleEvent };
+//# sourceMappingURL=evidence.js.map

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

@@ -0,0 +1,255 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { createCodexLifecycleState, expireCodexLifecycleState, reduceCodexLifecycleEvent } from './evidence.js';
+const LOCK_RETRY_MS = 10;
+const LOCK_TIMEOUT_MS = 1_000;
+const LOCK_STALE_MS = 30_000;
+function digest(value) {
+    return crypto.createHash('sha256').update(value).digest('hex');
+}
+function readRecord(file) {
+    const value = JSON.parse(fs.readFileSync(file, 'utf8'));
+    if (value.schemaVersion !== 1
+        || !Number.isSafeInteger(value.revision)
+        || value.revision < 1
+        || !value.state
+        || value.state.schemaVersion !== 1) {
+        throw new Error(`Codex lifecycle record '${path.basename(file)}' is invalid`);
+    }
+    return value;
+}
+function recordFiles(root) {
+    if (!fs.existsSync(root))
+        return [];
+    return fs.readdirSync(root)
+        .filter((name) => /^[a-f0-9]{64}\.json$/.test(name))
+        .map((name) => path.join(root, name));
+}
+function writeRecord(file, record, expectedRevision) {
+    const temp = `${file}.${process.pid}.${crypto.randomUUID()}.tmp`;
+    fs.writeFileSync(temp, `${JSON.stringify(record, null, 2)}\n`, {
+        encoding: 'utf8',
+        flag: 'wx',
+        mode: 0o600
+    });
+    try {
+        const actualRevision = fs.existsSync(file) ? readRecord(file).revision : 0;
+        if (actualRevision !== expectedRevision) {
+            throw new Error(`Codex lifecycle revision changed from ${expectedRevision} to ${actualRevision}`);
+        }
+        fs.renameSync(temp, file);
+        fs.chmodSync(file, 0o600);
+    }
+    finally {
+        if (fs.existsSync(temp))
+            fs.unlinkSync(temp);
+    }
+}
+function createCodexLifecycleStore(options) {
+    const root = options.root ?? path.join(process.cwd(), '.agents', 'workspace', '.runtime', 'codex-lifecycle');
+    const now = options.now ?? (() => new Date().toISOString());
+    fs.mkdirSync(root, { recursive: true, mode: 0o700 });
+    fs.chmodSync(root, 0o700);
+    function withWriteLock(operation) {
+        const lock = path.join(root, '.write.lock');
+        const deadline = Date.now() + LOCK_TIMEOUT_MS;
+        let descriptor = null;
+        while (descriptor === null) {
+            try {
+                descriptor = fs.openSync(lock, 'wx', 0o600);
+            }
+            catch (error) {
+                if (error.code !== 'EEXIST')
+                    throw error;
+                try {
+                    if (Date.now() - fs.statSync(lock).mtimeMs > LOCK_STALE_MS) {
+                        fs.unlinkSync(lock);
+                        continue;
+                    }
+                }
+                catch (lockError) {
+                    if (lockError.code === 'ENOENT')
+                        continue;
+                    throw lockError;
+                }
+                if (Date.now() >= deadline)
+                    throw new Error('Codex lifecycle store is busy');
+                Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, LOCK_RETRY_MS);
+            }
+        }
+        try {
+            return operation();
+        }
+        finally {
+            fs.closeSync(descriptor);
+            fs.unlinkSync(lock);
+        }
+    }
+    function findByChild(childThreadId) {
+        return recordFiles(root).filter((file) => {
+            const child = readRecord(file).state.child;
+            return child?.childThreadId === childThreadId;
+        });
+    }
+    function locate(event) {
+        if (event.type === 'hook-spawn') {
+            return path.join(root, `${digest(`${event.sessionId}\0${event.turnId}\0${event.toolUseId}`)}.json`);
+        }
+        if (event.type === 'hook-child') {
+            const matches = recordFiles(root).filter((file) => {
+                const state = readRecord(file).state;
+                return state.spawn?.sessionId === event.parentThreadId
+                    && state.spawn.nativeAgent === event.nativeAgent
+                    && (!state.child || state.child.childThreadId === event.childThreadId);
+            });
+            if (matches.length !== 1) {
+                throw new Error(matches.length === 0
+                    ? 'Codex lifecycle parent session and agent correlation was not found'
+                    : 'Codex lifecycle parent session and agent correlation is ambiguous');
+            }
+            return matches[0];
+        }
+        const matches = findByChild(event.childThreadId);
+        if (matches.length !== 1) {
+            throw new Error(matches.length === 0
+                ? `Codex lifecycle child '${event.childThreadId}' was not found`
+                : `Codex lifecycle child '${event.childThreadId}' is ambiguous`);
+        }
+        return matches[0];
+    }
+    function apply(event) {
+        return withWriteLock(() => {
+            const file = locate(event);
+            const current = fs.existsSync(file)
+                ? readRecord(file)
+                : Object.freeze({
+                    schemaVersion: 1,
+                    revision: 0,
+                    state: createCodexLifecycleState(options.cliVersion),
+                    consumer: null,
+                    consumedAt: null,
+                    updatedAt: now()
+                });
+            if (current.consumer)
+                throw new Error(`Codex lifecycle evidence was already consumed by '${current.consumer}'`);
+            const nextState = reduceCodexLifecycleEvent(current.state, event);
+            const next = Object.freeze({
+                schemaVersion: 1,
+                revision: current.revision + 1,
+                state: nextState,
+                consumer: null,
+                consumedAt: null,
+                updatedAt: now()
+            });
+            writeRecord(file, next, current.revision);
+            return Object.freeze({ path: file, revision: next.revision, state: next.state });
+        });
+    }
+    function applyToSpawn(identity, event) {
+        return withWriteLock(() => {
+            const file = path.join(root, `${digest(`${identity.sessionId}\0${identity.turnId}\0${identity.toolUseId}`)}.json`);
+            if (!fs.existsSync(file))
+                throw new Error('Codex lifecycle spawn identity was not found');
+            const current = readRecord(file);
+            if (current.consumer)
+                throw new Error(`Codex lifecycle evidence was already consumed by '${current.consumer}'`);
+            if (current.state.spawn?.sessionId !== identity.sessionId
+                || current.state.spawn.turnId !== identity.turnId
+                || current.state.spawn.toolUseId !== identity.toolUseId)
+                throw new Error('Codex lifecycle spawn identity does not match the stored event');
+            const nextState = reduceCodexLifecycleEvent(current.state, event);
+            const next = Object.freeze({
+                ...current,
+                revision: current.revision + 1,
+                state: nextState,
+                updatedAt: now()
+            });
+            writeRecord(file, next, current.revision);
+            return Object.freeze({ path: file, revision: next.revision, state: next.state });
+        });
+    }
+    function findByParent(parentThreadId) {
+        const matches = recordFiles(root)
+            .map(readRecord)
+            .filter((record) => record.state.startEvidence?.parentThreadId === parentThreadId
+            && ['start-ready', 'observed-terminal', 'stop-ready'].includes(record.state.status));
+        const unconsumed = matches.filter((record) => !record.consumer);
+        if (unconsumed.length > 1)
+            throw new Error(`Codex lifecycle parent '${parentThreadId}' has ambiguous active children`);
+        if (unconsumed.length === 1)
+            return Object.freeze(unconsumed);
+        return Object.freeze(matches
+            .filter((record) => record.consumer && record.state.status === 'stop-ready')
+            .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt)));
+    }
+    function read(childThreadId) {
+        const matches = findByChild(childThreadId);
+        if (matches.length !== 1)
+            throw new Error(`Codex lifecycle child '${childThreadId}' was not found uniquely`);
+        return readRecord(matches[0]);
+    }
+    function consume(childThreadId, consumer, expectedHookDefinitionHash) {
+        if (!consumer.trim())
+            throw new Error('Codex lifecycle consumer is required');
+        return withWriteLock(() => {
+            const matches = findByChild(childThreadId);
+            if (matches.length !== 1)
+                throw new Error(`Codex lifecycle child '${childThreadId}' was not found uniquely`);
+            const file = matches[0];
+            const current = readRecord(file);
+            if (current.consumer) {
+                if (current.consumer !== consumer) {
+                    throw new Error(`Codex lifecycle evidence was already consumed by '${current.consumer}'`);
+                }
+                if (expectedHookDefinitionHash
+                    && current.state.startEvidence?.hookDefinitionHash !== expectedHookDefinitionHash)
+                    throw new Error('Codex lifecycle hook definition hash is stale');
+                return current;
+            }
+            if (current.state.status !== 'stop-ready')
+                throw new Error('Codex lifecycle evidence is not stop-ready');
+            if (expectedHookDefinitionHash
+                && current.state.startEvidence?.hookDefinitionHash !== expectedHookDefinitionHash)
+                throw new Error('Codex lifecycle hook definition hash is stale');
+            const next = Object.freeze({
+                ...current,
+                revision: current.revision + 1,
+                consumer,
+                consumedAt: now(),
+                updatedAt: now()
+            });
+            writeRecord(file, next, current.revision);
+            return next;
+        });
+    }
+    function expireBefore(cutoff) {
+        return withWriteLock(() => {
+            let changed = 0;
+            for (const file of recordFiles(root)) {
+                const current = readRecord(file);
+                if (current.updatedAt >= cutoff)
+                    continue;
+                if (current.consumer || ['invalid', 'expired', 'stop-ready'].includes(current.state.status)) {
+                    fs.unlinkSync(file);
+                    changed += 1;
+                    continue;
+                }
+                const expiredState = expireCodexLifecycleState(current.state);
+                if (expiredState === current.state)
+                    continue;
+                writeRecord(file, Object.freeze({
+                    ...current,
+                    revision: current.revision + 1,
+                    state: expiredState,
+                    updatedAt: now()
+                }), current.revision);
+                changed += 1;
+            }
+            return changed;
+        });
+    }
+    return Object.freeze({ root, apply, applyToSpawn, consume, expireBefore, findByParent, read });
+}
+export { createCodexLifecycleStore };
+//# sourceMappingURL=store.js.map

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

@@ -11,7 +11,7 @@ const codexAdapter = defineAgentClientAdapter({
         commands: { level: 'integrated' },
         hooks: { level: 'integrated' },
         subagents: { level: 'experimental' },
-        orchestration: { level: 'unsupported' },
+        orchestration: { level: 'experimental' },
         sandbox: { level: 'integrated' },
         verification: { level: 'compatible' }
     },
@@ -21,8 +21,8 @@ const codexAdapter = defineAgentClientAdapter({
         guidance: 'Use the host model picker for the complete model and reasoning-effort catalog.'
     },
     delegationEvidence: {
-        actualModel: 'unavailable',
-        actualReasoningEffort: 'unavailable'
+        actualModel: 'app-server',
+        actualReasoningEffort: 'app-server'
     },
     project: {
         ownedPathPrefixes: ['.codex/'],

package/dist/lib/git/workflow.js

@@ -119,7 +119,6 @@ function pushRebasedBranch(input, runner = defaultRunner) {
         .map((name) => value(runner, input.cwd, ['rev-parse', '--git-path', name]))
         .filter((candidate) => Boolean(candidate));
     if (snapshot.worktree.length > 0 || snapshot.staged.length > 0 ||
-        run(runner, input.cwd, ['rev-parse', '-q', '--verify', 'REBASE_HEAD']).status === 0 ||
         rebasePaths.some((candidate) => fs.existsSync(path.isAbsolute(candidate) ? candidate : path.join(input.cwd, candidate)))) {
         return { status: 'failed', changed: false, snapshot, operations: [], error: { code: 'GIT_LOCAL_STATE_UNSAFE', message: 'Working tree must be clean with no rebase in progress' } };
     }

package/dist/lib/git/worktree-identity.js

@@ -0,0 +1,64 @@
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+function normalizeCanonicalPath(value, platform = process.platform) {
+    return platform === 'win32'
+        ? path.win32.normalize(value).replaceAll('/', '\\').toLowerCase()
+        : path.posix.normalize(value);
+}
+function sameFilesystemEntry(left, right, platform = process.platform) {
+    const leftReal = fs.realpathSync.native(left);
+    const rightReal = fs.realpathSync.native(right);
+    const leftStat = fs.statSync(leftReal, { bigint: true });
+    const rightStat = fs.statSync(rightReal, { bigint: true });
+    if (leftStat.ino !== 0n && rightStat.ino !== 0n) {
+        return leftStat.dev === rightStat.dev && leftStat.ino === rightStat.ino;
+    }
+    return normalizeCanonicalPath(leftReal, platform) === normalizeCanonicalPath(rightReal, platform);
+}
+function git(root, args) {
+    return execFileSync('git', args, {
+        cwd: root,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe']
+    }).trim();
+}
+function resolveGitWorktreeIdentity(worktreeRoot) {
+    try {
+        const canonical = fs.realpathSync.native(worktreeRoot);
+        const topLevel = fs.realpathSync.native(git(canonical, ['rev-parse', '--show-toplevel']));
+        if (!sameFilesystemEntry(canonical, topLevel)) {
+            throw new Error('worktree root is not the Git top-level directory');
+        }
+        const commonDir = fs.realpathSync.native(git(canonical, [
+            'rev-parse', '--path-format=absolute', '--git-common-dir'
+        ]));
+        const branch = git(canonical, ['symbolic-ref', '--short', 'HEAD']);
+        return { worktreeRoot: canonical, commonDir, branch };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`SANDBOX_CONTROL_WORKTREE_INVALID: ${message}`);
+    }
+}
+function assertGitWorktreeBinding(stateRoot, worktreeRoot, expectedBranch) {
+    const state = resolveGitWorktreeIdentity(stateRoot);
+    const worktree = resolveGitWorktreeIdentity(worktreeRoot);
+    if (!sameFilesystemEntry(state.commonDir, worktree.commonDir)) {
+        throw new Error('SANDBOX_CONTROL_WORKTREE_INVALID: state and worktree roots have different Git common directories');
+    }
+    if (worktree.branch !== expectedBranch) {
+        throw new Error(`SANDBOX_CONTROL_WORKTREE_INVALID: expected branch '${expectedBranch}', got '${worktree.branch}'`);
+    }
+    return worktree;
+}
+function assertGitRepositoryBinding(stateRoot, worktreeRoot) {
+    const state = resolveGitWorktreeIdentity(stateRoot);
+    const worktree = resolveGitWorktreeIdentity(worktreeRoot);
+    if (!sameFilesystemEntry(state.commonDir, worktree.commonDir)) {
+        throw new Error('SANDBOX_CONTROL_WORKTREE_INVALID: state and worktree roots have different Git common directories');
+    }
+    return worktree;
+}
+export { assertGitWorktreeBinding, assertGitRepositoryBinding, normalizeCanonicalPath, resolveGitWorktreeIdentity, sameFilesystemEntry };
+//# sourceMappingURL=worktree-identity.js.map