@fitlab-ai/agent-infra 0.9.8 → 0.9.10

package/dist/lib/task/commit-operation.js

@@ -0,0 +1,335 @@
+import fs from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import { commitExplicitPaths, inspectGitWorkflow, pushGitRefs } from '../git/workflow.js';
+import { parseTaskFrontmatter } from './frontmatter.js';
+import { resolveTaskContext, resolveTaskRef } from './resolve-ref.js';
+import { commitPushDecision } from './commit-policy.js';
+import { mergeOperationWarnings } from './operation-outcome.js';
+import { TaskExecutionLockError, withRepositoryMutationLock, withTaskExecutionLock } from './task-execution-lock.js';
+import { appendActivityEntry, locateActivityLog } from './activity-log.js';
+import { captureTaskWriteMetadata, writeTask } from './write.js';
+import { commitOrchestrationStageCompletion, planOrchestrationStageCompletion } from './orchestration.js';
+const HEAD_REF = /^refs\/heads\/(.+)$/;
+function isCommitExecutionMode(value) {
+    return value === 'direct' || value === 'orchestrated';
+}
+function gitText(repoRoot, args) {
+    return execFileSync('git', [...args], {
+        cwd: repoRoot,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe']
+    }).trim();
+}
+function canonicalRepositoryRoot(cwd) {
+    return gitText(cwd, ['rev-parse', '--show-toplevel']);
+}
+function failure(input, mode, taskId, code, message, status = 'failed', snapshot = null) {
+    return {
+        status,
+        changed: false,
+        result: status,
+        taskId,
+        mode,
+        warnings: [],
+        snapshot: snapshot ?? inspectGitWorkflow(input.cwd).snapshot,
+        operations: [],
+        error: { code, message }
+    };
+}
+function warning(code, message, retryable, step, target, severity) {
+    return { code, message, retryable, step, target, severity };
+}
+function resolveBoundTask(input) {
+    const mode = input.mode ?? 'direct';
+    if (input.taskRef !== undefined) {
+        const resolved = resolveTaskRef(input.taskRef, { repoRoot: input.cwd });
+        if (!resolved.ok)
+            return {
+                kind: 'error',
+                result: failure(input, mode, resolved.taskId, resolved.code, resolved.message)
+            };
+        return boundTask(input, resolved.taskId, resolved.taskDir, resolved.taskMdPath, resolved.repoRoot, resolved.state);
+    }
+    const context = resolveTaskContext(undefined, { repoRoot: input.cwd });
+    if (context.ok)
+        return boundTask(input, context.taskId, context.taskDir, context.taskMdPath, context.repoRoot, context.state);
+    if (context.code === 'TASK_CONTEXT_NOT_FOUND')
+        return { kind: 'none' };
+    return {
+        kind: 'error',
+        result: failure(input, mode, context.taskId, context.code, context.message)
+    };
+}
+function boundTask(input, taskId, taskDir, taskMdPath, repoRoot, state) {
+    let branch;
+    try {
+        const frontmatter = parseTaskFrontmatter(fs.readFileSync(taskMdPath, 'utf8'));
+        branch = frontmatter.branch ?? '';
+    }
+    catch (error) {
+        return {
+            kind: 'error',
+            result: failure(input, input.mode ?? 'direct', taskId, 'TASK_CONTEXT_UNREADABLE', error instanceof Error ? error.message : String(error))
+        };
+    }
+    if (!branch)
+        return {
+            kind: 'error',
+            result: failure(input, input.mode ?? 'direct', taskId, 'TASK_CONTEXT_UNREADABLE', 'task branch is missing')
+        };
+    return { kind: 'bound', task: { repoRoot, taskId, taskDir, taskMdPath, state, branch } };
+}
+function validateCommon(input, branch) {
+    if (!input.message.trim())
+        return { code: 'GIT_COMMIT_INPUT_INVALID', message: 'Commit message is required' };
+    if (input.paths.length === 0 && !input.push)
+        return { code: 'GIT_COMMIT_INPUT_INVALID', message: 'At least one explicit path is required unless this is a push-only retry' };
+    if (!/^[a-f0-9]{40,64}$/.test(input.expectedHead))
+        return { code: 'GIT_HEAD_EXPECTATION_REQUIRED', message: 'A valid expected HEAD is required' };
+    if (!/^[a-f0-9]{40,64}$/.test(input.expectedTree))
+        return { code: 'GIT_TREE_EXPECTATION_REQUIRED', message: 'A valid expected tree is required' };
+    if (input.paths.some((candidate) => !candidate || candidate.startsWith('/') || candidate.split(/[\\/]/).includes('..'))) {
+        return { code: 'GIT_COMMIT_INPUT_INVALID', message: 'Commit paths must stay inside the repository' };
+    }
+    if (input.paths.some((candidate) => /(^|\/)(?:\.env|credentials\.json|id_rsa)(?:$|\/)/i.test(candidate))) {
+        return { code: 'GIT_COMMIT_INPUT_INVALID', message: 'Sensitive paths cannot be committed' };
+    }
+    if (branch !== null && branch === '')
+        return { code: 'GIT_BRANCH_INVALID', message: 'A named branch is required' };
+    if (input.push) {
+        if (!input.push.remote || input.push.refs.length !== 1)
+            return { code: 'GIT_PUSH_INPUT_INVALID', message: 'Push requires one remote and one ref' };
+        const ref = input.push.refs[0] ?? '';
+        if (!HEAD_REF.test(ref) || HEAD_REF.exec(ref)?.[1] !== branch) {
+            return { code: 'GIT_PUSH_INPUT_INVALID', message: 'Push ref must be the current full heads ref' };
+        }
+    }
+    return null;
+}
+function validateOrchestrated(input, task) {
+    if (!input.agent)
+        return { error: { code: 'ORCHESTRATION_PROVENANCE_MISMATCH', message: 'orchestrated commit requires an agent' } };
+    const planned = planOrchestrationStageCompletion(task.taskId, {
+        stage: 'commit',
+        round: 1,
+        artifact: 'commit',
+        role: 'executor',
+        agent: input.agent
+    }, { repoRoot: task.repoRoot });
+    const run = planned.result.run;
+    if (!planned.plan
+        || !run
+        || run.status !== 'running'
+        || !run.commitAuthorization.issuedAt
+        || run.commitAuthorization.consumedAt)
+        return {
+            error: {
+                code: planned.result.error?.code ?? 'ORCHESTRATION_PROVENANCE_MISMATCH',
+                message: planned.result.error?.message ?? 'orchestrated commit requires one matching activated commit delegation'
+            }
+        };
+    return { plan: planned.plan };
+}
+function syncTaskCommit(input, task, committedHead) {
+    let content;
+    try {
+        content = fs.readFileSync(task.taskMdPath, 'utf8');
+        const activity = locateActivityLog(content);
+        if (!activity)
+            return warning('TASK_STATUS_SYNC_FAILED', 'task has no unique Activity Log section', true, 'task', task.taskId, 'ACTION_REQUIRED');
+        const metadata = captureTaskWriteMetadata();
+        const commitNote = gitText(task.repoRoot, ['show', '-s', '--format=%h %s', committedHead]);
+        const alreadyLogged = activity.entries.some((entry) => entry.step === 'Commit' && entry.note === commitNote);
+        const mutations = [];
+        if (!alreadyLogged)
+            mutations.push({
+                kind: 'section',
+                aliases: ['活动日志', 'Activity Log'],
+                heading: activity.heading,
+                body: appendActivityEntry(activity, { time: metadata.timestamp, step: 'Commit', agent: input.agent, note: commitNote })
+            });
+        const frontmatter = { assigned_to: input.agent };
+        mutations.push({ kind: 'frontmatter', set: frontmatter });
+        if (mutations.length === 0)
+            return null;
+        const written = writeTask({
+            taskRef: task.taskId,
+            expectedState: 'active',
+            mutations
+        }, { repoRoot: task.repoRoot, metadataProvider: () => metadata });
+        if (written.status === 'failed')
+            return warning('TASK_STATUS_SYNC_FAILED', written.error.message, true, 'task', task.taskId, 'ACTION_REQUIRED');
+        return null;
+    }
+    catch (error) {
+        return warning('TASK_STATUS_SYNC_FAILED', error instanceof Error ? error.message : String(error), true, 'task', task.taskId, 'ACTION_REQUIRED');
+    }
+}
+function executeUnlocked(input, task, mode) {
+    const inspected = inspectGitWorkflow(input.cwd);
+    if (!inspected.snapshot)
+        return failure(input, mode, task?.taskId ?? null, 'GIT_INSPECT_FAILED', 'Unable to inspect Git repository');
+    const branch = inspected.snapshot.branch;
+    const commonError = validateCommon(input, branch);
+    if (commonError)
+        return failure(input, mode, task?.taskId ?? null, commonError.code, commonError.message, 'blocked', inspected.snapshot);
+    if (task && task.state !== 'active')
+        return failure(input, mode, task.taskId, 'TASK_STATE_INVALID', 'task-bound commit requires an active task', 'blocked', inspected.snapshot);
+    if (task && task.branch !== branch)
+        return failure(input, mode, task.taskId, 'GIT_BRANCH_MISMATCH', `Task branch '${task.branch}' does not match current branch '${branch}'`, 'blocked', inspected.snapshot);
+    if (task && !input.agent)
+        return failure(input, mode, task.taskId, 'COMMIT_AGENT_REQUIRED', 'task-bound commit requires an agent', 'blocked', inspected.snapshot);
+    const orchestrationValidation = mode === 'orchestrated'
+        ? (task
+            ? validateOrchestrated(input, task)
+            : { error: { code: 'ORCHESTRATION_TASK_REQUIRED', message: 'orchestrated commit requires a task context' } })
+        : null;
+    if (orchestrationValidation && 'error' in orchestrationValidation) {
+        const error = orchestrationValidation.error;
+        return failure(input, mode, task?.taskId ?? null, error.code, error.message, 'blocked', inspected.snapshot);
+    }
+    const orchestrationCompletion = orchestrationValidation && 'plan' in orchestrationValidation
+        ? orchestrationValidation.plan
+        : null;
+    const committed = input.paths.length === 0
+        ? (() => {
+            if (inspected.snapshot.worktree.length > 0 || inspected.snapshot.staged.length > 0)
+                return {
+                    status: 'failed',
+                    changed: false,
+                    snapshot: inspected.snapshot,
+                    operations: [],
+                    error: { code: 'GIT_COMMIT_INPUT_INVALID', message: 'Push-only retry requires a clean working tree' }
+                };
+            if (inspected.snapshot.head !== input.expectedHead)
+                return {
+                    status: 'failed',
+                    changed: false,
+                    snapshot: inspected.snapshot,
+                    operations: [],
+                    error: { code: 'GIT_HEAD_MISMATCH', message: `Expected HEAD ${input.expectedHead}, received ${inspected.snapshot.head}` }
+                };
+            const currentTree = gitText(input.cwd, ['rev-parse', 'HEAD^{tree}']);
+            if (currentTree !== input.expectedTree)
+                return {
+                    status: 'failed',
+                    changed: false,
+                    snapshot: inspected.snapshot,
+                    operations: [],
+                    error: { code: 'GIT_TREE_MISMATCH', message: `Expected current tree ${input.expectedTree}, received ${currentTree}` }
+                };
+            return {
+                status: 'no-op',
+                changed: false,
+                snapshot: inspected.snapshot,
+                operations: [{ name: 'commit', status: 'no-op' }],
+                error: null
+            };
+        })()
+        : commitExplicitPaths({
+            cwd: input.cwd,
+            paths: input.paths,
+            message: input.message,
+            expectedHead: input.expectedHead,
+            expectedTree: input.expectedTree
+        });
+    if (committed.status === 'failed')
+        return {
+            ...committed,
+            result: 'failed',
+            taskId: task?.taskId ?? null,
+            mode,
+            warnings: [],
+            snapshot: committed.snapshot
+        };
+    const warnings = [];
+    if (orchestrationCompletion) {
+        try {
+            commitOrchestrationStageCompletion(orchestrationCompletion);
+        }
+        catch (error) {
+            warnings.push(warning('ORCHESTRATION_COMPLETION_FAILED', error instanceof Error ? error.message : String(error), true, 'orchestration', task?.taskId ?? 'orchestration', 'ACTION_REQUIRED'));
+        }
+    }
+    let status = committed.status;
+    let result = committed.status === 'applied' ? 'committed' : 'no_op';
+    if (input.push) {
+        const target = `${input.push.remote}:${input.push.refs[0]}`;
+        const decision = commitPushDecision({ branch, automatic: input.push.automatic }, target);
+        if (!decision.shouldPush) {
+            warnings.push(decision.warning);
+        }
+        else {
+            const pushed = pushGitRefs({
+                cwd: input.cwd,
+                remote: input.push.remote,
+                refs: input.push.refs,
+                expectedSha: committed.snapshot?.head ?? gitText(input.cwd, ['rev-parse', 'HEAD'])
+            });
+            if (pushed.status !== 'applied')
+                warnings.push(warning('COMMIT_PUSH_FAILED', pushed.error?.message ?? 'Git push failed', true, 'push', target, 'ACTION_REQUIRED'));
+        }
+    }
+    if (warnings.length > 0) {
+        status = 'applied';
+        result = 'committed_with_warnings';
+    }
+    if (task && (committed.status === 'applied' || committed.status === 'no-op')) {
+        const taskWarning = syncTaskCommit(input, task, committed.snapshot?.head ?? gitText(task.repoRoot, ['rev-parse', 'HEAD']));
+        if (taskWarning) {
+            warnings.push(taskWarning);
+            status = 'applied';
+            result = 'committed_with_warnings';
+        }
+    }
+    return {
+        status,
+        changed: committed.changed,
+        result,
+        taskId: task?.taskId ?? null,
+        mode,
+        warnings: mergeOperationWarnings(warnings),
+        snapshot: committed.snapshot,
+        operations: committed.operations,
+        error: null
+    };
+}
+function executeCommitOperation(input) {
+    if (input.mode !== undefined && !isCommitExecutionMode(input.mode))
+        return {
+            status: 'blocked',
+            changed: false,
+            result: 'blocked',
+            taskId: null,
+            mode: 'direct',
+            warnings: [],
+            snapshot: null,
+            operations: [],
+            error: { code: 'COMMIT_MODE_INVALID', message: 'commit mode must be direct or orchestrated' }
+        };
+    const mode = input.mode ?? 'direct';
+    let normalizedInput;
+    try {
+        normalizedInput = { ...input, cwd: canonicalRepositoryRoot(input.cwd) };
+    }
+    catch (error) {
+        return failure(input, mode, null, 'GIT_INSPECT_FAILED', error instanceof Error ? error.message : 'Unable to resolve Git repository root', 'blocked');
+    }
+    const resolved = resolveBoundTask(normalizedInput);
+    if (resolved.kind === 'error')
+        return resolved.result;
+    const task = resolved.kind === 'bound' ? resolved.task : null;
+    if (mode === 'orchestrated' && !task)
+        return failure(normalizedInput, mode, null, 'ORCHESTRATION_TASK_REQUIRED', 'orchestrated commit requires a task context', 'blocked');
+    try {
+        return task
+            ? withRepositoryMutationLock(normalizedInput.cwd, () => withTaskExecutionLock(normalizedInput.cwd, task.taskId, 'commit-operation', () => executeUnlocked(normalizedInput, task, mode)))
+            : withRepositoryMutationLock(normalizedInput.cwd, () => executeUnlocked(normalizedInput, null, mode));
+    }
+    catch (error) {
+        const code = error instanceof TaskExecutionLockError ? error.code : 'COMMIT_OPERATION_FAILED';
+        return failure(normalizedInput, mode, task?.taskId ?? null, code, error instanceof Error ? error.message : String(error), 'blocked');
+    }
+}
+export { executeCommitOperation };
+//# sourceMappingURL=commit-operation.js.map

