@fitlab-ai/agent-infra 0.11.1 → 0.11.3

package/dist/lib/sandbox/control/client.js

@@ -81,10 +81,6 @@ function preflight(statusDir, generation, taskViewEffect = null, now = Date.now(
 function taskViewEffectForRequest(request) {
     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;
 }
 function parseResponse(raw, id, accepted = false) {
@@ -152,9 +148,7 @@ export function resolveVisibleActiveShortId(ref) {
 // 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) {
-    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))
@@ -179,7 +173,7 @@ function exchangeSandboxControl(request, params) {
                 || (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);
         }
     }
@@ -326,7 +320,7 @@ function authority(params) {
 export function requestSandboxControl(params) {
     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);
@@ -340,23 +334,6 @@ export function requestSandboxControl(params) {
     };
     return exchangeSandboxControl(request, params);
 }
-export function requestSandboxTaskControl(params) {
-    const auth = authority(params);
-    const issuedAt = Date.now();
-    const request = {
-        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) {
     const agent = normalizeAgentToken(params.agent);
     if (!agent)
@@ -378,24 +355,6 @@ export function requestSandboxTaskFinalization(params) {
     };
     return exchangeSandboxControl(request, params);
 }
-export function requestSandboxTaskWorkflow(params) {
-    const auth = authority(params);
-    const issuedAt = Date.now();
-    const request = {
-        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);
-}
 function exactKeys(value, keys) {
     return Object.keys(value).sort().join(',') === [...keys].sort().join(',');
 }

package/dist/lib/sandbox/control/executor.js

@@ -9,8 +9,7 @@ import { bindSandboxControlTask, validateSandboxControlRequest } from './protoco
 import { atomicWriteJson, executionPath, readActiveLease, terminateSandboxControlExecution } from './state.js';
 import { requestAuditFields, resultAuditFields, appendDiagnosticAudit, createSandboxControlAuditContext, appendCriticalAudit, writeSandboxControlTransition } from './audit.js';
 import { validateSandboxControlIdentity } from './identity-sentinel.js';
-import { createSandboxExecutorExecutionContext, dispatchTaskControlOperation, parseTaskControlOperation, validateLifecycleRecoveryAttestation } from '../../task/control-authority.js';
-import { executeTaskWorkflow } from './workflow-executor.js';
+import { createSandboxExecutorExecutionContext, dispatchTaskControlOperation, parseTaskControlOperation } from '../../task/control-authority.js';
 import { assertSandboxControlBrokerOwner, readSandboxControlManifest } from './lifecycle.js';
 import { computeLifecycleBuildIdentity } from '../../agent-clients/adapters/codex-lifecycle/build-identity.js';
 import { closeCodexControllerRegistration, CodexControllerRegistrationError, openCodexControllerRegistration, resolveCodexControllerBinding } from './controller-registration.js';
@@ -118,17 +117,11 @@ export async function prepareSandboxControlExecution(params) {
             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
             });
         },
         completion,
@@ -155,7 +148,7 @@ function waitForGate(nonce, timeoutMs = 2_000) {
             process.off('disconnect', onDisconnect);
             const value = message;
             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)
@@ -164,26 +157,13 @@ function waitForGate(nonce, timeoutMs = 2_000) {
                 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)
-                || (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,
-                authority: value.authority === null || value.authority === undefined ? null : value.authority,
-                requestId: value.requestId,
-                operationId: value.operationId,
-                phase: value.phase
+                requestId: value.requestId
             });
         });
     });
@@ -205,16 +185,6 @@ function controllerFailure(error) {
     };
     return { exitCode: 1, stdout: `${JSON.stringify(payload)}\n`, stderr: '' };
 }
