@fitlab-ai/agent-infra 0.11.1 → 0.11.3

package/lib/platform/verification-sync.ts

@@ -13,7 +13,7 @@ import { planInLabelUpdate, validateInLabelMapping } from "./in-label-sync.ts";
 import { readPrDeliveryFact } from "../task/pr-delivery-fact.ts";
 import { providerError, providerOperationContext, resourceIdentityNumber, unsupportedProviderOperation } from "./provider-bridge.ts";
 import { taskIssueIdentity } from "./task-identities.ts";
-import { renderTaskCommentResult } from "./issue-comments.ts";
+import { MARKERS, renderTaskCommentResult } from "./issue-comments.ts";
 import {
   CONTROL_MARKER_PATTERN,
   canonicalizeCommentBody,
@@ -279,7 +279,9 @@ async function fetchRemoteData(context: any, shared: VerificationShared): Promis
   }
   return {
     issue,
-    comments: facts.value.comments.map((comment: { id: string; body: string }) => ({ id: comment.id, body: comment.body })),
+    comments: facts.value.comments.map((comment: { id: string; body: string; createdSequence: number | null }) => ({
+      id: comment.id, body: comment.body, createdSequence: comment.createdSequence
+    })),
     prComments,
     prLabels: changeRequest?.labels || null,
     issueType: issueSnapshot
@@ -361,6 +363,21 @@ function checkCommentMarker(context: any, remoteData: any, shared: VerificationS
 
   const comment = findCommentByMarker(remoteData.comments, context.marker);
   if (comment) {
+    if (context.marker === MARKERS.summary(context.task.metadata.id)) {
+      const managed = remoteData.comments.filter((candidate: any) => {
+        const first = String(candidate.body || '').replace(/\r\n/g, '\n').split('\n', 1)[0] || '';
+        return first === MARKERS.task(context.task.metadata.id)
+          || first === MARKERS.summary(context.task.metadata.id)
+          || first.startsWith(`<!-- sync-issue:${context.task.metadata.id}:`);
+      });
+      if (managed.some((candidate: any) => !Number.isSafeInteger(candidate.createdSequence) || candidate.createdSequence < 1)) {
+        return shared.failResult(CHECK_TYPE, `Issue #${context.issueNumber} summary comment ordering is not provable`, "check_failed");
+      }
+      const summarySequence = comment.createdSequence;
+      if (!managed.every((candidate: any) => summarySequence >= candidate.createdSequence)) {
+        return shared.failResult(CHECK_TYPE, `Issue #${context.issueNumber} summary comment is not last among task-managed comments`, "check_failed");
+      }
+    }
     return shared.passResult(CHECK_TYPE, `Issue #${context.issueNumber} has expected comment marker`);
   }
 

package/lib/sandbox/control/client.ts

@@ -11,10 +11,8 @@ import {
   type SandboxControlRequest,
   type SandboxControlResponse,
   type SandboxTaskCreateRequest,
-  type SandboxTaskCommandRequest,
   type SandboxTaskFinalizationRequest,
-  type SandboxCodexControllerRequest,
-  type SandboxTaskWorkflowRequest
+  type SandboxCodexControllerRequest
 } from './protocol.ts';
 import type {
   CodexControllerLeaseProofV1,
@@ -26,8 +24,6 @@ import { readSandboxControlPayload, readSandboxControlStatus } from './state.ts'
 import type { TaskCreateCandidateV1 } from '../../task/create.ts';
 import { accessSandboxTaskView, taskViewFromStatus, type TaskViewAccessEffect } from './task-view.ts';
 import { readSandboxControlIdentitySentinel } from './identity-sentinel.ts';
-import type { TaskWorkflowRequest } from './task-workflow.ts';
-import type { LifecycleAuthorityRequestV1 } from '../../task/control-authority.ts';
 import { configuredShortIdLength, resolveShortIdReadOnly } from '../../task/short-id.ts';
 
 const SANDBOX_CONTROL_RESPONSE_SETTLE_MS = 250;
@@ -119,8 +115,6 @@ function preflight(
 
 function taskViewEffectForRequest(request: SandboxControlRequest): TaskViewAccessEffect | null {
   if (request.family === 'task-lifecycle' || request.family === 'task-finalization') return 'progress';
-  if (request.family === 'task-orchestration') return request.args[1] === 'status' ? 'diagnostic' : 'progress';
-  if (request.family === 'task-workflow') return request.workflow.operation === 'artifact-inspect' || request.workflow.operation === 'decision-next-id' ? 'diagnostic' : 'progress';
   return null;
 }
 
@@ -194,9 +188,7 @@ export function resolveVisibleActiveShortId(ref: string): string | null {
 // may be a documented short id. Compare canonical ids so a bound sandbox keeps
 // refusing other tasks without rejecting its own task's short id.
 function canonicalRequestTask(request: SandboxControlRequest): CanonicalRequestTask {
-  const ref = request.family === 'task-workflow'
-    ? request.workflow.taskId
-    : 'args' in request ? request.args[0] ?? null : null;
+  const ref = 'args' in request ? request.args[0] ?? null : null;
   if (!ref) return { kind: 'none' };
   if (CONTROL_TASK_ID_RE.test(ref)) return { kind: 'task', taskId: ref };
   if (!CONTROL_SHORT_ID_RE.test(ref)) return { kind: 'none' };
@@ -223,7 +215,7 @@ function exchangeSandboxControl(request: SandboxControlRequest, params: Readonly
         || (requestTask.kind === 'task' && requestTask.taskId !== identity.taskId))) {
       clientError('SANDBOX_CONTROL_IDENTITY_TOPOLOGY_MISMATCH', 'request task does not match the sandbox identity', false);
     }
-    if (identity.mode === 'branch-only' && (request.family === 'task-finalization' || request.family === 'task-workflow')) {
+    if (identity.mode === 'branch-only' && request.family === 'task-finalization') {
       clientError('SANDBOX_CONTROL_BRANCH_ONLY', 'branch-only sandboxes cannot finalize tasks', false);
     }
   }
@@ -384,7 +376,7 @@ export function requestSandboxControl(params: Readonly<{
   token?: string; generation?: string; timeoutMs?: number;
 }>): SandboxControlResponse {
   if (!isSandboxControlFamily(params.family)) clientError('SANDBOX_CONTROL_COMMAND_DENIED', `'${params.family}' is not allowed`, false);
-  if (params.family === 'task-create' || params.family === 'codex-controller' || params.family === 'task-finalization' || params.family === 'task-workflow') {
+  if (params.family === 'task-create' || params.family === 'codex-controller' || params.family === 'task-finalization') {
     clientError('SANDBOX_CONTROL_COMMAND_DENIED', `'${params.family}' requires a typed request`, false);
   }
   const auth = authority(params);
@@ -392,41 +384,13 @@ export function requestSandboxControl(params: Readonly<{
   const request: SandboxControlRequest = {
     version: 3, id: randomUUID(), ...auth, issuedAt,
     expiresAt: issuedAt + SANDBOX_CONTROL_ADMISSION_WINDOW_MS,
-    family: params.family as 'task-lifecycle' | 'task-orchestration', args: params.args,
+    family: params.family as 'task-lifecycle', args: params.args,
     controllerProcess: null,
     controllerProof: null
   };
   return exchangeSandboxControl(request, params);
 }
 
-export function requestSandboxTaskControl(params: Readonly<{
-  family: 'task-lifecycle' | 'task-orchestration';
-  args: string[];
-  controllerProof: CodexControllerLeaseProofV1 | null;
-  authority?: LifecycleAuthorityRequestV1;
-  channelDir?: string;
-  statusDir?: string;
-  token?: string;
-  generation?: string;
-  timeoutMs?: number;
-}>): SandboxControlResponse {
-  const auth = authority(params);
-  const issuedAt = Date.now();
-  const request: SandboxTaskCommandRequest = {
-    version: 3,
-    id: params.authority?.requestId ?? randomUUID(),
-    ...auth,
-    issuedAt,
-    expiresAt: issuedAt + SANDBOX_CONTROL_ADMISSION_WINDOW_MS,
-    family: params.family,
-    args: params.args,
-    controllerProcess: null,
-    controllerProof: params.authority ? null : params.controllerProof,
-    ...(params.authority ? { authority: params.authority } : {})
-  };
-  return exchangeSandboxControl(request, params);
-}
-
 export function requestSandboxTaskFinalization(params: Readonly<{
   agent: string;
   channelDir?: string;
@@ -455,33 +419,6 @@ export function requestSandboxTaskFinalization(params: Readonly<{
   return exchangeSandboxControl(request, params);
 }
 
-export function requestSandboxTaskWorkflow(params: Readonly<{
-  workflow: TaskWorkflowRequest;
-  channelDir?: string;
-  statusDir?: string;
-  token?: string;
-  generation?: string;
-  timeoutMs?: number;
-  authority?: LifecycleAuthorityRequestV1;
-}>): SandboxControlResponse {
-  const auth = authority(params);
-  const issuedAt = Date.now();
-  const request: SandboxTaskWorkflowRequest = {
-    version: 3,
-    id: params.workflow.id,
-    ...auth,
-    issuedAt,
-    expiresAt: issuedAt + SANDBOX_CONTROL_ADMISSION_WINDOW_MS,
-    family: 'task-workflow',
-    args: [],
-    controllerProcess: null,
-    controllerProof: null,
-    workflow: params.workflow,
-    ...(params.authority ? { authority: params.authority } : {})
-  };
-  return exchangeSandboxControl(request, params);
-}
-
 type CodexControllerClosed = Readonly<{
   version: 1;
   status: 'closed';

package/lib/sandbox/control/executor.ts

@@ -31,12 +31,8 @@ import {
   createSandboxExecutorExecutionContext,
   dispatchTaskControlOperation,
   parseTaskControlOperation,
-  validateLifecycleRecoveryAttestation,
-  type LifecycleAuthorityResponseV1,
-  type LifecycleRecoveryAttestationV1,
   type TaskControlOperation
 } from '../../task/control-authority.ts';
-import { executeTaskWorkflow } from './workflow-executor.ts';
 import { assertSandboxControlBrokerOwner, readSandboxControlManifest, type BrokerOwner } from './lifecycle.ts';
 import { computeLifecycleBuildIdentity } from '../../agent-clients/adapters/codex-lifecycle/build-identity.ts';
 import {
@@ -45,7 +41,6 @@ import {
   openCodexControllerRegistration,
   resolveCodexControllerBinding
 } from './controller-registration.ts';
-import type { OrchestrationDiagnosticLogger } from '../../task/orchestration.ts';
 
 export type SandboxControlExecutionResult = {
   exitCode: number;
@@ -127,7 +122,6 @@ export async function prepareSandboxControlExecution(params: {
   request: SandboxControlRequest;
   requestPath: string;
   internalCliPath: string;
-  lifecycleAuthority?: LifecycleAuthorityResponseV1;
 }): Promise<PreparedSandboxControlExecution> {
   const nonce = randomUUID();
   const child = spawn(
@@ -181,17 +175,11 @@ export async function prepareSandboxControlExecution(params: {
       if (!canWrite()) throw new Error('SANDBOX_CONTROL_OWNER_LOST');
       atomicWriteJson(executionPath(params.manifest, params.request.id), { ...execution, phase: 'running', updatedAt: Date.now() });
       if (!canWrite()) throw new Error('SANDBOX_CONTROL_OWNER_LOST');
-      const authority = params.lifecycleAuthority?.attestation ?? null;
       child.send({
         version: 2,
         nonce,
         owner: gateOwner,
-        requestId: params.request.id,
-        operationId: authority?.operationId ?? params.request.id,
-        phase: authority?.phase ?? (params.request.family === 'task-workflow'
-          && params.request.workflow?.operation === 'artifact-preflight' ? 'artifact.preflight'
-          : params.request.family === 'task-workflow' ? 'artifact.finalize-local' : 'orchestration.prepare'),
-        authority
+        requestId: params.request.id
       } satisfies SandboxControlExecutorGateV2);
     },
     completion,
@@ -206,7 +194,7 @@ export async function prepareSandboxControlExecution(params: {
   };
 }
 
-function waitForGate(nonce: string, timeoutMs = 2_000): Promise<Readonly<{ owner: BrokerOwner; authority: LifecycleRecoveryAttestationV1 | null; requestId: string; operationId: string; phase: SandboxControlExecutorGateV2['phase'] }>> {
+function waitForGate(nonce: string, timeoutMs = 2_000): Promise<Readonly<{ owner: BrokerOwner; requestId: string }>> {
   return new Promise((resolve, reject) => {
     const timer = setTimeout(() => reject(new Error('SANDBOX_CONTROL_EXECUTOR_GATE_TIMEOUT')), timeoutMs);
     const onDisconnect = () => {
@@ -222,12 +210,9 @@ function waitForGate(nonce: string, timeoutMs = 2_000): Promise<Readonly<{ owner
         nonce?: unknown;
         owner?: Partial<BrokerOwner> | null;
         requestId?: unknown;
-        operationId?: unknown;
-        phase?: unknown;
-        authority?: unknown;
       } | null;
       const owner = value?.owner;
-      if (!value || Object.keys(value).sort().join(',') !== 'authority,nonce,operationId,owner,phase,requestId,version'
+      if (!value || Object.keys(value).sort().join(',') !== 'nonce,owner,requestId,version'
         || value.version !== 2 || value.nonce !== nonce
         || !owner || owner.version !== 3 || !Number.isSafeInteger(owner.pid) || (owner.pid ?? 0) <= 0
         || typeof owner.startTime !== 'number' || !Number.isSafeInteger(owner.startTime)
@@ -236,20 +221,13 @@ function waitForGate(nonce: string, timeoutMs = 2_000): Promise<Readonly<{ owner
         reject(new Error('SANDBOX_CONTROL_EXECUTOR_GATE_INVALID'));
         return;
       }
-      if (typeof value.requestId !== 'string' || typeof value.operationId !== 'string'
-        || !['orchestration.prepare', 'artifact.preflight', 'artifact.finalize-local', 'task-event.completed'].includes(value.phase as string)
-        || (value.authority !== null && value.authority !== undefined && (() => {
-          try { validateLifecycleRecoveryAttestation(value.authority); return false; } catch { return true; }
-        })())) {
+      if (typeof value.requestId !== 'string') {
         reject(new Error('SANDBOX_CONTROL_EXECUTOR_GATE_INVALID'));
         return;
       }
       resolve({
         owner: owner as BrokerOwner,
-        authority: value.authority === null || value.authority === undefined ? null : value.authority as LifecycleRecoveryAttestationV1,
-        requestId: value.requestId,
-        operationId: value.operationId,
-        phase: value.phase as SandboxControlExecutorGateV2['phase']
+        requestId: value.requestId
       });
     });
   });
@@ -273,17 +251,6 @@ function controllerFailure(error: unknown): SandboxControlExecutionResult {
   return { exitCode: 1, stdout: `${JSON.stringify(payload)}\n`, stderr: '' };
 }
 
-function orchestrationFailure(code: string, message: string): SandboxControlExecutionResult {
-  return {
-    exitCode: 1,
-    stdout: `${JSON.stringify({
-      status: 'failed', changed: false, taskId: null, run: null, next: null,
-      error: { code, message }
-    })}\n`,
-    stderr: ''
-  };
-}
-
 function lifecycleFailure(code: string, message: string): SandboxControlExecutionResult {
   return {
     exitCode: 1,
@@ -330,7 +297,6 @@ function finalizationResult(result: Awaited<ReturnType<typeof applyTaskFinalizat
 type ExecuteRequestOptions = Readonly<{
   buildIdentity?: typeof computeLifecycleBuildIdentity;
   resolveControllerBinding?: typeof resolveCodexControllerBinding;
-  lifecycleRecoveryAttestation?: LifecycleRecoveryAttestationV1 | null;
 }>;
 
 async function executeRequestInner(
@@ -406,7 +372,6 @@ async function executeRequestInner(
       return controllerFailure(error);
     }
   }
-  if (request.family === 'task-workflow') return executeTaskWorkflow(manifest, request.workflow, options.lifecycleRecoveryAttestation ?? null);
   if (request.family === 'task-finalization') {
     const operation = parseTaskControlOperation(
       'task-finalization', [manifest.taskId!, 'complete', '--agent', request.agent]
@@ -420,78 +385,21 @@ async function executeRequestInner(
         taskId: manifest.taskId!,
         generation: manifest.generation,
         manifestPath,
-        requestId: request.id,
-        lifecycleRecoveryAttestation: options.lifecycleRecoveryAttestation ?? null
+        requestId: request.id
       }),
       operation
     );
     return finalizationResult(await result);
   }
   const boundArgs = bindSandboxControlTask(request, manifest.taskId!);
-  if (request.family === 'task-orchestration') {
-    boundArgs.push('--git-worktree-root', manifest.worktreeRoot);
-  }
   let operation: TaskControlOperation;
   try {
     operation = parseTaskControlOperation(request.family, boundArgs);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     const code = /^([A-Z][A-Z0-9_]+)/u.exec(message)?.[1] ?? 'TASK_CONTROL_OPERATION_INVALID';
-    return request.family === 'task-lifecycle'
-      ? lifecycleFailure('LIFECYCLE_PAYLOAD_INVALID', message)
-      : orchestrationFailure(code, message);
+    return lifecycleFailure('LIFECYCLE_PAYLOAD_INVALID', `${code}: ${message}`);
   }
-  let controllerBinding: Readonly<{
-    instanceDigest: string;
-    controlGeneration: string;
-  }> | null = null;
-  if (request.family === 'task-orchestration') {
-    const codexPrepare = operation.family === 'task-orchestration'
-      && operation.intent === 'prepare'
-      && operation.input.client === 'codex';
-    if (codexPrepare) {
-      if (!request.controllerProof) {
-        const authority = options.lifecycleRecoveryAttestation;
-        if (!authority || authority.phase !== 'orchestration.prepare') {
-          return orchestrationFailure(
-            'CODEX_SANDBOX_CONTROLLER_PROOF_REQUIRED',
-            'Codex prepare requires a current controller lease proof'
-          );
-        }
-        controllerBinding = {
-          instanceDigest: authority.controllerInstanceDigest,
-          controlGeneration: authority.controlGeneration
-        };
-      } else {
-        try {
-          controllerBinding = (options.resolveControllerBinding ?? resolveCodexControllerBinding)({
-            manifest,
-            manifestPath,
-            proof: request.controllerProof,
-            buildIdentity: (options.buildIdentity ?? computeLifecycleBuildIdentity)(manifest.repoRoot)
-          });
-        } catch (error) {
-          const code = error instanceof CodexControllerRegistrationError
-            ? error.code
-            : 'CODEX_SANDBOX_CONTROLLER_PROOF_INVALID';
-          return orchestrationFailure(code, `${code}: Codex controller proof was rejected`);
-        }
-      }
-    } else if (request.controllerProof !== null) {
-      return orchestrationFailure(
-        'CODEX_SANDBOX_CONTROLLER_PROOF_INVALID',
-        'Controller proof is only accepted for canonical Codex prepare'
-      );
-    }
-  }
-  const diagnosticLog: OrchestrationDiagnosticLogger = (event, fields): void => {
-    appendExecutorAudit(manifest, event.startsWith('orchestration-') ? event : `orchestration-${event}`, {
-      requestId: request.id,
-      requestFamily: request.family,
-      sandboxTaskId: manifest.taskId,
-      ...fields
-    });
-  };
   const context = createSandboxExecutorExecutionContext({
     repoRoot: manifest.repoRoot,
     worktreeRoot: manifest.worktreeRoot,
@@ -499,10 +407,7 @@ async function executeRequestInner(
     taskId: manifest.taskId!,
     generation: manifest.generation,
     manifestPath,
-    requestId: request.id,
-    diagnosticLog,
-    ...(controllerBinding ? { controllerBinding } : {}),
-    lifecycleRecoveryAttestation: options.lifecycleRecoveryAttestation ?? null
+    requestId: request.id
   });
   const format = (value: unknown): SandboxControlExecutionResult => {
     const result = value as { status?: string };
@@ -512,12 +417,8 @@ async function executeRequestInner(
       stderr: ''
     };
   };
-  if (request.family === 'task-orchestration') {
-    if (operation.family !== 'task-orchestration') throw new Error('SANDBOX_CONTROL_ORCHESTRATION_OPERATION_INVALID');
-    return format(await dispatchTaskControlOperation(context, operation));
-  }
   if (operation.family !== 'task-lifecycle') throw new Error('SANDBOX_CONTROL_LIFECYCLE_OPERATION_INVALID');
-    return format(await dispatchTaskControlOperation(context, operation));
+  return format(await dispatchTaskControlOperation(context, operation));
 }
 
 export async function executeRequest(
@@ -579,12 +480,6 @@ export async function runSandboxControlExecutor(requestPath: string, nonce: stri
   const raw = JSON.parse(fs.readFileSync(requestPath, 'utf8')) as unknown;
   const request = validateSandboxControlRequest(raw, manifest);
   if (gate.requestId !== request.id) throw new Error('SANDBOX_CONTROL_EXECUTOR_GATE_REQUEST_MISMATCH');
-  if (gate.authority !== null
-    && (gate.authority.requestId !== request.id
-      || gate.authority.operationId !== gate.operationId
-      || gate.authority.phase !== gate.phase)) {
-    throw new Error('SANDBOX_CONTROL_EXECUTOR_GATE_AUTHORITY_MISMATCH');
-  }
   appendExecutorAudit(manifest, 'executor-request-validated', requestAuditFields(manifest, request));
   const requestDirectory = path.resolve(path.dirname(requestPath));
   const processingDirectory = path.resolve(path.join(manifest.processingDir, request.id));
@@ -602,7 +497,7 @@ export async function runSandboxControlExecutor(requestPath: string, nonce: stri
   let result: SandboxControlExecutionResult;
   try {
     assertSandboxControlExecutorAuthority(manifest, gateOwner);
-    const operation = request.family === 'task-lifecycle' || request.family === 'task-orchestration'
+    const operation = request.family === 'task-lifecycle'
       ? (() => {
         try { return parseTaskControlOperation(request.family, request.args); } catch { return null; }
       })()
@@ -610,10 +505,8 @@ export async function runSandboxControlExecutor(requestPath: string, nonce: stri
     const context = createSandboxControlAuditContext(manifest, {
       requestId: request.id,
       family: request.family,
-      operation: operation?.family === 'task-orchestration'
-        ? operation.intent
-        : operation?.family === 'task-lifecycle'
-          ? operation.request.intent
+      operation: operation?.family === 'task-lifecycle'
+        ? operation.request.intent
           : request.family === 'task-finalization' ? request.operation : null,
       phase: 'started-committed',
       outcome: 'in-progress'
@@ -622,9 +515,7 @@ export async function runSandboxControlExecutor(requestPath: string, nonce: stri
     writeSandboxControlTransition(manifest, { requestId: request.id, phase: 'started-committed' });
     const execution = readJsonExecution(executionPath(manifest, request.id));
     atomicWriteJson(executionPath(manifest, request.id), { ...execution, phase: 'running', updatedAt: Date.now() });
-    result = await executeRequest(manifest, manifestPath, request, {
-      lifecycleRecoveryAttestation: gate.authority
-    });
+    result = await executeRequest(manifest, manifestPath, request);
   } catch (error) {
     appendExecutorAudit(manifest, 'executor-authority-or-dispatch-failed', {
       ...requestAuditFields(manifest, request),
@@ -643,9 +534,7 @@ export async function runSandboxControlExecutor(requestPath: string, nonce: stri
       }
       : request.family === 'task-create'
         ? taskCreateExecutionFailure(request.id, code, detail)
-        : request.family === 'task-lifecycle'
-        ? lifecycleFailure(code, detail)
-        : orchestrationFailure(code, detail);
+        : lifecycleFailure(code, detail);
   }
   process.stdout.write(result.stdout);
   process.stderr.write(result.stderr);

package/lib/sandbox/control/finalization-response.ts

@@ -4,18 +4,24 @@ import type { SandboxControlResponse } from './protocol.ts';
 export function finalizationTerminalResponse(taskId: string, requestId: string, receipt: TaskFinalizationReceipt): SandboxControlResponse {
   const pendingSteps = [
     receipt.taskComment === 'pending' ? 'task-comment' : null,
-    receipt.verification === 'pending' ? 'verification' : null
+    receipt.verification === 'pending' ? 'verification' : null,
+    receipt.summary === 'pending' ? 'summary' : null
   ].filter((step): step is string => step !== null);
-  const completedSteps = ['lifecycle', receipt.taskComment === 'pending' ? null : 'task-comment', receipt.verification === 'pending' ? null : 'verification']
+  const completedSteps = [
+    'lifecycle', receipt.taskComment === 'pending' ? null : 'task-comment',
+    receipt.verification === 'pending' ? null : 'verification', receipt.summary === 'pending' ? null : 'summary'
+  ]
     .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,
+    backfill: { status: 'no-op', changed: false, error: null },
     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 },
+    summary: receipt.summary === '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',

package/lib/sandbox/control/protocol.ts

@@ -5,12 +5,6 @@ import type { ProcessIdentity } from '../../server/process-state.ts';
 import type { CodexControllerLeaseProofV1 } from './controller-registration.ts';
 import type { SandboxAuthorityEvidenceV1 } from '../engines/authority.ts';
 import type { SandboxTaskView } from './task-view.ts';
-import { validateTaskWorkflowRequest, type TaskWorkflowRequest } from './task-workflow.ts';
-import {
-  validateLifecycleAuthorityRequest,
-  type LifecycleAuthorityRequestV1,
-  type LifecycleRecoveryAttestationV1
-} from '../../task/control-authority.ts';
 
 export const SANDBOX_CONTROL_MAX_BYTES = 64 * 1024;
 export const SANDBOX_CONTROL_MAX_LOGICAL_RECORDS = 1024;
@@ -21,7 +15,7 @@ export const SANDBOX_CONTROL_ADMISSION_WINDOW_MS = 2_000;
 export const SANDBOX_CONTROL_STATUS_INTERVAL_MS = 250;
 export const SANDBOX_CONTROL_STATUS_STALE_MS = 1_500;
 export const SANDBOX_CONTROL_FUTURE_SKEW_MS = 1_000;
-export const SANDBOX_CONTROL_FAMILIES = ['task-lifecycle', 'task-orchestration', 'task-finalization', 'task-create', 'codex-controller', 'task-workflow'] as const;
+export const SANDBOX_CONTROL_FAMILIES = ['task-lifecycle', 'task-finalization', 'task-create', 'codex-controller'] as const;
 export type SandboxControlTimingPolicy = Readonly<{
   controlTickMs: number;
   parkedBindingInitialMs: number;
@@ -61,9 +55,6 @@ export type SandboxControlExecutorGateV2 = Readonly<{
   nonce: string;
   owner: SandboxControlBrokerOwner;
   requestId: string;
-  operationId: string;
-  phase: 'orchestration.prepare' | 'artifact.preflight' | 'artifact.finalize-local' | 'task-event.completed';
-  authority: LifecycleRecoveryAttestationV1 | null;
 }>;
 type RequestBase = Readonly<{
   version: 3; id: string; token: string; generation: string; issuedAt: number; expiresAt: number;
@@ -71,8 +62,7 @@ type RequestBase = Readonly<{
   controllerProof: CodexControllerLeaseProofV1 | null;
 }>;
 export type SandboxTaskCommandRequest = RequestBase & Readonly<{
-  family: 'task-lifecycle' | 'task-orchestration'; args: string[];
-  authority?: LifecycleAuthorityRequestV1;
+  family: 'task-lifecycle'; args: string[];
 }>;
 export type SandboxTaskFinalizationRequest = RequestBase & Readonly<{
   family: 'task-finalization'; operation: 'complete'; agent: string; args: [];
@@ -85,13 +75,7 @@ export type SandboxCodexControllerRequest = RequestBase & Readonly<{
   command: 'open' | 'close' | 'verify';
   args: [];
 }>;
-export type SandboxTaskWorkflowRequest = RequestBase & Readonly<{
-  family: 'task-workflow';
-  args: [];
-  workflow: TaskWorkflowRequest;
-  authority?: LifecycleAuthorityRequestV1;
-}>;
-export type SandboxControlRequest = SandboxTaskCommandRequest | SandboxTaskFinalizationRequest | SandboxTaskCreateRequest | SandboxCodexControllerRequest | SandboxTaskWorkflowRequest;
+export type SandboxControlRequest = SandboxTaskCommandRequest | SandboxTaskFinalizationRequest | SandboxTaskCreateRequest | SandboxCodexControllerRequest;
 export type SandboxControlError = Readonly<{ code: string; message: string; retryable: boolean }>;
 export type SandboxControlResultEvidence = Readonly<{
   version: 1;
@@ -131,11 +115,6 @@ export type SandboxControlResponse = Readonly<{
   outputState?: 'available' | 'unavailable';
   payload?: SandboxControlPayloadReference | null;
 }>;
-export type SandboxControlRecoveryWarning = Readonly<{
-  code: string;
-  message: string;
-  action: string;
-}>;
 export type SandboxControlStatus = Readonly<{
   version: 3; generation: string; broker: ProcessIdentity & { brokerId: string };
   state: 'starting' | 'healthy' | 'busy' | 'parked'; reasonCode: string | null;
@@ -313,25 +292,8 @@ export function validateSandboxControlRequest(
     }
     return request as SandboxTaskFinalizationRequest;
   }
-  if (request.family === 'task-workflow') {
-    const expected = ['args', 'authority', 'controllerProcess', 'controllerProof', 'expiresAt', 'family', 'generation', 'id', 'issuedAt', 'token', 'version', 'workflow'];
-    const baseExpected = expected.filter((key) => key !== 'authority');
-    if (![baseExpected, expected].some((keys) => Object.keys(request).sort().join(',') === keys.sort().join(','))
-      || !Array.isArray(request.args) || request.args.length !== 0
-      || request.controllerProcess !== null || request.controllerProof !== null) {
-      fail('SANDBOX_CONTROL_REQUEST_INVALID', 'task-workflow request schema is invalid');
-    }
-    if (manifest.mode !== 'task-bound' || !manifest.taskId) fail('SANDBOX_CONTROL_BRANCH_ONLY', 'branch-only sandboxes cannot use task-workflow');
-    const workflow = validateTaskWorkflowRequest(request.workflow);
-    if (workflow.taskId !== manifest.taskId || workflow.generation !== manifest.generation || workflow.id !== request.id) {
-      fail('SANDBOX_CONTROL_REQUEST_INVALID', 'task-workflow binding does not match the sandbox manifest');
-    }
-    if (request.authority !== undefined) validateAuthoritySelector(request.authority, request, manifest);
-    return { ...request, workflow } as SandboxTaskWorkflowRequest;
-  }
-  const expected = ['args', 'authority', 'controllerProcess', 'controllerProof', 'expiresAt', 'family', 'generation', 'id', 'issuedAt', 'token', 'version'];
-  const baseExpected = expected.filter((key) => key !== 'authority');
-  if (![baseExpected, expected].some((keys) => Object.keys(request).sort().join(',') === keys.sort().join(','))
+  const expected = ['args', 'controllerProcess', 'controllerProof', 'expiresAt', 'family', 'generation', 'id', 'issuedAt', 'token', 'version'];
+  if (Object.keys(request).sort().join(',') !== expected.sort().join(',')
     || !Array.isArray(request.args) || !request.args.every((arg) => typeof arg === 'string')) {
     fail('SANDBOX_CONTROL_REQUEST_INVALID', 'request schema or authorization is invalid');
   }
@@ -341,52 +303,14 @@ export function validateSandboxControlRequest(
       "branch-only sandboxes cannot coordinate tasks; return to the host and run 'ai sandbox start --recreate <task-ref-or-correct-branch>'"
     );
   }
-  if (request.family === 'task-orchestration'
-    && request.args.some((arg) => arg === '--git-worktree-root' || arg.startsWith('--git-worktree-root='))) {
-    fail('SANDBOX_CONTROL_REQUEST_INVALID', 'worktree binding is reserved for the control broker');
-  }
-  if (request.controllerProcess !== null
-    || (request.controllerProof !== null && !validControllerProof(request.controllerProof))) {
+  if (request.controllerProcess !== null || request.controllerProof !== null) {
     fail('SANDBOX_CONTROL_REQUEST_INVALID', 'controller authority is invalid');
   }
-  if (request.family !== 'task-orchestration' && request.controllerProof !== null) {
-    fail('SANDBOX_CONTROL_REQUEST_INVALID', 'controller proof is not allowed for this family');
-  }
-  if (request.authority !== undefined) validateAuthoritySelector(request.authority, request, manifest);
   return request as SandboxTaskCommandRequest;
 }
 
-function validateAuthoritySelector(
-  value: unknown,
-  request: Record<string, unknown>,
-  manifest: SandboxControlManifest
-): asserts value is LifecycleAuthorityRequestV1 {
-  let authority: LifecycleAuthorityRequestV1;
-  try { authority = validateLifecycleAuthorityRequest(value); }
-  catch { fail('SANDBOX_CONTROL_AUTHORITY_INVALID', 'lifecycle authority selector is invalid'); }
-  if (authority.requestId !== request.id
-    || authority.taskId !== manifest.taskId
-    || authority.expectedControlGeneration !== manifest.generation) {
-    fail('SANDBOX_CONTROL_AUTHORITY_INVALID', 'lifecycle authority selector is not bound to this request');
-  }
-  const args = Array.isArray(request.args) ? request.args : [];
-  if (request.family === 'task-orchestration'
-    && (args[1] !== 'prepare' || authority.phase !== 'orchestration.prepare')) {
-    fail('SANDBOX_CONTROL_AUTHORITY_INVALID', 'orchestration authority is only valid for prepare');
-  }
-  const workflow = request.workflow as TaskWorkflowRequest | undefined;
-  if (request.family === 'task-workflow') {
-    const expectedPhase = workflow?.operation === 'artifact-finalize-local'
-      ? 'artifact.finalize-local'
-      : workflow?.operation === 'event' ? 'task-event.completed' : null;
-    if (authority.phase !== expectedPhase) {
-      fail('SANDBOX_CONTROL_AUTHORITY_INVALID', 'workflow authority phase does not match the workflow operation');
-    }
-  }
-}
-
 export function bindSandboxControlTask(request: SandboxControlRequest, taskId: string): string[] {
-  if (request.family === 'task-create' || request.family === 'codex-controller' || request.family === 'task-finalization' || request.family === 'task-workflow') {
+  if (request.family === 'task-create' || request.family === 'codex-controller' || request.family === 'task-finalization') {
     fail('SANDBOX_CONTROL_REQUEST_INVALID', `${request.family} requests do not bind a current task`);
   }
   if (request.args.length === 0) fail('SANDBOX_CONTROL_REQUEST_INVALID', 'command arguments are required');