@fitlab-ai/agent-infra 0.9.5 → 0.9.7

package/dist/lib/task/verification-engine.js

@@ -151,7 +151,7 @@ function checkOrchestrationState({ taskDir }) {
     if (isFailClosedLegacyPause(run)) {
         return passResult('orchestration-state', 'Legacy orchestration run is safely paused');
     }
-    if (run.schemaVersion !== 2 || !['paused', 'completed'].includes(run.status)) {
+    if (![2, 3].includes(run.schemaVersion) || !['paused', 'completed'].includes(run.status)) {
         return failResult('orchestration-state', `Expected paused or completed run, received '${run.status}'`);
     }
     if (run.status === 'paused' && (!run.pause?.code || !run.pause?.message)) {
@@ -239,12 +239,29 @@ function checkOrchestrationEvidence({ taskDir }) {
         return failResult('orchestration-evidence', 'Run model policy source or recovery history is invalid');
     }
     for (const recovery of run.recoveryHistory) {
-        if (recovery.code !== 'MODEL_POLICY_SUPPLEMENTED'
-            || recovery.previousSchemaVersion !== 1
-            || recovery.receiptCount !== 0
-            || recovery.pendingDelegation !== false
-            || !exactText(recovery.recoveredAt)
-            || !recovery.policySource) {
+        const validModelRecovery = recovery.code === 'MODEL_POLICY_SUPPLEMENTED'
+            && recovery.previousSchemaVersion === 1
+            && recovery.receiptCount === 0
+            && recovery.pendingDelegation === false
+            && exactText(recovery.recoveredAt)
+            && recovery.policySource;
+        const guards = recovery.guards;
+        const validCapabilityRecovery = recovery.code === 'CLIENT_CAPABILITY_ENABLED'
+            && recovery.previousSchemaVersion === 2
+            && recovery.previousStatus === 'paused'
+            && recovery.previousPause?.code === 'ORCHESTRATION_CLIENT_UNSUPPORTED'
+            && recovery.client === 'codex'
+            && recovery.resultingStatus === 'running'
+            && exactText(recovery.recoveredAt)
+            && guards?.stepCount === 0
+            && guards?.nextStage === null
+            && guards?.baselineEmpty === true
+            && guards?.receiptCount === 0
+            && guards?.pendingDelegation === false
+            && guards?.commitAuthorizationUnused === true
+            && guards?.completionEvidenceAbsent === true
+            && guards?.commitIntentAbsent === true;
+        if (!validModelRecovery && !validCapabilityRecovery) {
             return failResult('orchestration-evidence', 'Run recovery history contains invalid provenance');
         }
     }
@@ -298,6 +315,21 @@ function checkOrchestrationEvidence({ taskDir }) {
                 && receipt.reasoningEffortFallbackReason !== null) {
                 return failResult('orchestration-evidence', `Receipt '${receipt.id ?? '(unknown)'}' has an unrelated reasoning-effort fallback reason`);
             }
+            if (receipt.client === 'codex') {
+                const host = receipt.hostEvidence;
+                if (host?.kind !== 'codex-lifecycle-v1'
+                    || !exactText(host.hookDefinitionHash)
+                    || !Number.isSafeInteger(host.startRevision)
+                    || host.startRevision < 1) {
+                    return failResult('orchestration-evidence', `Receipt '${receipt.id ?? '(unknown)'}' has invalid Codex start evidence`);
+                }
+                if (['sealed', 'consumed'].includes(receipt.status) && (!Number.isSafeInteger(host.stopRevision)
+                    || host.stopRevision <= host.startRevision
+                    || host.consumer !== receipt.id
+                    || !exactText(host.consumedAt))) {
+                    return failResult('orchestration-evidence', `Receipt '${receipt.id ?? '(unknown)'}' has invalid Codex consumed stop evidence`);
+                }
+            }
         }
     }
     if (run.receipts.some((receipt) => receipt.status !== 'consumed')) {
@@ -884,7 +916,13 @@ function checkPostReviewCommit({ taskDir, config }) {
                 return blockedResult("post-review-commit", relation.message, relation.code);
             }
             if (relation.status === "strict") {
-                return failResult("post-review-commit", "Merged PR evidence did not establish squash merge equivalence", "PR_MERGE_IDENTITY_INVALID");
+                return resolvePostReviewIdentityFailure(task.content, {
+                    code: "PR_MERGE_IDENTITY_INVALID",
+                    message: "Merged PR evidence did not establish squash merge equivalence"
+                });
+            }
+            if (relation.code === "PR_MERGE_IDENTITY_INVALID") {
+                return resolvePostReviewIdentityFailure(task.content, relation);
             }
             return failResult("post-review-commit", relation.message, relation.code);
         }
@@ -949,21 +987,47 @@ function checkPostReviewCommit({ taskDir, config }) {
     }
     const exemption = resolvePostReviewExemption(task.content);
     if (!exemption.ok)
-        return failResult("post-review-commit", exemption.message);
-    if (exemption.exempt) {
-        return passResult("post-review-commit", `${commits.length} post-review commit(s) covered by a human-decided exemption`);
+        return failResult("post-review-commit", exemption.message, exemption.code);
+    if (exemption.exemptions.length > 0) {
+        return passResult("post-review-commit", `${commits.length} post-review commit(s) covered by a human-decided exemption: ${formatPostReviewExemptions(exemption.exemptions)}`);
     }
     return failResult("post-review-commit", `${commits.length} commit(s) to code/rule paths after reviewed commit ${sha.slice(0, 8)}; re-run review-code or record a human-decided exemption`);
 }
+function resolvePostReviewIdentityFailure(content, failure) {
+    const exemption = resolvePostReviewExemption(content);
+    if (!exemption.ok) {
+        return failResult("post-review-commit", exemption.message, exemption.code);
+    }
+    if (exemption.exemptions.length === 0) {
+        return failResult("post-review-commit", failure.message, failure.code);
+    }
+    return passResult("post-review-commit", `Human-decided post-review exemption overrode ${failure.code}: ${failure.message}; ${formatPostReviewExemptions(exemption.exemptions)}`);
+}
+function formatPostReviewExemptions(exemptions) {
+    return exemptions.map((row) => `${row.id}: ${row.evidence}`).join("; ");
+}
 function resolvePostReviewExemption(content) {
     try {
+        const rows = parseLedger(content);
+        const invalid = validateLedgerRows(rows);
+        if (invalid) {
+            return {
+                ok: false,
+                code: "POST_REVIEW_EXEMPTION_INVALID",
+                message: `${invalid.code}: ${invalid.message}`
+            };
+        }
         return {
             ok: true,
-            exempt: parseLedger(content).some((row) => row.stage === POST_REVIEW_COMMIT_STAGE && row.status === "human-decided")
+            exemptions: rows.filter((row) => row.stage === POST_REVIEW_COMMIT_STAGE)
         };
     }
-    catch {
-        return { ok: false, message: "Invalid disagreement ledger" };
+    catch (error) {
+        return {
+            ok: false,
+            code: "POST_REVIEW_EXEMPTION_INVALID",
+            message: `Invalid disagreement ledger: ${error instanceof Error ? error.message : String(error)}`
+        };
     }
 }
 function checkReviewFact({ taskDir, artifactFile }) {

package/dist/lib/task/verification.js

@@ -16,6 +16,7 @@ const VERIFICATION_CATALOG = {
     'code.completed': gate('code-task', 'active', 'code'),
     'review-code.completed': gate('review-code', 'active', 'review-code'),
     'manual-validation.completed': gate('complete-manual-validation', 'active', 'manual-validation'),
+    'validation-run.completed': gate('run-manual-validation', 'active', 'validation-run'),
     'block-task.completed': gate('block-task', 'blocked'),
     'cancel-task.completed': gate('cancel-task', 'completed'),
     'commit.completed': gate('commit', 'active'),

package/dist/lifecycle-build-manifest.json

@@ -0,0 +1,6 @@
+{
+  "protocolVersion": 3,
+  "packageVersion": "0.9.7",
+  "sourceInputHash": "ee12d1ec7a586eeaba04deb4253ccd7f5d16552915ca141e493248c0728459a9",
+  "internalExecutableBuildHash": "0eceb914e6c1cb9937b86d34bfbf933d1010f499b9976813556146d2e6fa0132"
+}

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

@@ -19,6 +19,12 @@ type DiscoveredHook = Readonly<{
   matcher: string | null;
   command: string;
   enabled: boolean;
+  source: string;
+  sourcePathDigest: string;
+  trustStatus: string;
+  currentHash: string;
+  isManaged: boolean;
+  pluginId: string | null;
 }>;
 
 type AppServerTransportOptions = Readonly<{
@@ -27,6 +33,8 @@ type AppServerTransportOptions = Readonly<{
   cwd?: string;
   env?: NodeJS.ProcessEnv;
   timeoutMs?: number;
+  rolloutReadAttempts?: number;
+  rolloutRetryMs?: number;
 }>;
 
 type CodexRuntimeIdentity = Readonly<{
@@ -37,10 +45,12 @@ type CodexRuntimeIdentity = Readonly<{
 
 const LIFECYCLE_HOOKS = Object.freeze([
   Object.freeze({ event: 'PreToolUse', matcher: '^collaborationspawn_agent$', phase: 'pre-tool' }),
-  Object.freeze({ event: 'PostToolUse', matcher: '^collaborationspawn_agent$', phase: 'post-tool' }),
-  Object.freeze({ event: 'SubagentStart', matcher: '^agent-infra-lifecycle-(executor|reviewer)$', phase: 'subagent-start' }),
-  Object.freeze({ event: 'SubagentStop', matcher: '^agent-infra-lifecycle-(executor|reviewer)$', phase: 'subagent-stop' })
+  Object.freeze({ event: 'PostToolUse', matcher: '', phase: 'post-tool' }),
+  Object.freeze({ event: 'SubagentStart', matcher: '', phase: 'subagent-start' }),
+  Object.freeze({ event: 'SubagentStop', matcher: '', phase: 'subagent-stop' })
 ]);
+const DEFAULT_ROLLOUT_READ_ATTEMPTS = 81;
+const DEFAULT_ROLLOUT_RETRY_MS = 100;
 
 function object(value: unknown): JsonObject | null {
   return value && typeof value === 'object' && !Array.isArray(value)
@@ -52,6 +62,65 @@ function nonEmpty(value: unknown): string | null {
   return typeof value === 'string' && value.trim() ? value : null;
 }
 
+function resolveCodexSpawnedChild(
+  transcriptPath: string,
+  expected: Readonly<{
+    sessionId: string;
+    toolUseId: string;
+    nativeAgent: string;
+    taskName: string;
+    requestedModel?: string;
+    requestedReasoningEffort?: string;
+  }>
+): string {
+  const name = path.basename(transcriptPath);
+  if (!transcriptPath || (!name.endsWith(`-${expected.sessionId}.jsonl`) && name !== `${expected.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 buffer = Buffer.alloc(stat.size - offset);
+  const descriptor = fs.openSync(transcriptPath, 'r');
+  try {
+    fs.readSync(descriptor, buffer, 0, buffer.length, offset);
+  } finally {
+    fs.closeSync(descriptor);
+  }
+  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';
+  });
+  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)
+  ) throw new Error('Codex parent rollout spawn identity does not match the hook event');
+  const activities = records.filter((record) => {
+    const payload = object(record?.payload);
+    return record?.type === 'event_msg'
+      && payload?.type === 'sub_agent_activity'
+      && payload.event_id === expected.toolUseId
+      && payload.kind === 'started'
+      && payload.agent_path === `/root/${expected.taskName}`
+      && nonEmpty(payload.agent_thread_id);
+  });
+  if (activities.length !== 1) throw new Error('Codex parent rollout child activity was not found uniquely');
+  return nonEmpty(object(activities[0]?.payload)?.agent_thread_id)!;
+}
+
 function validateCodexLifecycleHookConfig(value: unknown): void {
   const hooks = object(object(value)?.hooks);
   const valid = hooks && LIFECYCLE_HOOKS.every(({ event, matcher, phase }) => {
@@ -63,7 +132,7 @@ function validateCodexLifecycleHookConfig(value: unknown): void {
       return entry.hooks.some((hookValue) => {
         const hook = object(hookValue);
         return hook?.type === 'command'
-          && hook.timeout === 5
+          && hook.timeout === 15
           && hook.command === `node "$(git rev-parse --show-toplevel)/.agents/hooks/lifecycle-delegation.js" --client codex --event ${phase}`;
       });
     });
@@ -71,7 +140,11 @@ function validateCodexLifecycleHookConfig(value: unknown): void {
   if (!valid) throw new Error('CODEX_PREFLIGHT_HOOKS_INVALID: lifecycle hooks are invalid');
 }
 
-function parseCodexHooksList(value: unknown, repoRoot: string): readonly DiscoveredHook[] {
+function parseCodexHooksList(
+  value: unknown,
+  repoRoot: string,
+  expectedSource: 'direct-host' | 'isolated-user' = 'direct-host'
+): readonly DiscoveredHook[] {
   const root = object(value);
   const entries = Array.isArray(root?.data) ? root.data : [];
   const entry = entries.map(object).find((candidate) => candidate?.cwd === repoRoot);
@@ -84,13 +157,28 @@ function parseCodexHooksList(value: unknown, repoRoot: string): readonly Discove
       eventName: String(hook.eventName ?? ''),
       matcher: typeof hook.matcher === 'string' ? hook.matcher : null,
       command: String(hook.command ?? ''),
-      enabled: hook.enabled === true
+      enabled: hook.enabled === true,
+      source: String(hook.source ?? ''),
+      sourcePathDigest: typeof hook.sourcePath === 'string' && path.isAbsolute(hook.sourcePath)
+        ? crypto.createHash('sha256').update(hook.sourcePath).digest('hex')
+        : '',
+      trustStatus: String(hook.trustStatus ?? ''),
+      currentHash: String(hook.currentHash ?? ''),
+      isManaged: hook.isManaged === true,
+      pluginId: typeof hook.pluginId === 'string' ? hook.pluginId : null
     }));
   const valid = LIFECYCLE_HOOKS.every(({ event, matcher, phase }) => hooks.some((hook) =>
     hook.eventName === event.replace(/^./, (character) => character.toLowerCase())
     && hook.matcher === matcher
     && hook.command === `node "$(git rev-parse --show-toplevel)/.agents/hooks/lifecycle-delegation.js" --client codex --event ${phase}`
     && hook.enabled
+    && hook.currentHash.length > 0
+    && hook.sourcePathDigest.length === 64
+    && hook.pluginId === null
+    && (expectedSource === 'isolated-user'
+      ? hook.source === 'user' && hook.trustStatus !== 'modified'
+      : (hook.source === 'project' && hook.trustStatus === 'trusted')
+        || hook.isManaged && hook.trustStatus === 'managed')
   ));
   if (!valid) throw new Error('CODEX_PREFLIGHT_HOOKS_NOT_LOADED: lifecycle hooks are not loaded for this workspace');
   return Object.freeze(hooks);
@@ -120,26 +208,38 @@ function hasCodexRuntimeLiveness(
     });
 }
 
-function parseCodexThreadResolution(readValue: unknown, resumeValue: unknown): ThreadResolution {
+function parseCodexThreadResolution(readValue: unknown, rolloutRecords: readonly unknown[]): ThreadResolution {
   const readRoot = object(readValue);
-  const resumeRoot = object(resumeValue);
   const thread = object(readRoot?.thread);
-  const resumedThread = object(resumeRoot?.thread);
   const source = object(thread?.source);
   const subAgent = object(source?.subAgent);
   const threadSpawn = object(subAgent?.thread_spawn);
+  const sessionMeta = rolloutRecords
+    .map(object)
+    .find((record) => record?.type === 'session_meta');
+  const sessionPayload = object(sessionMeta?.payload);
+  const turnContext = rolloutRecords
+    .map(object)
+    .filter((record) => record?.type === 'turn_context')
+    .at(-1);
+  const turnPayload = object(turnContext?.payload);
   const childThreadId = nonEmpty(thread?.id);
   const parentThreadId = nonEmpty(thread?.parentThreadId);
   const sourceParentThreadId = nonEmpty(threadSpawn?.parent_thread_id);
-  const resumedChildThreadId = nonEmpty(resumedThread?.id);
-  const model = nonEmpty(resumeRoot?.model);
-  const reasoningEffort = nonEmpty(resumeRoot?.reasoningEffort ?? object(resumeRoot?.settings)?.effort);
+  const rolloutChildThreadId = nonEmpty(sessionPayload?.id);
+  const rolloutParentThreadId = nonEmpty(sessionPayload?.parent_thread_id);
+  const agentRole = nonEmpty(sessionPayload?.agent_role);
+  const model = nonEmpty(turnPayload?.model);
+  const reasoningEffort = nonEmpty(turnPayload?.effort);
   const forkedFromId = thread?.forkedFromId;
   if (
     !childThreadId
-    || resumedChildThreadId !== childThreadId
+    || rolloutChildThreadId !== childThreadId
     || !parentThreadId
     || !sourceParentThreadId
+    || rolloutParentThreadId !== parentThreadId
+    || rolloutParentThreadId !== sourceParentThreadId
+    || !/^agent-infra-lifecycle-(executor|reviewer)$/.test(agentRole ?? '')
     || !model
     || !reasoningEffort
     || (forkedFromId !== null && typeof forkedFromId !== 'string')
@@ -152,7 +252,8 @@ function parseCodexThreadResolution(readValue: unknown, resumeValue: unknown): T
       childThreadId,
       parentThreadId,
       forkedFromId,
-      sourceParentThreadId
+      sourceParentThreadId,
+      nativeAgent: agentRole!
     }),
     settings: Object.freeze({
       type: 'app-settings',
@@ -163,6 +264,49 @@ function parseCodexThreadResolution(readValue: unknown, resumeValue: unknown): T
   });
 }
 
+function readCodexRolloutRecords(readValue: unknown, childThreadId: string): readonly unknown[] {
+  const thread = object(object(readValue)?.thread);
+  const rolloutPath = nonEmpty(thread?.path);
+  const rolloutName = rolloutPath ? path.basename(rolloutPath) : '';
+  if (!rolloutPath || (rolloutName !== `${childThreadId}.jsonl` && !rolloutName.endsWith(`-${childThreadId}.jsonl`))) {
+    throw new Error('Codex App Server rollout path is invalid');
+  }
+  const stat = fs.statSync(rolloutPath);
+  if (!stat.isFile()) throw new Error('Codex App Server rollout path is not a regular file');
+  const maxBytes = 1024 * 1024;
+  const bytes = Math.min(stat.size, maxBytes);
+  const descriptor = fs.openSync(rolloutPath, 'r');
+  try {
+    const buffer = Buffer.alloc(bytes);
+    fs.readSync(descriptor, buffer, 0, bytes, 0);
+    const text = buffer.toString('utf8');
+    const completeText = stat.size <= maxBytes ? text : text.slice(0, text.lastIndexOf('\n'));
+    return Object.freeze(completeText.split(/\r?\n/).filter(Boolean).map((line) => JSON.parse(line)));
+  } finally {
+    fs.closeSync(descriptor);
+  }
+}
+
+async function resolveCodexRolloutRecords(
+  readValue: unknown,
+  childThreadId: string,
+  attempts: number,
+  retryMs: number
+): Promise<readonly unknown[]> {
+  let lastError: unknown;
+  for (let attempt = 0; attempt < attempts; attempt += 1) {
+    try {
+      const records = readCodexRolloutRecords(readValue, childThreadId);
+      parseCodexThreadResolution(readValue, records);
+      return records;
+    } catch (error) {
+      lastError = error;
+      if (attempt + 1 < attempts) await new Promise((resolve) => setTimeout(resolve, retryMs));
+    }
+  }
+  throw lastError;
+}
+
 function parseCodexTurnCompleted(value: unknown): Extract<CodexLifecycleEvent, { type: 'app-terminal' }> {
   const root = object(value);
   const turn = object(root?.turn);
@@ -333,12 +477,17 @@ async function resolveCodexThread(
     const readResult = object(await transport.request('thread/read', { threadId: childThreadId, includeTurns: false }));
     const readThread = object(readResult?.thread);
     if (nonEmpty(readThread?.id) !== childThreadId) throw new Error('Codex App Server returned the wrong child thread');
-    const resumeResult = await transport.request('thread/resume', { threadId: childThreadId });
     let resolution: ThreadResolution;
     try {
-      resolution = parseCodexThreadResolution(readResult, resumeResult);
+      const rolloutRecords = await resolveCodexRolloutRecords(
+        readResult,
+        childThreadId,
+        options.rolloutReadAttempts ?? DEFAULT_ROLLOUT_READ_ATTEMPTS,
+        options.rolloutRetryMs ?? DEFAULT_ROLLOUT_RETRY_MS
+      );
+      resolution = parseCodexThreadResolution(readResult, rolloutRecords);
     } catch {
-      throw new Error('Codex App Server resumed settings are unavailable');
+      throw new Error('Codex App Server rollout metadata is unavailable');
     }
     const reroutes = transport.notifications
       .filter((entry) => entry.method === 'model/rerouted')
@@ -368,6 +517,8 @@ async function resolveCodexTerminal(
     if (nonEmpty(thread?.id) !== childThreadId) throw new Error('Codex App Server returned the wrong child thread');
     const turns = Array.isArray(thread?.turns) ? thread.turns : [];
     const turn = turns.at(-1);
+    const turnValue = object(turn);
+    if (!turnValue || turnValue.status === 'inProgress') throw new Error('CODEX_TURN_NOT_TERMINAL');
     return parseCodexTurnCompleted({ threadId: childThreadId, turn });
   } finally {
     transport.close();
@@ -415,13 +566,45 @@ async function preflightCodexLifecycleEvidence(
   let discoveredHooks: readonly DiscoveredHook[];
   try {
     await transport.initialize();
-    discoveredHooks = parseCodexHooksList(await transport.request('hooks/list', { cwds: [repoRoot] }), repoRoot);
+    discoveredHooks = parseCodexHooksList(
+      await transport.request('hooks/list', { cwds: [repoRoot] }),
+      repoRoot,
+      process.env.AGENT_INFRA_CODEX_CONTROLLER_CONTEXT ? 'isolated-user' : 'direct-host'
+    );
   } finally { transport.close(); }
+  const lifecycleHooks = LIFECYCLE_HOOKS.map(({ event, matcher, phase }) => discoveredHooks.filter((hook) =>
+    hook.eventName === event.replace(/^./, (character) => character.toLowerCase())
+    && hook.matcher === matcher
+    && hook.command === `node "$(git rev-parse --show-toplevel)/.agents/hooks/lifecycle-delegation.js" --client codex --event ${phase}`
+  ));
+  if (lifecycleHooks.some((matches) => matches.length !== 1)) {
+    throw new Error('CODEX_PREFLIGHT_HOOK_SOURCE_AMBIGUOUS: lifecycle hook source is not unique');
+  }
+  const matchedHooks = lifecycleHooks.flat();
+  const sources = new Set(matchedHooks.map((hook) => hook.isManaged ? 'managed' : hook.source));
+  const sourcePathDigests = new Set(matchedHooks.map((hook) => hook.sourcePathDigest));
+  if (sources.size !== 1 || sourcePathDigests.size !== 1) {
+    throw new Error('CODEX_PREFLIGHT_HOOK_SOURCE_AMBIGUOUS: lifecycle hooks do not share one exact source');
+  }
+  const source = [...sources][0];
+  const hookSource = process.env.AGENT_INFRA_CODEX_CONTROLLER_CONTEXT
+    ? 'isolated-user'
+    : source === 'managed' ? 'managed' : 'project';
   return Object.freeze({
     cliVersion: match[1],
     hookDefinitionHash,
     staticReady: true,
     discoveredHooks,
+    hookProvenance: Object.freeze({
+      hookSource,
+      hookSourcePathDigest: [...sourcePathDigests][0]!,
+      hookSourceHash: crypto.createHash('sha256').update(JSON.stringify(matchedHooks.map((hook) => ({
+        eventName: hook.eventName,
+        matcher: hook.matcher,
+        command: hook.command,
+        currentHash: hook.currentHash
+      })))).digest('hex')
+    }),
     runtimeLiveness,
     diagnostics: transport.diagnostics
   });
@@ -434,6 +617,7 @@ export {
   parseCodexHooksList,
   parseCodexThreadResolution,
   parseCodexTurnCompleted,
+  resolveCodexSpawnedChild,
   preflightCodexLifecycleEvidence,
   resolveCodexTerminal,
   resolveCodexThread,