@fitlab-ai/agent-infra 0.9.13 → 0.9.15

package/lib/sandbox/control/server.ts

@@ -1,3 +1,6 @@
+import { finalizationTerminalResponse } from './finalization-response.ts';
+import { isDeepStrictEqual } from 'node:util';
+import { completedReentryView } from './completed-reentry.ts';
 import fs from 'node:fs';
 import path from 'node:path';
 import { createHash, randomUUID } from 'node:crypto';
@@ -15,7 +18,6 @@ import {
 } from './protocol.ts';
 import { prepareSandboxControlExecution, type PreparedSandboxControlExecution, type SandboxControlExecutionResult } from './executor.ts';
 import {
-  appendSandboxControlAudit,
   atomicWriteJsonNoReplace,
   createSandboxControlPayload,
   cleanupStaleSandboxControlLease,
@@ -25,6 +27,8 @@ import {
   readExecution,
   readSandboxControlPayload,
   readSandboxControlResultEvidence,
+  readSandboxControlTerminalResult,
+  createSandboxControlTerminalResult,
   sandboxControlEncodedJsonBytes,
   sandboxControlGenerationUsage,
   sanitizeSandboxControlOutput,
@@ -33,10 +37,36 @@ import {
   writeSandboxControlPayload,
   writeSandboxControlReservation,
   writeSandboxControlResultEvidence,
+  writeSandboxControlTerminalResult,
+  appendSandboxControlAudit,
   terminateSandboxControlExecution,
-  writeSandboxControlStatus
+  writeSandboxControlStatus,
+  readSandboxControlStatus
 } from './state.ts';
 import { validateSandboxControlRequest } from './protocol.ts';
+import {
+  requestAuditFields,
+  resultAuditFields,
+  appendCriticalAudit,
+  appendDiagnosticAudit,
+  createSandboxControlAuditContext,
+  writeSandboxControlTransition,
+  readSandboxControlTransition
+} from './audit.ts';
+import { parseTaskControlOperation } from '../../task/control-authority.ts';
+import {
+  parseControlOutput,
+  classifySandboxControlRecovery,
+  findSandboxControlRecoveryOperation,
+  operationRecoveryBinding,
+  SANDBOX_CONTROL_REQUIRED_COMPLETION_PHASES
+} from '../../task/control-recovery.ts';
+import { readRun } from '../../task/orchestration.ts';
+import { captureRepositorySnapshot } from '../../task/workspace-snapshot.ts';
+import { parseTypedTaskFrontmatter } from '../../task/frontmatter.ts';
+import { readLifecycleJournalEvidence } from '../../task/lifecycle.ts';
+import { resolveTaskRef } from '../../task/resolve-ref.ts';
+import { loadShortIdByTaskId } from '../../task/short-id.ts';
 import { inspectSandboxControlContainer, type ContainerObservation } from './container-identity.ts';
 import {
   acquireSandboxControlBrokerStartup,
@@ -47,17 +77,151 @@ import {
 import type { BrokerOwner } from './lifecycle.ts';
 import { nextSandboxControlBackoff } from './timing.ts';
 import { readTaskFinalizationReceipt } from '../../task/finalization.ts';
-import { resolveTaskRef } from '../../task/resolve-ref.ts';
+import { readCodexControllerRegistration } from './controller-registration.ts';
+import { validateSandboxControlIdentity } from './identity-sentinel.ts';
+import {
+  mergeSandboxTaskView,
+  taskViewAfterFinalization,
+  taskViewForManifest,
+  type SandboxTaskView
+} from './task-view.ts';
+import { taskCreateOutputUnavailableResult } from '../../task/create-service.ts';
+import {
+  consumeLifecycleRecoveryAttestation,
+  issueLifecycleRecoveryAttestation,
+  recoverLifecycleRecoveryOperation,
+  type LifecycleAuthorityResponseV1
+} from '../../task/control-authority.ts';
+import { createCodexCapabilityStore } from '../../agent-clients/adapters/codex-lifecycle/capability-store.ts';
+import { computeLifecycleBuildIdentity } from '../../agent-clients/adapters/codex-lifecycle/build-identity.ts';
 
 type ActiveExecution = {
   request: SandboxControlRequest;
   prepared: PreparedSandboxControlExecution;
+  lifecycleAuthority: LifecycleAuthorityResponseV1 | undefined;
   result: SandboxControlExecutionResult | null;
   resultEvidenceWritten: boolean;
   failure: unknown;
   settled: boolean;
 };
 
+function consumeLifecycleAuthorityForResult(
+  manifest: SandboxControlManifest,
+  execution: ActiveExecution
+): boolean {
+  const authority = execution.lifecycleAuthority?.attestation;
+  if (!authority || execution.result?.exitCode !== 0) return true;
+  try {
+    consumeLifecycleRecoveryAttestation(authority);
+    return true;
+  } catch (error) {
+    appendBrokerAudit(manifest, 'lifecycle-authority-consume-retry', {
+      ...requestAuditFields(manifest, execution.request),
+      errorCode: error instanceof Error ? error.name : 'LIFECYCLE_AUTHORITY_CONSUME_FAILED'
+    });
+    return false;
+  }
+}
+
+function lifecycleAuthorityForRequest(
+  manifest: SandboxControlManifest,
+  manifestPath: string,
+  request: SandboxControlRequest
+): LifecycleAuthorityResponseV1 | undefined {
+  const selector = request.family === 'task-workflow' || request.family === 'task-orchestration'
+    ? request.authority
+    : undefined;
+  if (!selector) return undefined;
+  let controllerBinding: { instanceDigest: string; controlGeneration: string } | null = null;
+  try {
+    const registration = readCodexControllerRegistration(manifestPath);
+    controllerBinding = {
+      instanceDigest: registration.controllerInstanceDigest,
+      controlGeneration: registration.controlGeneration
+    };
+  } catch {
+    // The issuer reports the stable unavailable result; the broker never trusts
+    // a controller binding supplied by the request.
+  }
+  return issueLifecycleRecoveryAttestation(selector, {
+    controllerBinding,
+    capabilityStore: createCodexCapabilityStore(),
+    buildIdentity: computeLifecycleBuildIdentity(manifest.repoRoot)
+  });
+}
+
+function appendBrokerAudit(
+  manifest: SandboxControlManifest,
+  event: string,
+  fields: Record<string, string | number | boolean | null> = {}
+): void {
+  appendDiagnosticAudit(manifest, event, { source: 'broker', ...fields });
+}
+
+function operationKey(request: SandboxControlRequest, output?: string): string | null {
+  if (request.family === 'task-finalization') return request.operation;
+  if (request.family === 'task-create') return 'create';
+  if (request.family === 'codex-controller') return request.command;
+  if (request.family === 'task-workflow') return request.workflow.operation;
+  if (request.family !== 'task-lifecycle' && request.family !== 'task-orchestration') return null;
+  if (request.family === 'task-orchestration' && request.args[1] === 'route') {
+    if (!output) return 'route';
+    const result = parseControlOutput(output);
+    return result?.changed === true && result.status === 'completed' ? 'route.clean-completion' : 'route.read';
+  }
+  try {
+    const operation = parseTaskControlOperation(request.family, request.args);
+    return operation.family === 'task-orchestration' ? operation.intent : operation.request.intent;
+  } catch {
+    return null;
+  }
+}
+
+function recoveryOperationKey(
+  request: SandboxControlRequest,
+  terminalResult: ReturnType<typeof readSandboxControlTerminalResult> | null,
+  output: string | undefined
+): string | null {
+  const operation = operationKey(request, output);
+  if (operation !== 'route') return operation;
+  const digest = terminalResult?.intentDigest;
+  for (const candidate of ['route.read', 'route.clean-completion'] as const) {
+    const expected = operationRecoveryBinding(request.id, request.generation, null, request.family, candidate).intentDigest;
+    if (digest === expected) return candidate;
+  }
+  return null;
+}
+
+function terminalResultMatchesRequest(
+  request: SandboxControlRequest,
+  terminalResult: ReturnType<typeof readSandboxControlTerminalResult>
+): boolean {
+  const operation = operationKey(request);
+  const candidates = operation === 'route'
+    ? ['route.read', 'route.clean-completion']
+    : operation ? [operation] : [];
+  return candidates.some((candidate) => createHash('sha256').update(`${request.family}\0${candidate}`, 'utf8').digest('hex') === terminalResult.intentDigest);
+}
+
+function criticalRequestPhase(
+  manifest: SandboxControlManifest,
+  request: SandboxControlRequest,
+  phase: Parameters<typeof createSandboxControlAuditContext>[1]['phase'],
+  outcome: Parameters<typeof createSandboxControlAuditContext>[1]['outcome'],
+  reference?: string | null
+): void {
+  const context = createSandboxControlAuditContext(manifest, {
+    requestId: request.id,
+    family: request.family,
+    operation: operationKey(request),
+    phase,
+    outcome
+  });
+  appendCriticalAudit(manifest, context, { reference: reference ?? null });
+  writeSandboxControlTransition(manifest, { requestId: request.id, phase, reference });
+}
+
+
 function assertRealDirectory(directory: string, parent?: string): void {
   const stat = fs.lstatSync(directory);
   if (!stat.isDirectory() || stat.isSymbolicLink()) throw new Error('SANDBOX_CONTROL_CHANNEL_INVALID');
@@ -142,33 +306,37 @@ function finalizationRecoveryResponse(
   } catch {
     return { status: 'deferred' };
   }
-  const pendingSteps = [
-    receipt.taskComment === 'pending' ? 'task-comment' : null,
-    receipt.verification === 'pending' ? 'verification' : null
-  ].filter((step): step is string => step !== null);
-  const completedSteps = ['lifecycle', receipt.taskComment === 'pending' ? null : 'task-comment', receipt.verification === 'pending' ? null : 'verification']
-    .filter((step): step is string => step !== null);
-  const warnings = receipt.warnings
-    .filter((warning) => warning.status === 'open')
-    .map(({ status: _status, resolvedAt: _resolvedAt, ...warning }) => warning);
-  const result = {
-    status: 'completed', changed: false, taskId: manifest.taskId,
-    lifecycle: { status: 'no-op', changed: false, error: null },
-    taskComment: receipt.taskComment === 'pending' ? null : { status: 'no-op', changed: false, error: null },
-    verification: receipt.verification === 'pending' ? null : { status: 'no-op', changed: false, error: null },
-    completedSteps, pendingSteps,
-    result: pendingSteps.length > 0 || receipt.warningProjection === 'pending' || warnings.length > 0
-      ? 'completed_with_warnings' : 'completed',
-    warnings, error: null
-  };
-  return {
-    status: 'matched',
-    response: {
-      version: 2, id: requestId, phase: 'completed', exitCode: 0,
-      stdout: `${JSON.stringify({ version: 1, status: 'completed', changed: false, accepted: true, result, error: null })}\n`,
-      stderr: '', error: null
-    }
-  };
+  return { status: 'matched', response: finalizationTerminalResponse(manifest.taskId, requestId, receipt) };
+}
+
+function publishFinalizationTaskView(
+  manifest: SandboxControlManifest,
+  broker: BrokerOwner,
+  requestId: string,
+  state: 'starting' | 'healthy' | 'busy' | 'parked',
+  reasonCode: string | null,
+  activeRequestId: string | null
+): SandboxTaskView {
+  let view: SandboxTaskView;
+  try {
+    const resolved = resolveTaskRef(manifest.taskId ?? '', { repoRoot: manifest.repoRoot });
+    const receipt = readTaskFinalizationReceipt(manifest.repoRoot, manifest.taskId ?? '');
+    view = resolved.ok && resolved.state === 'completed'
+      ? taskViewAfterFinalization({
+          taskId: manifest.taskId ?? '', generation: manifest.generation, requestId, receipt
+        })
+      : {
+          state: 'unknown', taskId: manifest.taskId, observedSource: 'unknown', receipt: null,
+          reasonCode: 'SANDBOX_TASK_VIEW_SOURCE_UNCONFIRMED'
+        };
+  } catch {
+    view = {
+      state: 'unknown', taskId: manifest.taskId, observedSource: 'unknown', receipt: null,
+      reasonCode: 'SANDBOX_TASK_VIEW_RECEIPT_INVALID'
+    };
+  }
+  writeSandboxControlStatus(manifest, broker, state, reasonCode, activeRequestId, Date.now(), view);
+  return view;
 }
 
 function payloadReference(payload: ReturnType<typeof createSandboxControlPayload>) {
@@ -201,46 +369,290 @@ function outputMatchesEvidence(output: string, bytes: number, sha256: string): b
 }
 
 function genericRecoveryResponse(
-  requestId: string,
-  evidence: ReturnType<typeof readSandboxControlResultEvidence>,
-  payload: ReturnType<typeof readSandboxControlPayload> | null
+  request: SandboxControlRequest,
+  exitCode: number,
+  payload: ReturnType<typeof readSandboxControlPayload> | null,
+  cause: 'publish' | 'recovery' = 'recovery'
 ): SandboxControlResponse {
+  const outputUnavailable = request.family === 'task-create' && !payload;
   return {
     version: 2,
-    id: requestId,
+    id: request.id,
     phase: 'completed',
-    exitCode: evidence.exitCode,
-    stdout: '',
-    stderr: payload ? '' : 'SANDBOX_CONTROL_OUTPUT_UNAVAILABLE: broker restarted after executor completion\n',
+    exitCode,
+    stdout: outputUnavailable ? `${JSON.stringify(taskCreateOutputUnavailableResult(request.id))}\n` : '',
+    stderr: payload ? '' : cause === 'publish'
+      ? 'SANDBOX_CONTROL_OUTPUT_UNAVAILABLE: output payload was not retained\n'
+      : 'SANDBOX_CONTROL_OUTPUT_UNAVAILABLE: broker restarted after executor completion\n',
     error: null,
     outputState: payload ? 'available' : 'unavailable',
     payload: payload ? payloadReference(payload) : null
   };
 }
 
+type RecoveryDomainEvidence = Readonly<{
+  domain: Readonly<Record<string, unknown>> | null;
+  journal?: ReturnType<typeof readLifecycleJournalEvidence>;
+}>;
+
+function taskCreateDomainEvidence(
+  manifest: SandboxControlManifest,
+  output: Record<string, unknown> | null
+): Readonly<Record<string, unknown>> {
+  if (!output || !['applied', 'no-op', 'degraded'].includes(String(output.status))) {
+    return { consistent: false };
+  }
+  const task = output.task && typeof output.task === 'object' && !Array.isArray(output.task)
+    ? output.task as Record<string, unknown> : null;
+  const taskId = typeof task?.id === 'string' ? task.id : null;
+  const shortId = typeof task?.shortId === 'string' ? task.shortId : null;
+  if (!taskId || !shortId) return { consistent: false };
+  try {
+    const resolved = resolveTaskRef(taskId, { repoRoot: manifest.repoRoot });
+    const shortIds = loadShortIdByTaskId(manifest.repoRoot);
+    return {
+      consistent: resolved.ok && resolved.taskId === taskId && resolved.state === 'active' && shortIds.get(taskId) === shortId,
+      taskId,
+      shortId
+    };
+  } catch {
+    return { consistent: false };
+  }
+}
+
+function controllerDomainEvidence(
+  manifest: SandboxControlManifest,
+  manifestPath: string,
+  request: SandboxControlRequest,
+  output: Record<string, unknown> | null
+): Readonly<Record<string, unknown>> {
+  if (!output || output.error !== null || typeof output.status !== 'string') return { consistent: false };
+  try {
+    const registration = readCodexControllerRegistration(manifestPath);
+    if (request.family !== 'codex-controller') return { consistent: false };
+    if (request.command === 'open') {
+      const lease = output.lease && typeof output.lease === 'object' && !Array.isArray(output.lease)
+        ? output.lease as Record<string, unknown> : null;
+      return {
+        consistent: output.status === 'opened' && output.changed === true
+          && lease?.taskId === registration.taskId
+          && lease.controlGeneration === registration.controlGeneration
+          && lease.controllerInstanceDigest === registration.controllerInstanceDigest
+          && registration.taskId === manifest.taskId
+          && registration.controlGeneration === manifest.generation
+      };
+    }
+    if (request.command === 'verify') {
+      const binding = output.binding && typeof output.binding === 'object' && !Array.isArray(output.binding)
+        ? output.binding as Record<string, unknown> : null;
+      return {
+        consistent: output.status === 'verified' && output.changed === false
+          && binding?.taskId === registration.taskId
+          && binding.controlGeneration === registration.controlGeneration
+          && binding.controllerInstanceDigest === registration.controllerInstanceDigest
+      };
+    }
+    return { consistent: false };
+  } catch (error) {
+    return { consistent: request.family === 'codex-controller' && request.command === 'close'
+      && (error as { code?: string }).code === 'CODEX_SANDBOX_CONTROLLER_REGISTRATION_MISSING'
+      && output?.status === 'closed' && typeof output.changed === 'boolean' };
+  }
+}
+
+function orchestrationDomainEvidence(
+  operation: ReturnType<typeof findSandboxControlRecoveryOperation>,
+  terminalResult: ReturnType<typeof readSandboxControlTerminalResult>,
+  output: Record<string, unknown> | null,
+  run: ReturnType<typeof readRun> | null
+): Readonly<Record<string, unknown>> {
+  if (!operation || !output) return { consistent: false };
+  const outputRun = output.run && typeof output.run === 'object' && !Array.isArray(output.run)
+    ? output.run as Record<string, unknown> : null;
+  const runMatches = outputRun === null ? run === null : run !== null && JSON.stringify(run) === JSON.stringify(outputRun);
+  if (operation.class === 'read-only') {
+    return {
+      consistent: output.status === terminalResult.status && output.changed === terminalResult.changed && runMatches,
+      snapshotValid: true,
+      status: run?.status ?? terminalResult.status,
+      pendingDelegation: run?.pendingDelegation ?? null
+    };
+  }
+  if (!run || !outputRun) return { consistent: false };
+  return {
+    consistent: output.status === terminalResult.status && output.changed === terminalResult.changed && runMatches,
+    status: run.status,
+    pendingDelegation: run.pendingDelegation
+  };
+}
+
+function readRecoveryDomain(
+  manifest: SandboxControlManifest,
+  manifestPath: string,
+  request: SandboxControlRequest,
+  operation: ReturnType<typeof findSandboxControlRecoveryOperation>,
+  terminalResult: ReturnType<typeof readSandboxControlTerminalResult>,
+  payloadOutput: string | null
+): RecoveryDomainEvidence {
+  if (!operation) return { domain: null };
+  const taskRef = request.family === 'task-finalization' || request.family === 'task-workflow'
+    ? manifest.taskId
+    : 'args' in request ? request.args[0] ?? null : manifest.taskId;
+  const output = parseControlOutput(payloadOutput);
+  if (!taskRef && operation.family !== 'task-create' && operation.family !== 'codex-controller') {
+    return { domain: null };
+  }
+
+  if (operation.family === 'task-lifecycle') {
+    if (!taskRef || !terminalResult.targetState) return { domain: null };
+    const journal = readLifecycleJournalEvidence(manifest.repoRoot, taskRef);
+    try {
+      const resolved = resolveTaskRef(taskRef, { repoRoot: manifest.repoRoot });
+      const shortIds = loadShortIdByTaskId(manifest.repoRoot);
+      const shortIdMatches = terminalResult.targetState === 'active'
+        ? shortIds.has(resolved.ok ? resolved.taskId : taskRef)
+        : !shortIds.has(resolved.ok ? resolved.taskId : taskRef);
+      return {
+        domain: { consistent: resolved.ok && resolved.state === terminalResult.targetState && shortIdMatches },
+        journal
+      };
+    } catch {
+      return { domain: { consistent: false }, journal };
+    }
+  }
+
+  if (operation.family === 'task-orchestration') {
+    if (!taskRef) return { domain: null };
+    try {
+      const resolved = resolveTaskRef(taskRef, { repoRoot: manifest.repoRoot });
+      if (!resolved.ok) return { domain: { consistent: false } };
+      const run = readRun(resolved.taskDir);
+      if (!run && operation.class !== 'read-only') return { domain: { consistent: false } };
+      if (operation.class === 'route.clean-completion') {
+        const snapshot = captureRepositorySnapshot(manifest.repoRoot);
+        const metadata = parseTypedTaskFrontmatter(fs.readFileSync(resolved.taskMdPath, 'utf8'));
+        const completion = run?.completionEvidence ?? null;
+        const consistent = run !== null && completion !== null
+          && terminalResult.completionEvidence !== null
+          && isDeepStrictEqual(completion, terminalResult.completionEvidence);
+        return {
+          domain: {
+            consistent,
+            status: run?.status ?? null,
+            pendingDelegation: run?.pendingDelegation ?? null,
+            completionEvidence: completion,
+            snapshot,
+            lastReviewedCommit: metadata.last_reviewed_commit
+          }
+        };
+      }
+      return { domain: orchestrationDomainEvidence(operation, terminalResult, output, run) };
+    } catch {
+      return { domain: { consistent: false } };
+    }
+  }
+
+  if (operation.family === 'task-create') {
+    return { domain: taskCreateDomainEvidence(manifest, output) };
+  }
+  if (operation.family === 'codex-controller') {
+    return { domain: controllerDomainEvidence(manifest, manifestPath, request, output) };
+  }
+  if (operation.family === 'task-workflow') {
+    return {
+      domain: { consistent: output?.status === terminalResult.status && output.changed === terminalResult.changed, snapshotValid: true }
+    };
+  }
+  return { domain: null };
+}
+
+function readCommittedCriticalPhases(manifest: SandboxControlManifest, requestId: string): readonly string[] {
+  return SANDBOX_CONTROL_REQUIRED_COMPLETION_PHASES.filter((phase) => {
+    try {
+      readSandboxControlTransition(manifest, requestId, phase);
+      return true;
+    } catch {
+      return false;
+    }
+  });
+}
+
 function recoveryResponse(
   manifest: SandboxControlManifest,
+  manifestPath: string,
   request: SandboxControlRequest,
   evidence: ReturnType<typeof readSandboxControlResultEvidence>,
-  payload: ReturnType<typeof readSandboxControlPayload> | null
+  payload: ReturnType<typeof readSandboxControlPayload> | null,
+  terminalResult: ReturnType<typeof readSandboxControlTerminalResult>
 ): SandboxControlResponse | null {
+  const operationName = recoveryOperationKey(request, terminalResult, payload?.stdout);
+  const operation = operationName ? findSandboxControlRecoveryOperation(request.family, operationName) : null;
+  if (!operation) return null;
+  if (payload) {
+    const payloadTerminal = createSandboxControlTerminalResult(manifest, {
+      id: request.id, family: request.family, operation: operationName
+    }, payload.stdout);
+    if (JSON.stringify(payloadTerminal) !== JSON.stringify(terminalResult)) return unknown(request.id);
+  }
+  const finalization = request.family === 'task-finalization' ? finalizationRecoveryResponse(manifest, request.id, 0) : null;
+  if (evidence.exitCode === 0 && finalization?.status === 'deferred') return null;
+  if (evidence.exitCode === 0 && request.family === 'task-workflow' && request.authority?.phase === 'task-event.completed') {
+    try {
+      const registration = readCodexControllerRegistration(manifestPath);
+      const recovered = recoverLifecycleRecoveryOperation(request.authority, {
+        repoRoot: manifest.repoRoot,
+        capabilityStore: createCodexCapabilityStore(),
+        buildIdentity: computeLifecycleBuildIdentity(manifest.repoRoot),
+        controllerBinding: {
+          instanceDigest: registration.controllerInstanceDigest,
+          controlGeneration: registration.controlGeneration
+        }
+      });
+      if (recovered.status !== 'committed') return null;
+    } catch (error) {
+      appendBrokerAudit(manifest, 'lifecycle-authority-recovery-failed', {
+        ...requestAuditFields(manifest, request),
+        errorCode: error instanceof Error ? error.name : 'LIFECYCLE_AUTHORITY_RECOVERY_FAILED'
+      });
+      return null;
+    }
+  }
+  const recovery: RecoveryDomainEvidence = finalization
+    ? { domain: { consistent: finalization.status === 'matched' } }
+    : readRecoveryDomain(manifest, manifestPath, request, operation, terminalResult, payload?.stdout ?? null);
+  const binding = operationRecoveryBinding(request.id, manifest.generation, manifest.taskId, request.family, operationName!);
+  const decision = classifySandboxControlRecovery({
+    operation,
+    binding,
+    startedCommitted: true,
+    terminalResult,
+    criticalPhases: readCommittedCriticalPhases(manifest, request.id),
+    domain: recovery.domain,
+    journal: recovery.journal
+  });
+  if (decision.outcome === 'unknown' || decision.outcome === 'in-progress') return unknown(request.id);
+  if (decision.outcome === 'not-executed') return notExecuted(request.id);
+  if (decision.outcome !== 'success' && decision.outcome !== 'failure') return null;
   if (request.family === 'task-finalization' && evidence.exitCode === 0) {
-    const finalization = finalizationRecoveryResponse(manifest, request.id, evidence.exitCode);
-    return finalization.status === 'matched' ? finalization.response ?? null : null;
+    if (finalization?.status !== 'matched') return null;
+    return finalization.response ?? null;
   }
-  return genericRecoveryResponse(request.id, evidence, payload);
+  return genericRecoveryResponse(request, evidence.exitCode, payload);
 }
 
 function terminalMatchesEvidence(
   manifest: SandboxControlManifest,
+  manifestPath: string,
   request: SandboxControlRequest,
   response: SandboxControlResponse,
   evidence: ReturnType<typeof readSandboxControlResultEvidence>,
   payload: ReturnType<typeof readSandboxControlPayload> | null,
-  payloadInvalid: boolean
+  payloadInvalid: boolean,
+  terminalResult: ReturnType<typeof readSandboxControlTerminalResult> | null
 ): { valid: boolean; payloadReferenced: boolean } {
   if (request.family === 'task-finalization' && evidence.exitCode === 0) {
-    const expected = recoveryResponse(manifest, request, evidence, payload);
+    if (!terminalResult) return { valid: false, payloadReferenced: false };
+    const expected = recoveryResponse(manifest, manifestPath, request, evidence, payload, terminalResult);
     return {
       valid: expected !== null && JSON.stringify(response) === JSON.stringify(expected),
       payloadReferenced: false
@@ -267,8 +679,10 @@ function terminalMatchesEvidence(
     };
   }
   if (response.outputState === 'unavailable') {
-    const expected = genericRecoveryResponse(request.id, evidence, null);
-    return { valid: JSON.stringify(response) === JSON.stringify(expected), payloadReferenced: false };
+    const causes = ['recovery', 'publish'] as const;
+    const valid = causes.some((cause) => JSON.stringify(response)
+      === JSON.stringify(genericRecoveryResponse(request, evidence.exitCode, null, cause)));
+    return { valid, payloadReferenced: false };
   }
   return {
     valid: response.payload === undefined
@@ -282,9 +696,20 @@ function publishExecutionResult(
   manifest: SandboxControlManifest,
   request: SandboxControlRequest,
   result: SandboxControlExecutionResult,
+  broker: BrokerOwner,
   brokerOwns: () => boolean
 ): boolean {
   const normalized = sanitizeSandboxControlResult(manifest, result);
+  writeSandboxControlTerminalResult(manifest, {
+    id: request.id,
+    family: request.family,
+    operation: operationKey(request, normalized.stdout)
+  }, normalized.stdout);
+  if (fs.existsSync(path.join(manifest.processingDir, request.id, 'transitions'))) {
+    criticalRequestPhase(manifest, request, 'completed', normalized.exitCode === 0 ? 'success' : 'failure');
+    criticalRequestPhase(manifest, request, 'evidence-written', normalized.exitCode === 0 ? 'success' : 'failure');
+    criticalRequestPhase(manifest, request, 'publish-authorized', normalized.exitCode === 0 ? 'success' : 'failure');
+  }
   let terminal: SandboxControlResponse | null = null;
   if (request.family === 'task-finalization') {
     const finalization = finalizationRecoveryResponse(manifest, request.id, normalized.exitCode);
@@ -299,7 +724,7 @@ function publishExecutionResult(
     if (sandboxControlEncodedJsonBytes(inline) <= SANDBOX_CONTROL_MAX_TERMINAL_RECORD_BYTES) {
       terminal = inline;
     }
-    let payload = null;
+    let payload: ReturnType<typeof createSandboxControlPayload> | null = null;
     if (!terminal) {
       try {
         payload = createSandboxControlPayload(manifest, request.id, normalized);
@@ -312,21 +737,19 @@ function publishExecutionResult(
       } catch {
         payload = null;
       }
-      terminal = {
-        version: 2,
-        id: request.id,
-        phase: 'completed',
-        exitCode: normalized.exitCode,
-        stdout: '',
-        stderr: payload ? '' : 'SANDBOX_CONTROL_OUTPUT_UNAVAILABLE: output payload was not retained\n',
-        error: null,
-        outputState: payload ? 'available' : 'unavailable',
-        payload: payload ? payloadReference(payload) : null
-      };
+      terminal = genericRecoveryResponse(request, normalized.exitCode, payload, 'publish');
     }
   }
   if (!brokerOwns()) return false;
-  return writeSandboxControlResponse(manifest, terminal);
+  if (request.family === 'task-finalization' && normalized.exitCode === 0) {
+    const view = publishFinalizationTaskView(manifest, broker, request.id, 'healthy', null, null);
+    if (view.state === 'unknown') return false;
+  }
+  const committed = writeSandboxControlResponse(manifest, terminal);
+  if (committed && fs.existsSync(path.join(manifest.processingDir, request.id, 'transitions'))) {
+    criticalRequestPhase(manifest, request, 'published-committed', normalized.exitCode === 0 ? 'success' : 'failure');
+  }
+  return committed;
 }
 
 function writeAcceptedResponse(manifest: SandboxControlManifest, response: SandboxControlResponse): void {
@@ -391,21 +814,40 @@ function bindingReason(manifest: SandboxControlManifest): string | null {
   }
 }
 
-function recoverProcessing(manifest: SandboxControlManifest, brokerOwns: () => boolean): boolean {
+function assertCurrentSandboxControlIdentity(manifest: SandboxControlManifest, manifestPath: string): void {
+  const result = validateSandboxControlIdentity({
+    publicStatusDir: manifest.publicStatusDir,
+    root: path.dirname(path.resolve(manifestPath)),
+    mode: manifest.mode,
+    taskId: manifest.taskId,
+    generation: manifest.generation,
+    controlRootId: manifest.controlRootId
+  });
+  if (result.state !== 'valid') {
+    throw new Error(`SANDBOX_CONTROL_IDENTITY_${result.state.replaceAll('-', '_').toUpperCase()}`);
+  }
+}
+
+function recoverProcessing(manifest: SandboxControlManifest, manifestPath: string, broker: BrokerOwner, brokerOwns: () => boolean): boolean {
   for (const entry of fs.readdirSync(manifest.processingDir, { withFileTypes: true })) {
     if (!entry.isDirectory() || !/^[a-f0-9-]{16,64}$/.test(entry.name)) continue;
     if (!brokerOwns()) return false;
     const descriptor = executionPath(manifest, entry.name);
     const existingResponse = responsePath(manifest, entry.name);
     const processingDirectory = path.join(manifest.processingDir, entry.name);
+    const transitionsDirectory = path.join(processingDirectory, 'transitions');
+    const transitionProtocolActive = fs.existsSync(transitionsDirectory);
+    const startedCommitted = fs.existsSync(path.join(transitionsDirectory, 'started-committed.json'));
     let payloadReferenced = false;
     if (fs.existsSync(descriptor)) {
       const execution = readExecution(descriptor);
       let resultEvidence: ReturnType<typeof readSandboxControlResultEvidence> | null = null;
+      let terminalResult: ReturnType<typeof readSandboxControlTerminalResult> | null = null;
       let payload: ReturnType<typeof readSandboxControlPayload> | null = null;
       let payloadInvalid = false;
       let request: SandboxControlRequest | null = null;
       let existingTerminalResponse: SandboxControlResponse | null = null;
+      let terminalReconciled = false;
       try {
         const rawRequest = JSON.parse(fs.readFileSync(path.join(processingDirectory, 'request.json'), 'utf8')) as Record<string, unknown>;
         request = validateSandboxControlRequest(rawRequest, manifest, {
@@ -425,6 +867,18 @@ function recoverProcessing(manifest: SandboxControlManifest, brokerOwns: () => b
           resultEvidence = null;
         }
       }
+      const terminalResultPathValue = path.join(processingDirectory, 'terminal-result.json');
+      if (fs.existsSync(terminalResultPathValue)) {
+        try {
+          terminalResult = readSandboxControlTerminalResult(terminalResultPathValue);
+          if (terminalResult.requestId !== entry.name || terminalResult.generation !== manifest.generation
+            || !request || !terminalResultMatchesRequest(request, terminalResult)) {
+            terminalResult = null;
+          }
+        } catch {
+          terminalResult = null;
+        }
+      }
       const publishedPayloadPath = payloadPath(manifest, entry.name);
       if (fs.existsSync(publishedPayloadPath)) {
         try {
@@ -437,11 +891,21 @@ function recoverProcessing(manifest: SandboxControlManifest, brokerOwns: () => b
           payloadInvalid = true;
         }
       }
+      if (transitionProtocolActive && startedCommitted && !terminalResult) {
+        if (!brokerOwns()) return false;
+        if (!terminateSandboxControlExecution(execution)) {
+          throw new Error(`SANDBOX_CONTROL_EXECUTION_STILL_RUNNING: ${entry.name}`);
+        }
+        appendDiagnosticAudit(manifest, 'orphan-tree-terminated', { requestId: entry.name });
+        writeSandboxControlResponse(manifest, unknown(entry.name));
+        continue;
+      }
+      if (transitionProtocolActive && !startedCommitted && terminalResult) continue;
       if (!terminateSandboxControlExecution(execution)) {
         throw new Error(`SANDBOX_CONTROL_EXECUTION_STILL_RUNNING: ${entry.name}`);
       }
       if (!brokerOwns()) return false;
-      appendSandboxControlAudit(manifest, 'orphan-tree-terminated', { requestId: entry.name });
+      appendDiagnosticAudit(manifest, 'orphan-tree-terminated', { requestId: entry.name });
       let terminal = false;
       if (fs.existsSync(existingResponse)) {
         try {
@@ -459,7 +923,7 @@ function recoverProcessing(manifest: SandboxControlManifest, brokerOwns: () => b
               || response.payload.stdoutSha256 !== payload.stdoutSha256
               || response.payload.stderrSha256 !== payload.stderrSha256) throw new Error('payload missing or mismatched');
             payloadReferenced = true;
-          } else if (terminal && (response.outputState !== undefined
+          } else if (terminal && ((response.outputState !== undefined && response.outputState !== 'unavailable')
             || response.payload !== undefined && response.payload !== null)) {
             throw new Error('payload state invalid');
           }
@@ -470,20 +934,61 @@ function recoverProcessing(manifest: SandboxControlManifest, brokerOwns: () => b
       }
       if (terminal && (!request || !resultEvidence)) continue;
       if (terminal && request && resultEvidence) {
-        const reconciliation = terminalMatchesEvidence(manifest, request, existingTerminalResponse!, resultEvidence, payload, payloadInvalid);
+        if (!terminalResult && request.family !== 'task-create') continue;
+        const reconciliation = terminalMatchesEvidence(
+          manifest,
+          manifestPath,
+          request,
+          existingTerminalResponse!,
+          resultEvidence,
+          payload,
+          payloadInvalid,
+          terminalResult
+        );
         if (!reconciliation.valid) continue;
+        terminalReconciled = true;
         payloadReferenced = reconciliation.payloadReferenced;
+        if (request.family === 'task-finalization' && resultEvidence.exitCode === 0) {
+          const view = publishFinalizationTaskView(manifest, broker, request.id, 'starting', null, null);
+          if (view.state === 'unknown') continue;
+        }
+      }
+      if (!terminalResult && !terminalReconciled) {
+        if (terminal) continue;
+        if (!brokerOwns()) return false;
+        if (!resultEvidence || !request || payloadInvalid) continue;
+        if (request.family === 'task-create' && resultEvidence.exitCode === 0 && payload === null) {
+          writeSandboxControlResponse(manifest, genericRecoveryResponse(request, resultEvidence.exitCode, null));
+          terminalReconciled = true;
+          terminal = true;
+        } else {
+          writeSandboxControlResponse(manifest, unknown(entry.name));
+          continue;
+        }
       }
       if (!terminal) {
         if (!brokerOwns()) return false;
         if (!resultEvidence || !request || payloadInvalid) continue;
-        const recovered = recoveryResponse(manifest, request, resultEvidence, payload);
+        const recovered = recoveryResponse(manifest, manifestPath, request, resultEvidence, payload, terminalResult!);
         if (!recovered) continue;
+        if (request.family === 'task-finalization' && resultEvidence.exitCode === 0) {
+          const view = publishFinalizationTaskView(manifest, broker, request.id, 'starting', null, null);
+          if (view.state === 'unknown') continue;
+        }
         writeSandboxControlResponse(manifest, recovered);
+        const preserveRecoveryEvidence = recovered.error?.code === 'SANDBOX_CONTROL_RESULT_UNKNOWN';
+        if (transitionProtocolActive && !preserveRecoveryEvidence) {
+          writeSandboxControlTransition(manifest, { requestId: entry.name, phase: 'recovered' });
+        }
+        if (preserveRecoveryEvidence) continue;
         payloadReferenced = Boolean(payload) && request.family !== 'task-finalization';
       }
     } else {
       if (!brokerOwns()) return false;
+      if (transitionProtocolActive && startedCommitted) {
+        writeSandboxControlResponse(manifest, unknown(entry.name));
+        continue;
+      }
       writeSandboxControlResponse(manifest, notExecuted(entry.name));
     }
     if (!brokerOwns()) return false;
@@ -499,7 +1004,13 @@ function delay(ms: number): Promise<void> {
 }
 
 export function sandboxControlSafeEnv(env: NodeJS.ProcessEnv = process.env): NodeJS.ProcessEnv {
-  return Object.fromEntries(Object.entries(env).filter(([key]) => !key.toUpperCase().startsWith('AGENT_INFRA_CONTROL_')));
+  return Object.fromEntries(Object.entries(env).filter(([key]) => {
+    const normalized = key.toUpperCase();
+    return !normalized.startsWith('AGENT_INFRA_CONTROL_')
+      && normalized !== 'AGENT_INFRA_TASK_ID'
+      && normalized !== 'AGENT_INFRA_RUNTIME_DIR'
+      && normalized !== 'AGENT_INFRA_EXECUTOR_MANIFEST';
+  }));
 }
 
 export async function serveSandboxControl(
@@ -519,6 +1030,7 @@ export async function serveSandboxControl(
   const prepareExecution = options.prepareExecution ?? prepareSandboxControlExecution;
   const manifest = readSandboxControlManifest(manifestPath);
   const root = path.dirname(manifestPath);
+  assertCurrentSandboxControlIdentity(manifest, manifestPath);
   const startTime = getProcessStartTime(process.pid);
   if (!startTime) throw new Error('SANDBOX_CONTROL_BROKER_IDENTITY_UNAVAILABLE');
   const brokerId = randomUUID();
@@ -562,6 +1074,25 @@ export async function serveSandboxControl(
     releaseStartup();
   }
   let active: ActiveExecution | null = null;
+  let startupReceipt: unknown = null;
+  if (manifest.taskId) {
+    try {
+      startupReceipt = readTaskFinalizationReceipt(manifest.repoRoot, manifest.taskId);
+    } catch {
+      // Preserve malformed receipt evidence as unknown rather than treating it as no receipt.
+      startupReceipt = {};
+    }
+  }
+  let taskView = taskViewForManifest({
+    ...manifest,
+    receipt: startupReceipt
+  });
+  try {
+    const previous = readSandboxControlStatus(manifest.publicStatusDir);
+    if (previous.generation === manifest.generation) taskView = mergeSandboxTaskView(taskView, previous.taskView);
+  } catch {
+    // A fresh control root has no previous task-view projection.
+  }
   let lastState = '';
   let lastStatusAt = 0;
   let nextBindingCheckAt = 0;
@@ -572,16 +1103,37 @@ export async function serveSandboxControl(
   let bindingBackoffMs: number = timing.parkedBindingInitialMs;
   try {
     if (!brokerOwns()) return;
-    writeSandboxControlStatus(manifest, broker, 'starting', null, null);
+    if (taskView.state === 'current' && taskView.observedSource === 'completed') {
+      // Recheck durable re-entry evidence before publishing a trusted startup view.
+      const unverified = { ...taskView, state: 'unknown' as const,
+        reasonCode: 'SANDBOX_COMPLETED_REENTRY_EVIDENCE_INVALID' };
+      try {
+        taskView = await completedReentryView(manifest, inspectContainer) ?? unverified;
+      } catch {
+        taskView = unverified;
+      }
+      if (!brokerOwns()) return;
+    }
+    writeSandboxControlStatus(manifest, broker, 'starting', null, null, Date.now(), taskView);
     if (!brokerOwns()) return;
-    appendSandboxControlAudit(manifest, 'broker-start', { pid: broker.pid });
-    if (!recoverProcessing(manifest, brokerOwns)) return;
+    appendBrokerAudit(manifest, 'broker-start', {
+      pid: broker.pid,
+      brokerId: broker.brokerId
+    });
+    if (!recoverProcessing(manifest, manifestPath, broker, brokerOwns)) return;
+    try {
+      const published = readSandboxControlStatus(manifest.publicStatusDir);
+      if (published.generation === manifest.generation) taskView = published.taskView;
+    } catch {
+      // The regular heartbeat will publish an invalid or missing projection as unknown.
+    }
     while (!signal.aborted) {
       let settledExecution: ActiveExecution | null = null;
       if (!brokerOwns()) break;
       let current: SandboxControlManifest;
       try {
         current = readSandboxControlManifest(manifestPath);
+        assertCurrentSandboxControlIdentity(current, manifestPath);
       } catch {
         break;
       }
@@ -612,7 +1164,7 @@ export async function serveSandboxControl(
           nextContainerHeartbeatAt = Date.now() + timing.containerHeartbeatMs;
         } else if (observation.state === 'unknown') {
           containerReasonCode = 'SANDBOX_CONTROL_CONTAINER_UNKNOWN';
-          appendSandboxControlAudit(manifest, 'container-heartbeat-unknown', { reason: observation.reason });
+          appendDiagnosticAudit(manifest, 'container-heartbeat-unknown', { reason: observation.reason });
           const backoff = nextSandboxControlBackoff(containerBackoffMs, timing.slowCheckMs);
           nextContainerHeartbeatAt = Date.now() + backoff.delayMs;
           containerBackoffMs = backoff.nextDelayMs;
@@ -628,7 +1180,7 @@ export async function serveSandboxControl(
           } catch (error) {
             if (!brokerOwns()) break;
             containerReasonCode = 'SANDBOX_CONTROL_CONTAINER_ABSENT_GC_FAILED';
-            appendSandboxControlAudit(manifest, 'container-gc-failed', { reason: controlError(error).code });
+            appendDiagnosticAudit(manifest, 'container-gc-failed', { reason: controlError(error).code });
             const backoff = nextSandboxControlBackoff(containerBackoffMs, timing.slowCheckMs);
             nextContainerHeartbeatAt = Date.now() + backoff.delayMs;
             containerBackoffMs = backoff.nextDelayMs;
@@ -647,7 +1199,7 @@ export async function serveSandboxControl(
         if (!brokerOwns()) break;
         if (cleanupStaleSandboxControlLease(manifest)) {
           if (!brokerOwns()) break;
-          appendSandboxControlAudit(manifest, 'lease-stale-cleanup');
+          appendBrokerAudit(manifest, 'lease-stale-cleanup');
         }
         if (readActiveLease(manifest)) reasonCode = 'SANDBOX_CONTROL_HANDOFF_ACTIVE';
       } catch {
@@ -667,25 +1219,53 @@ export async function serveSandboxControl(
       }
       reasonCode ??= containerReasonCode;
       reasonCode ??= bindingReasonCode;
+      if (!reasonCode && !active && taskView.state !== 'current') {
+        try {
+          const reentered = await completedReentryView(manifest, inspectContainer);
+          if (reentered && brokerOwns() && !readActiveLease(manifest) && !bindingCheck(manifest)) {
+            taskView = reentered;
+          }
+        } catch {
+          // Invalid or changed re-entry evidence never clears the existing task view.
+        }
+      }
       const state = reasonCode ? 'parked' : active ? 'busy' : 'healthy';
       const stateKey = `${state}:${reasonCode ?? ''}:${active?.request.id ?? ''}`;
       if (brokerOwns() && (stateKey !== lastState || now - lastStatusAt >= timing.controlTickMs)) {
-        writeSandboxControlStatus(manifest, broker, state, reasonCode, active?.request.id ?? null, now);
+        writeSandboxControlStatus(manifest, broker, state, reasonCode, active?.request.id ?? null, now, taskView);
         lastStatusAt = now;
       }
       if (brokerOwns() && stateKey !== lastState) {
-        appendSandboxControlAudit(manifest, 'broker-state', { state, reasonCode, requestId: active?.request.id ?? null });
+        appendBrokerAudit(manifest, 'broker-state', { state, reasonCode, requestId: active?.request.id ?? null });
         lastState = stateKey;
       }
       if (settledExecution) {
         if (!brokerOwns()) break;
         let terminalCommitted = false;
         if (settledExecution.result && settledExecution.resultEvidenceWritten) {
-          terminalCommitted = publishExecutionResult(manifest, settledExecution.request, settledExecution.result, brokerOwns);
+          if (!consumeLifecycleAuthorityForResult(manifest, settledExecution)) {
+            active = settledExecution;
+            continue;
+          }
+          terminalCommitted = publishExecutionResult(manifest, settledExecution.request, settledExecution.result, broker, brokerOwns);
+          if (terminalCommitted && settledExecution.request.family === 'task-finalization') {
+            try {
+              const published = readSandboxControlStatus(manifest.publicStatusDir);
+              if (published.generation === manifest.generation) taskView = published.taskView;
+            } catch {
+              taskView = { state: 'unknown', taskId: manifest.taskId, observedSource: 'unknown', receipt: null, reasonCode: 'SANDBOX_TASK_VIEW_STATUS_INVALID' };
+            }
+          }
         } else {
           terminalCommitted = writeSandboxControlResponse(manifest, unknown(settledExecution.request.id));
         }
         if (!terminalCommitted) return;
+        appendBrokerAudit(manifest, 'executor-result-published', {
+          ...requestAuditFields(manifest, settledExecution.request),
+          resultAvailable: settledExecution.result !== null,
+          resultEvidenceWritten: settledExecution.resultEvidenceWritten,
+          ...(settledExecution.result ? resultAuditFields(settledExecution.result) : {})
+        });
         if (!brokerOwns()) break;
         removeAcceptedResponse(manifest, settledExecution.request.id);
         fs.rmSync(path.join(manifest.processingDir, settledExecution.request.id), { recursive: true, force: true });
@@ -697,12 +1277,20 @@ export async function serveSandboxControl(
         const id = name.slice(0, -5);
         const source = path.join(requestsDir, name);
         let claimed: string | null = null;
+        let validatedRequest: SandboxControlRequest | null = null;
+        let prepared: PreparedSandboxControlExecution | null = null;
         try {
           if (!brokerOwns()) {
             retiring = true;
             break;
           }
           claimed = claimRequest(manifest, source, id);
+          appendBrokerAudit(manifest, 'request-claimed', {
+            requestId: id,
+            requestSourcePath: source,
+            requestClaimedPath: claimed,
+            requestProcessingDir: path.dirname(claimed)
+          });
           if (!brokerOwns()) {
             retiring = true;
             break;
@@ -715,29 +1303,99 @@ export async function serveSandboxControl(
           if (reasonCode) throw new Error(reasonCode);
           if (active) throw new Error('SANDBOX_CONTROL_BUSY');
           const request = validateSandboxControlRequest(JSON.parse(fs.readFileSync(claimed, 'utf8')), manifest);
+          validatedRequest = request;
+          criticalRequestPhase(manifest, request, 'validated', 'in-progress');
+          appendBrokerAudit(manifest, 'request-validated', {
+            ...requestAuditFields(manifest, request),
+            requestPath: claimed
+          });
           if (bindingCheck(manifest)) throw new Error('SANDBOX_WORKTREE_BINDING_LOST');
           if (readActiveLease(manifest)) throw new Error('SANDBOX_CONTROL_HANDOFF_ACTIVE');
+          criticalRequestPhase(manifest, request, 'gated', 'in-progress');
+          appendBrokerAudit(manifest, 'request-gates-passed', {
+            ...requestAuditFields(manifest, request),
+            requestPath: claimed,
+            bindingChecked: true,
+            handoffLeaseChecked: true
+          });
+          criticalRequestPhase(manifest, request, 'reserved', 'in-progress');
           writeSandboxControlReservation(manifest, request.id, sandboxControlGenerationUsage(manifest));
-          const prepared = await prepareExecution({
+          appendBrokerAudit(manifest, 'executor-reservation-written', {
+            ...requestAuditFields(manifest, request),
+            requestPath: claimed,
+            executionPath: executionPath(manifest, request.id)
+          });
+          appendBrokerAudit(manifest, 'executor-prepare-start', {
+            ...requestAuditFields(manifest, request),
+            requestPath: claimed,
+            executorCwd: manifest.repoRoot,
+            executorEntry: options.internalCliPath ?? process.argv[1] ?? null
+          });
+          const lifecycleAuthority = lifecycleAuthorityForRequest(manifest, manifestPath, request);
+          if (lifecycleAuthority?.status === 'rejected') {
+            throw Object.assign(
+              new Error(lifecycleAuthority.error?.message ?? 'lifecycle authority was rejected'),
+              { code: lifecycleAuthority.error?.code ?? 'LIFECYCLE_AUTHORITY_REJECTED' }
+            );
+          }
+          prepared = await prepareExecution({
             manifest, manifestPath, request, requestPath: claimed,
-            internalCliPath: options.internalCliPath ?? process.argv[1]!
+            internalCliPath: options.internalCliPath ?? process.argv[1]!,
+            ...(lifecycleAuthority ? { lifecycleAuthority } : {})
+          });
+          const preparedExecution = prepared;
+          if (!preparedExecution) throw new Error('SANDBOX_CONTROL_EXECUTION_PREPARE_INVALID');
+          criticalRequestPhase(manifest, request, 'prepared', 'in-progress', `${preparedExecution.execution.child.pid}`);
+          appendBrokerAudit(manifest, 'executor-prepared', {
+            ...requestAuditFields(manifest, request),
+            requestPath: claimed,
+            executorCwd: manifest.repoRoot,
+            childPid: preparedExecution.execution.child.pid,
+            childStartTime: preparedExecution.execution.child.startTime,
+            childProcessGroupId: preparedExecution.execution.child.processGroupId,
+            executionPath: executionPath(manifest, request.id)
           });
           const execution: ActiveExecution = {
-            request, prepared, result: null, resultEvidenceWritten: false, failure: null, settled: false
+            request, prepared: preparedExecution, lifecycleAuthority, result: null,
+            resultEvidenceWritten: false, failure: null, settled: false
           };
           active = execution;
-          prepared.completion.then(
+          preparedExecution.completion.then(
             (result) => {
               execution.result = sanitizeSandboxControlResult(manifest, result);
+              appendBrokerAudit(manifest, 'executor-completed', {
+                ...requestAuditFields(manifest, request),
+                ...resultAuditFields(execution.result),
+                childPid: preparedExecution.execution.child.pid,
+                childStartTime: preparedExecution.execution.child.startTime
+              });
               try {
                 writeSandboxControlResultEvidence(manifest, request.id, execution.result);
                 execution.resultEvidenceWritten = true;
                 execution.settled = true;
+                appendBrokerAudit(manifest, 'executor-result-evidence-written', {
+                  ...requestAuditFields(manifest, request),
+                  resultPath: path.join(manifest.processingDir, request.id, 'result.json'),
+                  ...resultAuditFields(execution.result)
+                });
               } catch (error) {
                 execution.failure = error;
+                appendBrokerAudit(manifest, 'executor-result-evidence-failed', {
+                  ...requestAuditFields(manifest, request),
+                  errorType: error instanceof Error ? error.name : typeof error,
+                });
               }
             },
-            (error) => { execution.failure = error; execution.settled = true; }
+            (error) => {
+              execution.failure = error;
+              execution.settled = true;
+              appendBrokerAudit(manifest, 'executor-failed', {
+                ...requestAuditFields(manifest, request),
+                childPid: preparedExecution.execution.child.pid,
+                childStartTime: preparedExecution.execution.child.startTime,
+                errorType: error instanceof Error ? error.name : typeof error,
+              });
+            }
           );
           if (!brokerOwns()) {
             prepared.terminate(false);
@@ -751,9 +1409,16 @@ export async function serveSandboxControl(
             retiring = true;
             continue;
           }
+          criticalRequestPhase(manifest, request, 'accepted-authorized', 'in-progress');
           writeAcceptedResponse(manifest, {
             version: 2, id, phase: 'accepted', exitCode: null, stdout: '', stderr: '', error: null
           });
+          writeSandboxControlTransition(manifest, { requestId: request.id, phase: 'accepted-committed' });
+          appendBrokerAudit(manifest, 'request-accepted', {
+            ...requestAuditFields(manifest, request),
+            acceptedPath: acceptedResponsePath(manifest, id),
+            executionPhase: 'prepared'
+          });
           if (!brokerOwns()) {
             prepared.terminate(false);
             active = null;
@@ -761,8 +1426,19 @@ export async function serveSandboxControl(
             break;
           }
           try {
+            criticalRequestPhase(manifest, request, 'start-authorized', 'in-progress', `${prepared.execution.child.pid}`);
+            appendBrokerAudit(manifest, 'executor-start', {
+              ...requestAuditFields(manifest, request),
+              childPid: prepared.execution.child.pid,
+              childStartTime: prepared.execution.child.startTime,
+              executionPath: executionPath(manifest, request.id)
+            });
             prepared.start(brokerOwns);
           } catch (error) {
+            appendBrokerAudit(manifest, 'executor-start-failed', {
+              ...requestAuditFields(manifest, request),
+              errorType: error instanceof Error ? error.name : typeof error,
+            });
             const owned = brokerOwns();
             prepared.terminate(owned);
             if (!owned || !brokerOwns()) {
@@ -784,19 +1460,35 @@ export async function serveSandboxControl(
               retiring = true;
               break;
             }
-            appendSandboxControlAudit(manifest, 'executor-gate-failed', { requestId: id });
+            appendBrokerAudit(manifest, 'executor-gate-failed', { requestId: id });
             continue;
           }
         } catch (error) {
+          if (prepared) {
+            try { prepared.terminate(brokerOwns()); } catch { /* cleanup is best effort after a failed admission */ }
+            prepared = null;
+            active = null;
+          }
           if (!brokerOwns()) {
             retiring = true;
             break;
           }
+          const detail = controlError(error);
+          appendBrokerAudit(manifest, 'request-rejected', {
+            requestId: id,
+            requestFamily: validatedRequest?.family ?? null,
+            sandboxTaskId: manifest.taskId,
+            requestPath: claimed,
+            errorCode: detail.code,
+            errorRetryable: detail.retryable,
+            errorType: error instanceof Error ? error.name : typeof error,
+          });
           writeSandboxControlResponse(manifest, rejected(id, error));
           if (!brokerOwns()) {
             retiring = true;
             break;
           }
+          removeAcceptedResponse(manifest, id);
           if (claimed) fs.rmSync(path.dirname(claimed), { recursive: true, force: true });
         }
       }
@@ -818,7 +1510,8 @@ export async function serveSandboxControl(
         }
       }
       if (owned && active.result && active.resultEvidenceWritten) {
-        if (publishExecutionResult(manifest, active.request, active.result, brokerOwns)) {
+        if (consumeLifecycleAuthorityForResult(manifest, active)
+          && publishExecutionResult(manifest, active.request, active.result, broker, brokerOwns)) {
           if (brokerOwns()) {
             removeAcceptedResponse(manifest, active.request.id);
             fs.rmSync(path.join(manifest.processingDir, active.request.id), { recursive: true, force: true });
@@ -830,7 +1523,11 @@ export async function serveSandboxControl(
         const terminationConfirmed = active.prepared.terminate(owned);
         if (owned && brokerOwns() && active.request.family === 'task-finalization') {
           const recovered = finalizationRecoveryResponse(manifest, active.request.id, 0);
-          if (recovered.status === 'matched' && recovered.response && writeSandboxControlResponse(manifest, recovered.response)) {
+          const view = recovered.status === 'matched'
+            ? publishFinalizationTaskView(manifest, broker, active.request.id, 'healthy', null, null)
+            : null;
+          if (view?.state !== 'unknown' && recovered.status === 'matched' && recovered.response
+            && writeSandboxControlResponse(manifest, recovered.response)) {
             if (terminationConfirmed && brokerOwns()) {
               removeAcceptedResponse(manifest, active.request.id);
               fs.rmSync(path.join(manifest.processingDir, active.request.id), { recursive: true, force: true });
@@ -844,7 +1541,7 @@ export async function serveSandboxControl(
       }
     }
     if (brokerOwns()) {
-      appendSandboxControlAudit(manifest, 'broker-stop', { pid: broker.pid, brokerId: broker.brokerId });
+      appendDiagnosticAudit(manifest, 'broker-stop', { pid: broker.pid, brokerId: broker.brokerId });
       try {
         if (fs.readFileSync(brokerPath, 'utf8') === brokerRecord) fs.unlinkSync(brokerPath);
       } catch {