package/dist/lib/task/commit-policy.js

@@ -0,0 +1,18 @@
+function commitPushDecision(policy, target) {
+    const branch = policy.branch.trim();
+    if (policy.automatic && (branch === 'main' || branch === 'master'))
+        return {
+            shouldPush: false,
+            warning: {
+                code: 'COMMIT_AUTOPUSH_PROTECTED_BRANCH',
+                message: `Automatic commit push is disabled for protected branch '${branch}'`,
+                retryable: false,
+                step: 'push',
+                target,
+                severity: 'IMPORTANT'
+            }
+        };
+    return { shouldPush: true, warning: null };
+}
+export { commitPushDecision };
+//# sourceMappingURL=commit-policy.js.map

package/dist/lib/task/delegation-receipts.js

@@ -1,5 +1,249 @@
 import { randomUUID } from 'node:crypto';
+import { isAgentClientId } from '../agent-clients/types.js';
 import { normalizeAgentToken } from '../agent-clients/tokens.js';
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function hasExactKeys(value, required, optional = []) {
+    if (!isRecord(value))
+        return false;
+    const keys = Object.keys(value);
+    const allowed = new Set([...required, ...optional]);
+    return required.every((key) => Object.prototype.hasOwnProperty.call(value, key))
+        && keys.every((key) => allowed.has(key));
+}
+function exactText(value) {
+    return typeof value === 'string' && value.length > 0 && value.trim() === value;
+}
+function validCodexBuildMetadata(value) {
+    return Number.isSafeInteger(value.protocolVersion) && value.protocolVersion > 0
+        && exactText(value.packageVersion)
+        && exactText(value.internalExecutableBuildHash)
+        && exactText(value.lifecycleContractHash);
+}
+function nullableText(value) {
+    return value === null || exactText(value);
+}
+function nullableSafeInteger(value) {
+    return value === null || (Number.isSafeInteger(value) && value >= 0);
+}
+const LIFECYCLE_PROVENANCE_KEYS = [
+    'protocolVersion', 'packageVersion', 'internalExecutableBuildHash', 'lifecycleContractHash',
+    'hookDefinitionHash', 'hookSource', 'hookSourcePathDigest', 'hookSourceHash',
+    'capabilitySessionId', 'capabilityTurnId', 'capabilityToolUseId',
+    'controllerInstanceDigest', 'controlGeneration'
+];
+function isDelegationLifecycleProvenance(value) {
+    if (!hasExactKeys(value, LIFECYCLE_PROVENANCE_KEYS))
+        return false;
+    return Number.isSafeInteger(value.protocolVersion)
+        && value.protocolVersion > 0
+        && exactText(value.packageVersion)
+        && exactText(value.internalExecutableBuildHash)
+        && exactText(value.lifecycleContractHash)
+        && exactText(value.hookDefinitionHash)
+        && ['project', 'managed', 'isolated-user'].includes(value.hookSource)
+        && exactText(value.hookSourcePathDigest)
+        && exactText(value.hookSourceHash)
+        && exactText(value.capabilitySessionId)
+        && exactText(value.capabilityTurnId)
+        && exactText(value.capabilityToolUseId)
+        && nullableText(value.controllerInstanceDigest)
+        && nullableText(value.controlGeneration);
+}
+const HOST_EVIDENCE_REQUIRED_KEYS = [
+    'kind', 'hookDefinitionHash', 'startRevision', 'stopRevision', 'consumer', 'consumedAt'
+];
+const HOST_EVIDENCE_OPTIONAL_KEYS = [
+    'protocolVersion', 'packageVersion', 'internalExecutableBuildHash', 'lifecycleContractHash',
+    'hookSource', 'hookSourcePathDigest', 'hookSourceHash', 'capabilitySessionId',
+    'capabilityTurnId', 'capabilityToolUseId', 'spawnToolUseId', 'spawnObservedAt',
+    'controllerInstanceDigest', 'controlGeneration'
+];
+function isDelegationHostEvidence(value) {
+    if (!hasExactKeys(value, HOST_EVIDENCE_REQUIRED_KEYS, HOST_EVIDENCE_OPTIONAL_KEYS))
+        return false;
+    if (!['codex-lifecycle-v1', 'codex-lifecycle-v2'].includes(value.kind))
+        return false;
+    if (!exactText(value.hookDefinitionHash)
+        || !Number.isSafeInteger(value.startRevision) || value.startRevision < 1
+        || !nullableSafeInteger(value.stopRevision)
+        || !nullableText(value.consumer)
+        || !nullableText(value.consumedAt))
+        return false;
+    if (value.kind === 'codex-lifecycle-v1')
+        return true;
+    return Number.isSafeInteger(value.protocolVersion)
+        && value.protocolVersion > 0
+        && exactText(value.packageVersion)
+        && exactText(value.internalExecutableBuildHash)
+        && exactText(value.lifecycleContractHash)
+        && ['project', 'managed', 'isolated-user'].includes(value.hookSource)
+        && exactText(value.hookSourcePathDigest)
+        && exactText(value.hookSourceHash)
+        && exactText(value.capabilitySessionId)
+        && exactText(value.capabilityTurnId)
+        && exactText(value.spawnToolUseId)
+        && exactText(value.spawnObservedAt)
+        && nullableText(value.controllerInstanceDigest)
+        && nullableText(value.controlGeneration);
+}
+function hasCurrentCodexEvidence(receipt) {
+    const provenance = receipt.lifecycleProvenance;
+    if (!provenance)
+        return false;
+    const activated = ['activated', 'stage-completed', 'sealed', 'consumed'].includes(receipt.status);
+    if (!activated)
+        return receipt.hostEvidence === null;
+    const host = receipt.hostEvidence;
+    if (host?.kind !== 'codex-lifecycle-v2'
+        || host.protocolVersion !== provenance.protocolVersion
+        || host.hookDefinitionHash !== provenance.hookDefinitionHash
+        || host.hookSource !== provenance.hookSource
+        || host.hookSourcePathDigest !== provenance.hookSourcePathDigest
+        || host.hookSourceHash !== provenance.hookSourceHash
+        || host.capabilitySessionId !== provenance.capabilitySessionId
+        || host.capabilityTurnId !== provenance.capabilityTurnId
+        || host.controllerInstanceDigest !== provenance.controllerInstanceDigest
+        || host.controlGeneration !== provenance.controlGeneration
+        || receipt.parentId !== provenance.capabilitySessionId
+        || host.spawnToolUseId === provenance.capabilityToolUseId)
+        return false;
+    const spawnObservedAt = Date.parse(host.spawnObservedAt ?? '');
+    const spawnDispatchedAt = Date.parse(receipt.spawnDispatchedAt ?? '');
+    const activationDeadlineAt = Date.parse(receipt.activationDeadlineAt ?? '');
+    if (!Number.isFinite(spawnObservedAt)
+        || !Number.isFinite(spawnDispatchedAt)
+        || !Number.isFinite(activationDeadlineAt)
+        || spawnObservedAt < spawnDispatchedAt
+        || spawnObservedAt > activationDeadlineAt)
+        return false;
+    if (['sealed', 'consumed'].includes(receipt.status)) {
+        return Number.isSafeInteger(host.stopRevision)
+            && host.stopRevision > host.startRevision
+            && host.consumer === receipt.id
+            && exactText(host.consumedAt);
+    }
+    return host.stopRevision === null && host.consumer === null && host.consumedAt === null;
+}
+const RECEIPT_KEYS = [
+    'id', 'taskId', 'runId', 'role', 'stage', 'round', 'artifact', 'client',
+    'requestedModel', 'requestedReasoningEffort', 'actualModel', 'actualReasoningEffort',
+    'modelFallbackReason', 'reasoningEffortFallbackReason', 'parentId', 'childId',
+    'spawnMode', 'agent', 'status', 'workspaceSnapshotScope', 'lifecycleProvenance',
+    'hostEvidence', 'beforeFingerprint', 'afterFingerprint', 'changedPaths', 'createdAt',
+    'preparedMonotonicMs', 'spawnDispatchMonotonicMs', 'activationDeadlineMonotonicMs',
+    'spawnDispatchedAt', 'activationDeadlineAt', 'startEvidenceMonotonicMs',
+    'activatedMonotonicMs', 'activatedAt', 'sealedAt', 'consumedAt'
+];
+function hasStatusBoundEvidence(receipt) {
+    const dispatchFields = [
+        receipt.spawnDispatchMonotonicMs,
+        receipt.activationDeadlineMonotonicMs,
+        receipt.spawnDispatchedAt,
+        receipt.activationDeadlineAt
+    ];
+    const dispatchEmpty = dispatchFields.every((field) => field === null);
+    const dispatchComplete = dispatchFields.every((field) => field !== null);
+    if (!dispatchEmpty && !dispatchComplete)
+        return false;
+    const beforeActivation = ['prepared', 'aborted', 'expired'].includes(receipt.status);
+    if (beforeActivation) {
+        return receipt.parentId === null
+            && receipt.childId === null
+            && receipt.spawnMode === null
+            && receipt.actualModel === null
+            && receipt.actualReasoningEffort === null
+            && receipt.modelFallbackReason === null
+            && receipt.reasoningEffortFallbackReason === null
+            && receipt.agent === null
+            && receipt.hostEvidence === null
+            && receipt.startEvidenceMonotonicMs === null
+            && receipt.activatedMonotonicMs === null
+            && receipt.activatedAt === null
+            && receipt.afterFingerprint === null
+            && receipt.changedPaths.length === 0
+            && receipt.sealedAt === null
+            && receipt.consumedAt === null;
+    }
+    if (!dispatchComplete
+        || !exactText(receipt.parentId)
+        || !exactText(receipt.childId)
+        || receipt.parentId === receipt.childId
+        || receipt.startEvidenceMonotonicMs === null
+        || receipt.activatedMonotonicMs === null
+        || !exactText(receipt.activatedAt))
+        return false;
+    if (receipt.status === 'activated') {
+        return receipt.agent === null
+            && receipt.afterFingerprint === null
+            && receipt.changedPaths.length === 0
+            && receipt.sealedAt === null
+            && receipt.consumedAt === null;
+    }
+    if (!exactText(receipt.agent)
+        || normalizeAgentToken(receipt.agent) !== normalizeAgentToken(receipt.client))
+        return false;
+    if (receipt.status === 'stage-completed') {
+        return receipt.afterFingerprint === null
+            && receipt.changedPaths.length === 0
+            && receipt.sealedAt === null
+            && receipt.consumedAt === null;
+    }
+    if (!exactText(receipt.afterFingerprint) || !exactText(receipt.sealedAt))
+        return false;
+    return receipt.status === 'sealed'
+        ? receipt.consumedAt === null
+        : receipt.status === 'consumed' && exactText(receipt.consumedAt);
+}
+function isDelegationReceipt(value) {
+    if (!hasExactKeys(value, RECEIPT_KEYS))
+        return false;
+    const structurallyValid = exactText(value.id)
+        && exactText(value.taskId)
+        && exactText(value.runId)
+        && ['executor', 'reviewer'].includes(value.role)
+        && ['analysis', 'review-analysis', 'plan', 'review-plan', 'code', 'review-code', 'commit'].includes(value.stage)
+        && Number.isSafeInteger(value.round)
+        && value.round > 0
+        && exactText(value.artifact)
+        && isAgentClientId(value.client)
+        && exactText(value.requestedModel)
+        && exactText(value.requestedReasoningEffort)
+        && nullableText(value.actualModel)
+        && nullableText(value.actualReasoningEffort)
+        && nullableText(value.modelFallbackReason)
+        && nullableText(value.reasoningEffortFallbackReason)
+        && nullableText(value.parentId)
+        && nullableText(value.childId)
+        && nullableText(value.spawnMode)
+        && nullableText(value.agent)
+        && ['prepared', 'activated', 'stage-completed', 'sealed', 'consumed', 'aborted', 'expired'].includes(value.status)
+        && value.workspaceSnapshotScope === 'task'
+        && (value.lifecycleProvenance === null || isDelegationLifecycleProvenance(value.lifecycleProvenance))
+        && (value.hostEvidence === null || isDelegationHostEvidence(value.hostEvidence))
+        && exactText(value.beforeFingerprint)
+        && nullableText(value.afterFingerprint)
+        && Array.isArray(value.changedPaths)
+        && value.changedPaths.every(exactText)
+        && exactText(value.createdAt)
+        && nullableSafeInteger(value.preparedMonotonicMs)
+        && value.preparedMonotonicMs !== null
+        && nullableSafeInteger(value.spawnDispatchMonotonicMs)
+        && nullableSafeInteger(value.activationDeadlineMonotonicMs)
+        && nullableText(value.spawnDispatchedAt)
+        && nullableText(value.activationDeadlineAt)
+        && nullableSafeInteger(value.startEvidenceMonotonicMs)
+        && nullableSafeInteger(value.activatedMonotonicMs)
+        && nullableText(value.activatedAt)
+        && nullableText(value.sealedAt)
+        && nullableText(value.consumedAt);
+    if (!structurallyValid)
+        return false;
+    const receipt = value;
+    return hasStatusBoundEvidence(receipt)
+        && (receipt.client !== 'codex' || hasCurrentCodexEvidence(receipt));
+}
 const MANAGED_AGENTS = {
     'agent-infra-lifecycle-executor': 'executor',
     'agent-infra-lifecycle-reviewer': 'reviewer'
@@ -53,7 +297,7 @@ function dispatchDelegation(receipt, options = {}) {
     }
     const monotonic = (options.monotonicNow ?? (() => Number(process.hrtime.bigint() / 1000000n)))();
     const dispatchedAt = (options.now ?? (() => new Date().toISOString()))();
-    const window = options.activationWindowMs ?? 15_000;
+    const window = options.activationWindowMs ?? 60_000;
     return { ok: true, receipt: Object.freeze({
             ...receipt,
             spawnDispatchMonotonicMs: monotonic,
@@ -138,9 +382,6 @@ function activateDelegation(receipt, event, options = {}) {
         const activationDeadlineAt = Date.parse(receipt.activationDeadlineAt);
         if (!expected
             || event.hostEvidence.protocolVersion !== expected.protocolVersion
-            || event.hostEvidence.packageVersion !== expected.packageVersion
-            || event.hostEvidence.internalExecutableBuildHash !== expected.internalExecutableBuildHash
-            || event.hostEvidence.lifecycleContractHash !== expected.lifecycleContractHash
             || event.hostEvidence.hookDefinitionHash !== expected.hookDefinitionHash
             || event.hostEvidence.hookSource !== expected.hookSource
             || event.hostEvidence.hookSourcePathDigest !== expected.hookSourcePathDigest
@@ -154,7 +395,8 @@ function activateDelegation(receipt, event, options = {}) {
             || spawnObservedAt > activationDeadlineAt
             || event.parentId !== expected.capabilitySessionId
             || (event.hostEvidence.controllerInstanceDigest ?? null) !== expected.controllerInstanceDigest
-            || (event.hostEvidence.controlGeneration ?? null) !== expected.controlGeneration)
+            || (event.hostEvidence.controlGeneration ?? null) !== expected.controlGeneration
+            || !validCodexBuildMetadata(event.hostEvidence))
             return fail('DELEGATION_HOST_EVIDENCE_INVALID', 'Codex lifecycle provenance does not match the prepared receipt');
     }
     return { ok: true, receipt: Object.freeze({
@@ -252,5 +494,5 @@ function consumeDelegation(receipt, options = {}) {
             consumedAt: (options.now ?? (() => new Date().toISOString()))()
         }) };
 }
-export { activateDelegation, abortPreparedDelegation, completeDelegationStage, consumeDelegation, dispatchDelegation, foldBlankToNull, managedDelegationRole, prepareDelegation, sealDelegation };
+export { activateDelegation, abortPreparedDelegation, completeDelegationStage, consumeDelegation, dispatchDelegation, foldBlankToNull, isDelegationReceipt, managedDelegationRole, prepareDelegation, sealDelegation };
 //# sourceMappingURL=delegation-receipts.js.map