-function orchestrationFailure(code, message) {
-    return {
-        exitCode: 1,
-        stdout: `${JSON.stringify({
-            status: 'failed', changed: false, taskId: null, run: null, next: null,
-            error: { code, message }
-        })}\n`,
-        stderr: ''
-    };
-}
 function lifecycleFailure(code, message) {
     return {
         exitCode: 1,
@@ -324,8 +294,6 @@ async function executeRequestInner(manifest, manifestPath, request, options = {}
             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]);
         if (operation.family !== 'task-finalization')
@@ -337,15 +305,11 @@ async function executeRequestInner(manifest, manifestPath, request, options = {}
             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;
     try {
         operation = parseTaskControlOperation(request.family, boundArgs);
@@ -353,55 +317,8 @@ async function executeRequestInner(manifest, manifestPath, request, options = {}
     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);
-    }
-    let controllerBinding = 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');
-        }
+        return lifecycleFailure('LIFECYCLE_PAYLOAD_INVALID', `${code}: ${message}`);
     }
-    const diagnosticLog = (event, fields) => {
-        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,
@@ -409,10 +326,7 @@ async function executeRequestInner(manifest, manifestPath, request, options = {}
         taskId: manifest.taskId,
         generation: manifest.generation,
         manifestPath,
-        requestId: request.id,
-        diagnosticLog,
-        ...(controllerBinding ? { controllerBinding } : {}),
-        lifecycleRecoveryAttestation: options.lifecycleRecoveryAttestation ?? null
+        requestId: request.id
     });
     const format = (value) => {
         const result = value;
@@ -422,11 +336,6 @@ async function executeRequestInner(manifest, manifestPath, request, options = {}
             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));
@@ -487,12 +396,6 @@ export async function runSandboxControlExecutor(requestPath, nonce) {
     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));
@@ -510,7 +413,7 @@ export async function runSandboxControlExecutor(requestPath, nonce) {
     let result;
     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);
@@ -523,11 +426,9 @@ export async function runSandboxControlExecutor(requestPath, nonce) {
         const context = createSandboxControlAuditContext(manifest, {
             requestId: request.id,
             family: request.family,
-            operation: operation?.family === 'task-orchestration'
-                ? operation.intent
-                : operation?.family === 'task-lifecycle'
-                    ? operation.request.intent
-                    : request.family === 'task-finalization' ? request.operation : null,
+            operation: operation?.family === 'task-lifecycle'
+                ? operation.request.intent
+                : request.family === 'task-finalization' ? request.operation : null,
             phase: 'started-committed',
             outcome: 'in-progress'
         });
@@ -535,9 +436,7 @@ export async function runSandboxControlExecutor(requestPath, nonce) {
         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', {
@@ -557,9 +456,7 @@ export async function runSandboxControlExecutor(requestPath, nonce) {
             }
             : 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/dist/lib/sandbox/control/finalization-response.js

@@ -1,18 +1,24 @@
 export function finalizationTerminalResponse(taskId, requestId, receipt) {
     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 !== 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 !== 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/dist/lib/sandbox/control/protocol.js

@@ -1,8 +1,6 @@
 import { createHash } from 'node:crypto';
 import { validateTaskCreateCandidate } from '../../task/create.js';
 import { normalizeAgentToken } from '../../agent-clients/tokens.js';
-import { validateTaskWorkflowRequest } from './task-workflow.js';
-import { validateLifecycleAuthorityRequest } from '../../task/control-authority.js';
 export const SANDBOX_CONTROL_MAX_BYTES = 64 * 1024;
 export const SANDBOX_CONTROL_MAX_LOGICAL_RECORDS = 1024;
 export const SANDBOX_CONTROL_MAX_RESPONSE_BYTES = 64 * 1024 * 1024;
@@ -12,7 +10,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'];
+export const SANDBOX_CONTROL_FAMILIES = ['task-lifecycle', 'task-finalization', 'task-create', 'codex-controller'];
 export const DEFAULT_SANDBOX_CONTROL_TIMING = Object.freeze({
     controlTickMs: 250,
     parkedBindingInitialMs: 1_000,
@@ -173,78 +171,21 @@ export function validateSandboxControlRequest(value, manifest, options = {}) {
         }
         return request;
     }
-    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 };
-    }
-    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');
     }
     if (manifest.mode !== 'task-bound' || !manifest.taskId) {
         fail('SANDBOX_CONTROL_BRANCH_ONLY', "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;
 }
-function validateAuthoritySelector(value, request, manifest) {
-    let authority;
-    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;
-    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, taskId) {
-    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)