@fitlab-ai/agent-infra 0.9.5 → 0.9.7

package/lib/task/commit-finalization.ts

@@ -12,7 +12,7 @@ import type { CommitAttempt } from './activity-log.ts';
 import { commitIntentPath, digest, readCommitIntent } from './commit-intent.ts';
 import type { CommitIntent } from './commit-intent.ts';
 import { parseTypedTaskFrontmatter } from './frontmatter.ts';
-import { parseReviewSummary } from './review-artifacts.ts';
+import { artifactName, maxRound, parseReviewSummary } from './review-artifacts.ts';
 import {
   extractReviewBaseline,
   extractReviewedSnapshotTree,
@@ -43,6 +43,7 @@ type CommitFinalizationInspection = Readonly<{
   currentHead: string;
   committedHead: string | null;
   commitNote: string | null;
+  activityNote: string | null;
   needsAnchor: boolean;
   needsLog: boolean;
   intent: CommitIntent | null;
@@ -87,6 +88,28 @@ function isAncestor(repoRoot: string, ancestor: string, descendant: string): boo
   }).status === 0;
 }
 
+function hasMatchingApprovedReview(
+  taskDir: string,
+  beforeRound: number,
+  baseline: string,
+  tree: string
+): boolean {
+  const entries = fs.readdirSync(taskDir);
+  for (let round = Math.min(beforeRound - 1, maxRound(entries, 'review-code')); round >= 1; round -= 1) {
+    const file = path.join(taskDir, artifactName('review-code', round));
+    if (!fs.existsSync(file)) continue;
+    const content = fs.readFileSync(file, 'utf8');
+    const summary = parseReviewSummary(content);
+    if (
+      summary.ok
+      && summary.summary.verdict === 'Approved'
+      && extractReviewBaseline(content) === baseline
+      && extractReviewedSnapshotTree(content) === tree
+    ) return true;
+  }
+  return false;
+}
+
 function outcome(
   disposition: CommitFinalizationDisposition,
   overrides: Partial<CommitFinalizationInspection> = {}
@@ -98,6 +121,7 @@ function outcome(
     currentHead: '',
     committedHead: null,
     commitNote: null,
+    activityNote: null,
     needsAnchor: false,
     needsLog: false,
     intent: null,
@@ -212,6 +236,12 @@ function inspectCommitFinalization(
     });
   }
 
+  const commitNote = git(repoRoot, ['show', '-s', '--format=%h%x20%s', intent.committedHead]);
+  const matchingDone = commitRows.filter((row) => row.done !== '' && row.note === commitNote);
+  const pushOnlyRetry = intent.phase === 'pushed'
+    && intent.baselineHead === intent.committedHead
+    && matchingDone.length === 1
+    && openRows.length === 1;
   const review = findAuthoritativeReviewCodeArtifact(taskDir);
   let needsAnchor = false;
   if (review.ok && review.path) {
@@ -228,7 +258,16 @@ function inspectCommitFinalization(
       return invalid('authoritative review-code evidence is not a valid approved snapshot', currentHead, 'COMMIT_FINALIZATION_EVIDENCE_INVALID', shared);
     }
     const committedTree = git(repoRoot, ['rev-parse', `${intent.committedHead}^{tree}`]);
-    if (reviewBaseline !== intent.baselineHead || reviewTree !== committedTree) {
+    const matchingCurrentReview = reviewBaseline === intent.baselineHead && reviewTree === committedTree;
+    if (
+      !matchingCurrentReview
+      && !hasMatchingApprovedReview(
+        taskDir,
+        review.round,
+        intent.baselineHead,
+        committedTree
+      )
+    ) {
       return outcome('conflict', {
         ...shared,
         code: 'COMMIT_FINALIZATION_CONFLICT',
@@ -237,18 +276,16 @@ function inspectCommitFinalization(
     }
 
     const anchor = String(metadata.last_reviewed_commit ?? '').trim();
-    if (anchor && anchor !== intent.committedHead) {
+    if (anchor && anchor !== intent.committedHead && anchor !== intent.baselineHead) {
       return outcome('conflict', {
         ...shared,
         code: 'COMMIT_FINALIZATION_CONFLICT',
         message: 'task review anchor conflicts with the committed intent'
       });
     }
-    needsAnchor = anchor === '';
+    needsAnchor = anchor !== intent.committedHead;
   }
-  const commitNote = git(repoRoot, ['show', '-s', '--format=%h%x20%s', intent.committedHead]);
-  const matchingDone = commitRows.filter((row) => row.done !== '' && row.note === commitNote);
-  const needsLog = matchingDone.length === 0 && openRows.length === 1;
+  const needsLog = (matchingDone.length === 0 && openRows.length === 1) || pushOnlyRetry;
   if (!(needsLog || (matchingDone.length === 1 && openRows.length === 0))) {
     return outcome('conflict', {
       ...shared,
@@ -261,6 +298,7 @@ function inspectCommitFinalization(
     ...shared,
     message: 'commit finalization can be recovered',
     commitNote,
+    activityNote: pushOnlyRetry ? `Pushed ${commitNote}` : commitNote,
     needsAnchor,
     needsLog
   });
@@ -272,7 +310,12 @@ function planCommitTaskFinalization(
   agent: string,
   timestamp: string
 ): CommitTaskFinalizationPlan {
-  if (inspection.disposition !== 'recoverable' || !inspection.committedHead || !inspection.commitNote) {
+  if (
+    inspection.disposition !== 'recoverable'
+    || !inspection.committedHead
+    || !inspection.commitNote
+    || !inspection.activityNote
+  ) {
     throw new Error('commit finalization task mutations require a recoverable inspection');
   }
   const taskContent = fs.readFileSync(path.join(taskDir, 'task.md'), 'utf8');
@@ -293,7 +336,7 @@ function planCommitTaskFinalization(
         time: timestamp,
         step: 'Commit',
         agent,
-        note: inspection.commitNote
+        note: inspection.activityNote
       })
     });
   }

package/lib/task/create.ts

@@ -231,6 +231,14 @@ function assertRealDirectory(directory: string, code: string): void {
   if (!stat.isDirectory() || stat.isSymbolicLink()) throw new Error(code);
 }
 
+function ensureRealDirectory(directory: string, code: string): void {
+  if (fs.existsSync(directory)) {
+    assertRealDirectory(directory, code);
+    return;
+  }
+  fs.mkdirSync(directory, { mode: 0o700 });
+}
+
 function withCreateLock<T>(repoRoot: string, workspaceRoot: string, operation: () => T): T {
   const lockRoot = path.join(workspaceRoot, '.task-create.lock');
   fs.mkdirSync(lockRoot, { recursive: true, mode: 0o700 });
@@ -289,8 +297,9 @@ function createLocalTask(value: unknown, options: LocalTaskCreateOptions): Local
   const repoRoot = fs.realpathSync.native(options.repoRoot);
   const workspaceRoot = path.join(repoRoot, '.agents', 'workspace');
   const activeRoot = path.join(workspaceRoot, 'active');
-  assertRealDirectory(workspaceRoot, 'TASK_CREATE_WORKSPACE_INVALID');
-  assertRealDirectory(activeRoot, 'TASK_CREATE_WORKSPACE_INVALID');
+  ensureRealDirectory(path.join(repoRoot, '.agents'), 'TASK_CREATE_WORKSPACE_INVALID');
+  ensureRealDirectory(workspaceRoot, 'TASK_CREATE_WORKSPACE_INVALID');
+  ensureRealDirectory(activeRoot, 'TASK_CREATE_WORKSPACE_INVALID');
   const project = readProject(repoRoot);
   const canonical = canonicalTaskCreateCandidate(candidate);
   const candidateDigest = sha256(canonical);

package/lib/task/delegation-receipts.ts

@@ -6,6 +6,43 @@ import { normalizeAgentToken } from '../agent-clients/tokens.ts';
 type DelegationRole = 'executor' | 'reviewer';
 type DelegationStage = 'analysis' | 'review-analysis' | 'plan' | 'review-plan' | 'code' | 'review-code' | 'commit';
 type DelegationStatus = 'prepared' | 'activated' | 'stage-completed' | 'sealed' | 'consumed' | 'aborted' | 'expired';
+type DelegationHostEvidence = Readonly<{
+  kind: 'codex-lifecycle-v1' | 'codex-lifecycle-v2';
+  hookDefinitionHash: string;
+  startRevision: number;
+  stopRevision: number | null;
+  consumer: string | null;
+  consumedAt: string | null;
+  protocolVersion?: number;
+  packageVersion?: string;
+  internalExecutableBuildHash?: string;
+  lifecycleContractHash?: string;
+  hookSource?: 'project' | 'managed' | 'isolated-user';
+  hookSourcePathDigest?: string;
+  hookSourceHash?: string;
+  capabilitySessionId?: string;
+  capabilityTurnId?: string;
+  capabilityToolUseId?: string;
+  spawnToolUseId?: string;
+  spawnObservedAt?: string;
+  controllerInstanceDigest?: string | null;
+  controlGeneration?: string | null;
+}>;
+type DelegationLifecycleProvenance = Readonly<{
+  protocolVersion: number;
+  packageVersion: string;
+  internalExecutableBuildHash: string;
+  lifecycleContractHash: string;
+  hookDefinitionHash: string;
+  hookSource: 'project' | 'managed' | 'isolated-user';
+  hookSourcePathDigest: string;
+  hookSourceHash: string;
+  capabilitySessionId: string;
+  capabilityTurnId: string;
+  capabilityToolUseId: string;
+  controllerInstanceDigest: string | null;
+  controlGeneration: string | null;
+}>;
 
 type DelegationReceipt = Readonly<{
   id: string;
@@ -28,10 +65,19 @@ type DelegationReceipt = Readonly<{
   agent: string | null;
   status: DelegationStatus;
   workspaceSnapshotScope?: 'task';
+  lifecycleProvenance?: DelegationLifecycleProvenance | null;
+  hostEvidence?: DelegationHostEvidence | null;
   beforeFingerprint: string;
   afterFingerprint: string | null;
   changedPaths: readonly string[];
   createdAt: string;
+  preparedMonotonicMs: number;
+  spawnDispatchMonotonicMs: number | null;
+  activationDeadlineMonotonicMs: number | null;
+  spawnDispatchedAt: string | null;
+  activationDeadlineAt: string | null;
+  startEvidenceMonotonicMs: number | null;
+  activatedMonotonicMs: number | null;
   activatedAt: string | null;
   sealedAt: string | null;
   consumedAt: string | null;
@@ -55,9 +101,10 @@ function fail(code: string, message: string): ReceiptFailure {
 }
 
 function prepareDelegation(
-  input: Omit<DelegationReceipt, 'id' | 'requestedModel' | 'requestedReasoningEffort' | 'actualModel' | 'actualReasoningEffort' | 'modelFallbackReason' | 'reasoningEffortFallbackReason' | 'parentId' | 'childId' | 'spawnMode' | 'agent' | 'status' | 'afterFingerprint' | 'changedPaths' | 'createdAt' | 'activatedAt' | 'sealedAt' | 'consumedAt'> & Readonly<{ requestedModel: string; requestedReasoningEffort: string }>,
-  options: { id?: () => string; now?: () => string } = {}
+  input: Omit<DelegationReceipt, 'id' | 'requestedModel' | 'requestedReasoningEffort' | 'actualModel' | 'actualReasoningEffort' | 'modelFallbackReason' | 'reasoningEffortFallbackReason' | 'parentId' | 'childId' | 'spawnMode' | 'agent' | 'status' | 'hostEvidence' | 'afterFingerprint' | 'changedPaths' | 'createdAt' | 'preparedMonotonicMs' | 'spawnDispatchMonotonicMs' | 'activationDeadlineMonotonicMs' | 'spawnDispatchedAt' | 'activationDeadlineAt' | 'startEvidenceMonotonicMs' | 'activatedMonotonicMs' | 'activatedAt' | 'sealedAt' | 'consumedAt'> & Readonly<{ requestedModel: string; requestedReasoningEffort: string }>,
+  options: { id?: () => string; now?: () => string; monotonicNow?: () => number } = {}
 ): DelegationReceipt {
+  const monotonic = (options.monotonicNow ?? (() => Number(process.hrtime.bigint() / 1_000_000n)))();
   return Object.freeze({
     ...input,
     id: (options.id ?? randomUUID)(),
@@ -70,15 +117,45 @@ function prepareDelegation(
     spawnMode: null,
     agent: null,
     status: 'prepared' as const,
+    hostEvidence: null,
     afterFingerprint: null,
     changedPaths: Object.freeze([]),
     createdAt: (options.now ?? (() => new Date().toISOString()))(),
+    preparedMonotonicMs: monotonic,
+    spawnDispatchMonotonicMs: null,
+    activationDeadlineMonotonicMs: null,
+    spawnDispatchedAt: null,
+    activationDeadlineAt: null,
+    startEvidenceMonotonicMs: null,
+    activatedMonotonicMs: null,
     activatedAt: null,
     sealedAt: null,
     consumedAt: null
   });
 }
 
+function dispatchDelegation(
+  receipt: DelegationReceipt,
+  options: { now?: () => string; monotonicNow?: () => number; activationWindowMs?: number } = {}
+): ReceiptResult {
+  if (receipt.status !== 'prepared') {
+    return fail('DELEGATION_STATE_INVALID', `delegation ${receipt.id} is ${receipt.status}, expected prepared`);
+  }
+  if (receipt.spawnDispatchMonotonicMs != null || receipt.spawnDispatchedAt != null) {
+    return fail('DELEGATION_DISPATCH_REPLAY', `delegation ${receipt.id} was already dispatched`);
+  }
+  const monotonic = (options.monotonicNow ?? (() => Number(process.hrtime.bigint() / 1_000_000n)))();
+  const dispatchedAt = (options.now ?? (() => new Date().toISOString()))();
+  const window = options.activationWindowMs ?? 15_000;
+  return { ok: true, receipt: Object.freeze({
+    ...receipt,
+    spawnDispatchMonotonicMs: monotonic,
+    activationDeadlineMonotonicMs: monotonic + window,
+    spawnDispatchedAt: dispatchedAt,
+    activationDeadlineAt: new Date(Date.parse(dispatchedAt) + window).toISOString()
+  }) };
+}
+
 function activateDelegation(
   receipt: DelegationReceipt,
   event: Readonly<{
@@ -90,12 +167,46 @@ function activateDelegation(
     actualReasoningEffort?: string;
     modelFallbackReason?: string;
     reasoningEffortFallbackReason?: string;
+    hostEvidence?: Readonly<{
+      kind: 'codex-lifecycle-v1' | 'codex-lifecycle-v2';
+      hookDefinitionHash: string;
+      startRevision: number;
+      protocolVersion?: number;
+      packageVersion?: string;
+      internalExecutableBuildHash?: string;
+      lifecycleContractHash?: string;
+      hookSource?: 'project' | 'managed' | 'isolated-user';
+      hookSourcePathDigest?: string;
+      hookSourceHash?: string;
+      capabilitySessionId?: string;
+      capabilityTurnId?: string;
+      capabilityToolUseId?: string;
+      spawnToolUseId?: string;
+      spawnObservedAt?: string;
+      controllerInstanceDigest?: string | null;
+      controlGeneration?: string | null;
+    }>;
   }>,
-  options: { now?: () => string } = {}
+  options: { now?: () => string; monotonicNow?: () => number } = {}
 ): ReceiptResult {
   const managedRole = managedDelegationRole(event.nativeAgent);
   if (!managedRole) return fail('DELEGATION_IGNORED', `subagent '${event.nativeAgent}' is not lifecycle-managed`);
   if (receipt.status !== 'prepared') return fail('DELEGATION_STATE_INVALID', `delegation ${receipt.id} is ${receipt.status}, expected prepared`);
+  if (
+    receipt.spawnDispatchMonotonicMs == null
+    || receipt.spawnDispatchedAt == null
+    || receipt.activationDeadlineAt == null
+    || receipt.activationDeadlineMonotonicMs == null
+    || !Number.isFinite(Date.parse(receipt.spawnDispatchedAt))
+    || !Number.isFinite(Date.parse(receipt.activationDeadlineAt))
+  ) {
+    return fail('DELEGATION_NOT_DISPATCHED', `delegation ${receipt.id} has not reached the native spawn dispatch boundary`);
+  }
+  const monotonic = (options.monotonicNow ?? (() => Number(process.hrtime.bigint() / 1_000_000n)))();
+  const wallNow = Date.parse((options.now ?? (() => new Date().toISOString()))());
+  if (wallNow > Date.parse(receipt.activationDeadlineAt)) {
+    return fail('DELEGATION_ACTIVATION_TIMEOUT', `delegation ${receipt.id} activation evidence arrived after its deadline`);
+  }
   if (managedRole !== receipt.role) return fail('DELEGATION_ROLE_MISMATCH', `managed role ${managedRole} does not match ${receipt.role}`);
   if (!event.parentId || (receipt.parentId !== null && event.parentId !== receipt.parentId) || !event.childId || event.childId === event.parentId) {
     return fail('DELEGATION_IDENTITY_INVALID', 'native parent/child identity does not match the prepared delegation');
@@ -112,6 +223,10 @@ function activateDelegation(
   if (!actualReasoningEffort || actualReasoningEffort.trim() !== actualReasoningEffort) {
     return fail('DELEGATION_REASONING_EFFORT_MISSING', 'native start event must provide a non-empty actual reasoning effort');
   }
+  if (
+    receipt.client === 'codex'
+    && event.hostEvidence?.kind !== 'codex-lifecycle-v2'
+  ) return fail('DELEGATION_HOST_EVIDENCE_REQUIRED', 'Codex activation requires trusted lifecycle-v2 host evidence');
   if (
     actualReasoningEffort !== receipt.requestedReasoningEffort
     && (!event.reasoningEffortFallbackReason || event.reasoningEffortFallbackReason.trim() === '')
@@ -124,6 +239,42 @@ function activateDelegation(
   if (actualReasoningEffort === receipt.requestedReasoningEffort && event.reasoningEffortFallbackReason) {
     return fail('DELEGATION_REASONING_EFFORT_FALLBACK_INVALID', 'reasoning-effort fallback reason is only valid when actual effort differs');
   }
+  if (
+    event.hostEvidence
+    && (
+      receipt.client !== 'codex'
+      || !event.hostEvidence.hookDefinitionHash.trim()
+      || !Number.isSafeInteger(event.hostEvidence.startRevision)
+      || event.hostEvidence.startRevision < 1
+    )
+  ) return fail('DELEGATION_HOST_EVIDENCE_INVALID', 'Codex start evidence reference is invalid');
+  if (event.hostEvidence?.kind === 'codex-lifecycle-v2') {
+    const expected = receipt.lifecycleProvenance;
+    const spawnObservedAt = Date.parse(event.hostEvidence.spawnObservedAt ?? '');
+    const spawnDispatchedAt = Date.parse(receipt.spawnDispatchedAt);
+    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
+      || event.hostEvidence.hookSourceHash !== expected.hookSourceHash
+      || event.hostEvidence.capabilitySessionId !== expected.capabilitySessionId
+      || event.hostEvidence.capabilityTurnId !== expected.capabilityTurnId
+      || !event.hostEvidence.spawnToolUseId?.trim()
+      || event.hostEvidence.spawnToolUseId === expected.capabilityToolUseId
+      || !Number.isFinite(spawnObservedAt)
+      || spawnObservedAt < spawnDispatchedAt
+      || spawnObservedAt > activationDeadlineAt
+      || event.parentId !== expected.capabilitySessionId
+      || (event.hostEvidence.controllerInstanceDigest ?? null) !== expected.controllerInstanceDigest
+      || (event.hostEvidence.controlGeneration ?? null) !== expected.controlGeneration
+    ) return fail('DELEGATION_HOST_EVIDENCE_INVALID', 'Codex lifecycle provenance does not match the prepared receipt');
+  }
   return { ok: true, receipt: Object.freeze({
     ...receipt,
     status: 'activated',
@@ -134,10 +285,28 @@ function activateDelegation(
     actualReasoningEffort,
     modelFallbackReason: event.modelFallbackReason ?? null,
     reasoningEffortFallbackReason: event.reasoningEffortFallbackReason ?? null,
-    activatedAt: (options.now ?? (() => new Date().toISOString()))()
+    hostEvidence: event.hostEvidence ? Object.freeze({
+      ...event.hostEvidence,
+      stopRevision: null,
+      consumer: null,
+      consumedAt: null
+    }) : receipt.hostEvidence ?? null,
+    startEvidenceMonotonicMs: monotonic,
+    activatedMonotonicMs: (options.monotonicNow ?? (() => Number(process.hrtime.bigint() / 1_000_000n)))(),
+    activatedAt: new Date(wallNow).toISOString()
   }) };
 }
 
+function abortPreparedDelegation(receipt: DelegationReceipt): ReceiptResult {
+  if (receipt.status !== 'prepared') {
+    return fail('DELEGATION_STATE_INVALID', `delegation ${receipt.id} is ${receipt.status}, expected prepared`);
+  }
+  return {
+    ok: true,
+    receipt: Object.freeze({ ...receipt, status: 'aborted' as const })
+  };
+}
+
 function completeDelegationStage(
   receipt: DelegationReceipt,
   event: Readonly<{ stage: DelegationStage; round: number; artifact: string; agent: string }>
@@ -154,10 +323,19 @@ function completeDelegationStage(
 
 function sealDelegation(
   receipt: DelegationReceipt,
-  event: Readonly<{ childId: string; exitCode: number; afterFingerprint: string; changedPaths: readonly string[] }>,
-  options: { now?: () => string } = {}
+  event: Readonly<{
+    childId: string;
+    exitCode: number;
+    afterFingerprint: string;
+    changedPaths: readonly string[];
+    hostEvidence?: Readonly<{ stopRevision: number; consumer: string; consumedAt: string }>;
+  }>,
+  options: { now?: () => string; requireHostEvidence?: boolean } = {}
 ): ReceiptResult {
   if (receipt.status !== 'stage-completed') return fail('DELEGATION_STATE_INVALID', `delegation ${receipt.id} is ${receipt.status}, expected stage-completed`);
+  if (receipt.client === 'codex' && options.requireHostEvidence !== false && !event.hostEvidence) {
+    return fail('DELEGATION_HOST_EVIDENCE_REQUIRED', 'Codex sealing requires consumed lifecycle-v2 host evidence');
+  }
   if (event.childId !== receipt.childId || event.exitCode !== 0) return fail('DELEGATION_STOP_INVALID', 'native stop identity or exit status is invalid');
   if (receipt.role === 'reviewer') {
     const taskRoot = `.agents/workspace/active/${receipt.taskId}/`;
@@ -169,11 +347,24 @@ function sealDelegation(
     const disallowed = event.changedPaths.find((entry) => !allowed.has(entry));
     if (disallowed) return fail('DELEGATION_REVIEWER_WRITE_FORBIDDEN', `reviewer changed forbidden path '${disallowed}'`);
   }
+  if (event.hostEvidence) {
+    if (
+      !receipt.hostEvidence
+      || !Number.isSafeInteger(event.hostEvidence.stopRevision)
+      || event.hostEvidence.stopRevision <= receipt.hostEvidence.startRevision
+      || event.hostEvidence.consumer !== receipt.id
+      || !event.hostEvidence.consumedAt.trim()
+    ) return fail('DELEGATION_HOST_EVIDENCE_INVALID', 'Codex stop evidence reference is invalid');
+  }
   return { ok: true, receipt: Object.freeze({
     ...receipt,
     status: 'sealed',
     afterFingerprint: event.afterFingerprint,
     changedPaths: Object.freeze([...event.changedPaths]),
+    hostEvidence: event.hostEvidence && receipt.hostEvidence ? Object.freeze({
+      ...receipt.hostEvidence,
+      ...event.hostEvidence
+    }) : receipt.hostEvidence ?? null,
     sealedAt: (options.now ?? (() => new Date().toISOString()))()
   }) };
 }
@@ -190,10 +381,20 @@ function consumeDelegation(receipt: DelegationReceipt, options: { now?: () => st
 
 export {
   activateDelegation,
+  abortPreparedDelegation,
   completeDelegationStage,
   consumeDelegation,
+  dispatchDelegation,
   managedDelegationRole,
   prepareDelegation,
   sealDelegation
 };
-export type { DelegationReceipt, DelegationRole, DelegationStage, DelegationStatus, ReceiptResult };
+export type {
+  DelegationHostEvidence,
+  DelegationLifecycleProvenance,
+  DelegationReceipt,
+  DelegationRole,
+  DelegationStage,
+  DelegationStatus,
+  ReceiptResult
+};