@fitlab-ai/agent-infra 0.11.2 → 0.11.4

package/dist/lib/task/workflow-dispatch.js

@@ -1,213 +0,0 @@
-import fs from 'node:fs';
-import { reconcileTaskInvalidation } from './invalidation-command.js';
-import { applyLedgerIntent } from './ledger-intents.js';
-import { isReviewStage, parseLedgerDocument, summarizeLedgerStage, validateLedgerRows } from './ledger.js';
-import { resolveTaskRef } from './resolve-ref.js';
-import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.js';
-import { applyWorkflowWarningIntent } from './workflow-warning-intents.js';
-function failed(code, message) {
-    return { status: 'failed', changed: false, error: { code, message } };
-}
-function isFailure(value) {
-    return Boolean(value) && typeof value === 'object' && value.status === 'failed';
-}
-function options(args, allowed) {
-    const values = {};
-    for (let index = 2; index < args.length; index += 1) {
-        const flag = args[index];
-        if (flag === '--dry-run') {
-            if (!Object.hasOwn(allowed, flag) || values[flag] !== undefined)
-                return failed('TASK_WORKFLOW_PAYLOAD_INVALID', `invalid option '${flag}'`);
-            values[flag] = true;
-            continue;
-        }
-        const key = allowed[flag];
-        if (!key || values[flag] !== undefined)
-            return failed('TASK_WORKFLOW_PAYLOAD_INVALID', `invalid option '${flag}'`);
-        const value = args[++index];
-        if (value === undefined || value.startsWith('--'))
-            return failed('TASK_WORKFLOW_PAYLOAD_INVALID', `option '${flag}' requires a value`);
-        if (flag === '--needs-implementation' && value !== 'true' && value !== 'false') {
-            return failed('TASK_WORKFLOW_PAYLOAD_INVALID', "option '--needs-implementation' must be true or false");
-        }
-        values[flag] = value;
-    }
-    return values;
-}
-function value(values, flag) {
-    const candidate = values[flag];
-    return typeof candidate === 'string' ? candidate : undefined;
-}
-function required(values, flags) {
-    const missing = flags.find((flag) => value(values, flag) === undefined);
-    return missing ? failed('TASK_WORKFLOW_PAYLOAD_INVALID', `option '${missing}' is required`) : null;
-}
-function resultForLock(error) {
-    if (error instanceof TaskExecutionLockError)
-        return failed(error.code, error.message);
-    throw error;
-}
-function ledgerIntent(operation, args) {
-    const [taskRef, kind] = args;
-    const mappings = {
-        'ledger-finding-response': {
-            kind: 'finding-respond', required: ['--id', '--round', '--status', '--evidence'],
-            flags: { '--id': 'id', '--round': 'round', '--status': 'status', '--evidence': 'evidence', '--dry-run': 'dryRun' }
-        },
-        'ledger-finding-review': {
-            kind: 'finding-review', required: ['--id', '--status', '--evidence'],
-            flags: { '--id': 'id', '--status': 'status', '--evidence': 'evidence', '--needs-implementation': 'needsImplementation', '--dry-run': 'dryRun' }
-        },
-        'ledger-finding-upsert': {
-            kind: 'finding-upsert', required: ['--stage', '--review-artifact', '--ordinal', '--severity', '--evidence'],
-            flags: { '--stage': 'stage', '--review-artifact': 'reviewArtifact', '--ordinal': 'ordinal', '--severity': 'severity', '--evidence': 'evidence', '--dry-run': 'dryRun' }
-        },
-        'decision-next-id': { kind: 'decision-next-id', required: [], flags: {} },
-        'decision-upsert': {
-            kind: 'decision-upsert', required: ['--id', '--stage', '--artifact'],
-            flags: { '--id': 'id', '--stage': 'stage', '--artifact': 'artifact', '--needs-implementation': 'needsImplementation', '--dry-run': 'dryRun' }
-        }
-    };
-    const mapping = mappings[operation];
-    if (!mapping || !taskRef || kind === undefined)
-        return failed('TASK_WORKFLOW_PAYLOAD_INVALID', 'task workflow ledger request is invalid');
-    const values = options(args, mapping.flags);
-    if (isFailure(values))
-        return values;
-    const missing = required(values, mapping.required);
-    if (missing)
-        return missing;
-    const dryRun = values['--dry-run'] === true;
-    if (mapping.kind === 'decision-next-id')
-        return { kind: mapping.kind, taskRef };
-    if (mapping.kind === 'finding-respond')
-        return {
-            kind: mapping.kind, taskRef, id: value(values, '--id'), round: Number(value(values, '--round')),
-            status: value(values, '--status'), evidence: value(values, '--evidence'), ...(dryRun ? { dryRun } : {})
-        };
-    if (mapping.kind === 'finding-review')
-        return {
-            kind: mapping.kind, taskRef, id: value(values, '--id'), status: value(values, '--status'),
-            evidence: value(values, '--evidence'), ...(value(values, '--needs-implementation') === 'true' ? { needsImplementation: true } : {}),
-            ...(dryRun ? { dryRun } : {})
-        };
-    if (mapping.kind === 'finding-upsert')
-        return {
-            kind: mapping.kind, taskRef, stage: value(values, '--stage'), reviewArtifact: value(values, '--review-artifact'),
-            ordinal: Number(value(values, '--ordinal')), severity: value(values, '--severity'), evidence: value(values, '--evidence'),
-            ...(dryRun ? { dryRun } : {})
-        };
-    return {
-        kind: mapping.kind, taskRef, id: value(values, '--id'), stage: value(values, '--stage'),
-        artifact: value(values, '--artifact'), ...(value(values, '--needs-implementation') === 'true' ? { needsImplementation: true } : {}),
-        ...(dryRun ? { dryRun } : {})
-    };
-}
-function warningIntent(args) {
-    const [taskRef, kind] = args;
-    if (!taskRef || !['add', 'list', 'set-status'].includes(kind ?? '')) {
-        return failed('TASK_WORKFLOW_PAYLOAD_INVALID', 'task workflow warning request is invalid');
-    }
-    if (kind === 'list') {
-        const values = options(args, { '--status': 'status' });
-        if (isFailure(values))
-            return values;
-        return { kind, taskRef, ...(value(values, '--status') ? { status: value(values, '--status') } : {}) };
-    }
-    if (kind === 'set-status') {
-        const values = options(args, { '--id': 'id', '--status': 'status', '--resolution': 'resolution', '--dry-run': 'dryRun' });
-        if (isFailure(values))
-            return values;
-        const missing = required(values, ['--id', '--status', '--resolution']);
-        if (missing)
-            return missing;
-        return {
-            kind, taskRef, id: value(values, '--id'), status: value(values, '--status'),
-            resolution: value(values, '--resolution'), ...(values['--dry-run'] === true ? { dryRun: true } : {})
-        };
-    }
-    const values = options(args, {
-        '--step': 'step', '--severity': 'severity', '--code': 'code', '--target': 'target',
-        '--message': 'message', '--action': 'action', '--dry-run': 'dryRun'
-    });
-    if (isFailure(values))
-        return values;
-    const missing = required(values, ['--step', '--severity', '--code', '--target', '--message', '--action']);
-    if (missing)
-        return missing;
-    return {
-        kind: 'add', taskRef, step: value(values, '--step'), severity: value(values, '--severity'),
-        code: value(values, '--code'), target: value(values, '--target'), message: value(values, '--message'),
-        action: value(values, '--action'), ...(values['--dry-run'] === true ? { dryRun: true } : {})
-    };
-}
-function stageStatus(repoRoot, args) {
-    const [taskRef, kind] = args;
-    if (!taskRef || kind !== 'stage-status')
-        return failed('TASK_WORKFLOW_PAYLOAD_INVALID', 'task workflow ledger request is invalid');
-    const values = options(args, { '--stage': 'stage' });
-    if (isFailure(values))
-        return values;
-    const stage = value(values, '--stage');
-    if (!stage || !isReviewStage(stage))
-        return failed('TASK_WORKFLOW_PAYLOAD_INVALID', 'stage-status requires a valid review stage');
-    const resolved = resolveTaskRef(taskRef, { repoRoot });
-    if (!resolved.ok)
-        return failed(resolved.code, resolved.message);
-    try {
-        const ledger = parseLedgerDocument(fs.readFileSync(resolved.taskMdPath, 'utf8'));
-        if (!ledger.present)
-            return failed('LEDGER_SECTION_MISSING', 'review disagreement ledger section is missing');
-        const invalid = validateLedgerRows(ledger.rows);
-        if (invalid)
-            return failed(invalid.code, invalid.message);
-        return { status: 'ready', changed: false, taskId: resolved.taskId, stageStatus: summarizeLedgerStage(ledger.rows, stage), error: null };
-    }
-    catch (error) {
-        return failed('LEDGER_DOCUMENT_INVALID', error instanceof Error ? error.message : String(error));
-    }
-}
-/**
- * The caller has already selected and authorized the execution boundary.
- * This function deliberately invokes task domains in that process: starting a
- * second CLI process would discard the broker binding and could misclassify a
- * sandbox process with cleared environment variables as direct-host.
- */
-export function dispatchWorkflowCommand(repoRoot, operation, args) {
-    const taskRef = args[0];
-    if (!taskRef)
-        return failed('TASK_WORKFLOW_PAYLOAD_INVALID', 'task ref is required');
-    try {
-        if (operation === 'invalidation-reconcile') {
-            const values = options(args, { '--max-targets': 'maxTargets', '--dry-run': 'dryRun' });
-            if (isFailure(values))
-                return values;
-            const maxTargets = value(values, '--max-targets');
-            if (maxTargets !== undefined && (!Number.isSafeInteger(Number(maxTargets)) || Number(maxTargets) < 1)) {
-                return failed('TASK_WORKFLOW_PAYLOAD_INVALID', '--max-targets must be a positive integer');
-            }
-            return withTaskExecutionLock(repoRoot, taskRef, 'task-invalidation.reconcile', () => reconcileTaskInvalidation(taskRef, {
-                repoRoot, ...(maxTargets === undefined ? {} : { maxTargets: Number(maxTargets) }),
-                ...(values['--dry-run'] === true ? { dryRun: true } : {})
-            }));
-        }
-        if (operation === 'ledger-stage-status')
-            return stageStatus(repoRoot, args);
-        if (operation === 'warning-add' || operation === 'warning-list' || operation === 'warning-set-status') {
-            const intent = warningIntent(args);
-            if (isFailure(intent))
-                return intent;
-            if (intent.kind === 'list')
-                return applyWorkflowWarningIntent(intent, { repoRoot });
-            return withTaskExecutionLock(repoRoot, taskRef, `task-warning.${intent.kind}`, () => applyWorkflowWarningIntent(intent, { repoRoot }));
-        }
-        const intent = ledgerIntent(operation, args);
-        if (isFailure(intent))
-            return intent;
-        return withTaskExecutionLock(repoRoot, taskRef, `task-ledger.${intent.kind}`, () => applyLedgerIntent(intent, { repoRoot }));
-    }
-    catch (error) {
-        return resultForLock(error);
-    }
-}
-//# sourceMappingURL=workflow-dispatch.js.map

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

@@ -1,37 +0,0 @@
-import type { TaskFinalizationReceipt } from '../../task/finalization.ts';
-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.summary === 'pending' ? 'summary' : null,
-    receipt.postSummaryVerification === 'pending' ? 'post-summary-verification' : null
-  ].filter((step): step is string => step !== null);
-  const completedSteps = [
-    'lifecycle', receipt.taskComment === 'pending' ? null : 'task-comment',
-    receipt.verification === 'pending' ? null : 'verification', receipt.summary === 'pending' ? null : 'summary',
-    receipt.postSummaryVerification === 'pending' ? null : 'post-summary-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,
-    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 },
-    postSummaryVerification: receipt.postSummaryVerification === '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 {
-    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
-  };
-}

package/lib/sandbox/control/task-workflow.ts

@@ -1,95 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { randomUUID } from 'node:crypto';
-
-import { readStableFile, SecureFileError, writeAtomicFile } from '../../task/secure-fs.ts';
-
-import { TASK_WORKFLOW_COMMANDS, TASK_WORKFLOW_OPERATIONS, type TaskWorkflowOperation, type WorkflowCommand } from '../../task/workflow-command.ts';
-
-export type TaskWorkflowRequest = Readonly<{
-  version: 1;
-  id: string;
-  taskId: string;
-  generation: string;
-  operation: TaskWorkflowOperation;
-  args: readonly string[];
-}>;
-
-export function validateTaskWorkflowRequest(value: unknown): TaskWorkflowRequest {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error('TASK_WORKFLOW_REQUEST_INVALID');
-  const request = value as TaskWorkflowRequest;
-  if (Object.keys(request).sort().join(',') !== 'args,generation,id,operation,taskId,version'
-    || request.version !== 1 || typeof request.id !== 'string' || !/^[a-f0-9-]{16,64}$/u.test(request.id)
-    || typeof request.taskId !== 'string' || !/^TASK-\d{8}-\d{6}$/u.test(request.taskId)
-    || typeof request.generation !== 'string' || !request.generation
-    || !Object.hasOwn(TASK_WORKFLOW_COMMANDS, request.operation)
-    || !Array.isArray(request.args) || request.args.length < 2 || request.args.length > 128
-    || !request.args.every((arg) => typeof arg === 'string' && !/[\r\n]/u.test(arg))
-    || request.args[0] !== request.taskId) throw new Error('TASK_WORKFLOW_REQUEST_INVALID');
-  const [, selector] = TASK_WORKFLOW_COMMANDS[request.operation];
-  if (selector !== null && request.args[1] !== selector) throw new Error('TASK_WORKFLOW_REQUEST_INVALID');
-  return request;
-}
-
-/** Preserve argv verbatim; the domain command owns option parsing and validation. */
-export function createTaskWorkflowRequest(
-  command: WorkflowCommand | undefined,
-  args: readonly string[],
-  taskId: string,
-  generation: string
-): TaskWorkflowRequest {
-  const operation = TASK_WORKFLOW_OPERATIONS.find((key) => {
-    const [name, selector] = TASK_WORKFLOW_COMMANDS[key];
-    return name === command && (selector === null || selector === args[1]);
-  });
-  if (!operation) throw new Error('TASK_WORKFLOW_OPERATION_UNSUPPORTED');
-  return validateTaskWorkflowRequest({ version: 1, id: randomUUID(), taskId, generation, operation, args: [...args] });
-}
-
-export function canonicalArtifactName(value: string): boolean {
-  return /^(?:analysis|plan|code|review-analysis|review-plan|review-code)(?:-r[1-9]\d*)?\.md$/u.test(value)
-    && path.basename(value) === value;
-}
-
-function assertTaskArtifactDirectory(directory: string): string {
-  const resolved = path.resolve(directory);
-  let stat: fs.Stats;
-  try {
-    stat = fs.lstatSync(resolved);
-  } catch {
-    throw new SecureFileError('TASK_ARTIFACT_WRITE_DENIED', 'task directory is unavailable');
-  }
-  if (!stat.isDirectory() || stat.isSymbolicLink()) {
-    throw new SecureFileError('TASK_ARTIFACT_WRITE_DENIED', 'task directory must be a real directory');
-  }
-  return resolved;
-}
-
-export async function readTaskArtifact(
-  taskDir: string,
-  input: Readonly<{
-    artifact: string;
-    expectedSha256?: string;
-  }>
-): Promise<Readonly<{ artifact: string; bytes: Buffer; sha256: string }>> {
-  if (!canonicalArtifactName(input.artifact)) throw new SecureFileError('TASK_ARTIFACT_WRITE_DENIED', 'artifact must be a canonical top-level basename');
-  const root = assertTaskArtifactDirectory(taskDir);
-  const candidate = path.join(root, input.artifact);
-  if (path.dirname(candidate) !== root) throw new SecureFileError('TASK_ARTIFACT_WRITE_DENIED', 'artifact escapes task directory');
-  const stable = await readStableFile(candidate, {
-    maxBytes: 1024 * 1024,
-    ...(input.expectedSha256 ? { expectedSha256: input.expectedSha256 } : {})
-  });
-  return { artifact: input.artifact, bytes: stable.bytes, sha256: stable.sha256 };
-}
-
-export async function writeTaskArtifact(
-  taskDir: string,
-  artifact: Readonly<{ artifact: string; bytes: Buffer; expectedSha256?: string }>
-): Promise<void> {
-  if (!canonicalArtifactName(artifact.artifact)) throw new SecureFileError('TASK_ARTIFACT_WRITE_DENIED', 'artifact must be a canonical top-level basename');
-  const root = assertTaskArtifactDirectory(taskDir);
-  const target = path.join(root, artifact.artifact);
-  if (path.dirname(target) !== root) throw new SecureFileError('TASK_ARTIFACT_WRITE_DENIED', 'artifact escapes task directory');
-  await writeAtomicFile(target, artifact.bytes, 0o600, artifact.expectedSha256);
-}

package/lib/sandbox/control/workflow-executor.ts

@@ -1,156 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { randomUUID } from 'node:crypto';
-
-import { TASK_WORKFLOW_COMMANDS } from '../../task/workflow-command.ts';
-
-import { parseArtifactCommand, executeArtifactCommand } from '../../task/artifact-command.ts';
-import { parseReviewCommand } from '../../task/review-command.ts';
-import { prepareLocalArtifact, preflightLocalArtifact, commitLocalArtifactProvenance } from '../../task/local-artifact-finalization.ts';
-import {
-  prepareReviewSummaryCandidate,
-  preflightReviewSummary
-} from '../../task/review-finalization.ts';
-import { withTaskExecutionLock } from '../../task/task-execution-lock.ts';
-import { dispatchWorkflowCommand } from '../../task/workflow-dispatch.ts';
-import { assertSandboxTaskSource } from '../workspace-view.ts';
-import { appendDiagnosticAudit } from './audit.ts';
-import {
-  readTaskArtifact, type TaskWorkflowRequest
-} from './task-workflow.ts';
-import type { SandboxControlManifest } from './protocol.ts';
-import type { SandboxControlExecutionResult } from './executor.ts';
-import type { LifecycleRecoveryAttestationV1 } from '../../task/control-authority.ts';
-import { applyTaskEvent } from '../../task/events.ts';
-import { parseTaskEventRequest } from '../../internal/task-event.ts';
-
-export type TaskWorkflowFaultWindow =
-  | 'before-call'
-  | 'before-domain-write'
-  | 'after-atomic-rename'
-  | 'before-result-return';
-
-export type TaskWorkflowExecutionOptions = Readonly<{
-  /** Deterministic test seam; production callers leave this unset. */
-  faultWindow?: TaskWorkflowFaultWindow;
-}>;
-
-function executionResult(result: Record<string, unknown>): SandboxControlExecutionResult {
-  return { exitCode: result.status === 'failed' || result.status === 'refused' ? 1 : 0, stdout: `${JSON.stringify(result)}\n`, stderr: '' };
-}
-
-function replaceCurrentArtifactAtomically(file: string, content: string): void {
-  const temporary = path.join(path.dirname(file), `.${path.basename(file)}.${process.pid}.${randomUUID()}.tmp`);
-  try {
-    fs.writeFileSync(temporary, content, { encoding: 'utf8', flag: 'wx' });
-    fs.renameSync(temporary, file);
-  } finally {
-    try { fs.unlinkSync(temporary); } catch (error) {
-      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
-    }
-  }
-}
-
-/** The broker already authorized this host executor; domain operations own validation. */
-export async function executeTaskWorkflow(
-  manifest: SandboxControlManifest,
-  request: TaskWorkflowRequest,
-  lifecycleRecoveryAttestation: LifecycleRecoveryAttestationV1 | null = null,
-  options: TaskWorkflowExecutionOptions = {}
-): Promise<SandboxControlExecutionResult> {
-  let publicationCommitted = false;
-  let faultTriggered = false;
-  const fault = (window: TaskWorkflowFaultWindow): void => {
-    if (faultTriggered || options.faultWindow !== window) return;
-    faultTriggered = true;
-    throw new Error(`TASK_WORKFLOW_FAULT_INJECTED:${window}`);
-  };
-  const response = (result: Record<string, unknown>): SandboxControlExecutionResult => {
-    fault('before-result-return');
-    return executionResult(result);
-  };
-  try {
-    fault('before-call');
-    const taskDir = assertSandboxTaskSource(manifest.repoRoot, request.taskId);
-    const [command] = TASK_WORKFLOW_COMMANDS[request.operation];
-    if (request.operation === 'event') {
-      const eventRequest = parseTaskEventRequest(request.args);
-      const boundEventRequest = lifecycleRecoveryAttestation && eventRequest.requestId === undefined
-        ? { ...eventRequest, requestId: lifecycleRecoveryAttestation.lifecycleRequestId }
-        : eventRequest;
-      fault('before-domain-write');
-      const result = applyTaskEvent(boundEventRequest, {
-        repoRoot: manifest.repoRoot,
-        lifecycleRecoveryAttestation,
-        deferLifecycleRecoveryConsumption: true
-      });
-      publicationCommitted = result.changed;
-      fault('after-atomic-rename');
-      return response(result);
-    }
-    if (command !== 'task-artifact' && command !== 'task-review') {
-      // The broker owns this short-lived executor; no global service or worker
-      // credential participates in the command's authority or recovery path.
-      fault('before-domain-write');
-      const result = dispatchWorkflowCommand(manifest.repoRoot, request.operation, request.args);
-      publicationCommitted = result.changed === true;
-      fault('after-atomic-rename');
-      return response(result);
-    }
-    const input = command === 'task-artifact' ? parseArtifactCommand(request.args) : parseReviewCommand(request.args);
-    if (command === 'task-artifact' && 'operation' in input && input.operation === 'inspect') {
-      fault('before-domain-write');
-      const result = executeArtifactCommand(input, { repoRoot: manifest.repoRoot });
-      publicationCommitted = result.changed === true;
-      fault('after-atomic-rename');
-      return response(result);
-    }
-    if ('operation' in input && input.operation === 'init') {
-      fault('before-domain-write');
-      const result = executeArtifactCommand(input, { repoRoot: manifest.repoRoot, artifactDir: taskDir });
-      publicationCommitted = result.changed === true;
-      fault('after-atomic-rename');
-      return response(result);
-    }
-    return await withTaskExecutionLock(manifest.repoRoot, request.taskId, `sandbox-control.${request.operation}`, async () => {
-      const artifact = await readTaskArtifact(taskDir, { artifact: input.artifact });
-      const content = artifact.bytes.toString('utf8');
-      fault('before-domain-write');
-      let result: Record<string, unknown>;
-      if ('operation' in input) {
-        const { family } = input;
-        if (family !== 'analysis' && family !== 'plan' && family !== 'code') throw new Error('ARTIFACT_IDENTITY_INVALID');
-        const local = { taskRef: request.taskId, family, artifact: input.artifact, repoRoot: manifest.repoRoot, lockAlreadyHeld: true } as const;
-        if (input.operation === 'preflight') {
-          const result = preflightLocalArtifact(local);
-          return response(result);
-        }
-        const prepared = prepareLocalArtifact(local, content);
-        result = commitLocalArtifactProvenance(prepared);
-      } else {
-        if (input.overrideTicket) throw new Error('TASK_WORKFLOW_OVERRIDE_UNSUPPORTED');
-        const family = `review-${input.stage}` as 'review-analysis' | 'review-plan' | 'review-code';
-        if (request.operation === 'review-preflight') {
-          const result = preflightReviewSummary(input, { repoRoot: manifest.repoRoot, lockAlreadyHeld: true });
-          return response(result);
-        }
-        const prepared = prepareReviewSummaryCandidate(input, content, { repoRoot: manifest.repoRoot, lockAlreadyHeld: true });
-        if (input.dryRun || prepared.result.status === 'planned') return executionResult(prepared.result);
-        if (prepared.result.status === 'failed') return executionResult(prepared.result);
-        if (prepared.result.changed) replaceCurrentArtifactAtomically(path.join(taskDir, input.artifact), prepared.content);
-        result = prepared.result;
-      }
-      publicationCommitted ||= result.changed === true;
-      if (result.status !== 'failed') appendDiagnosticAudit(manifest, 'task-workflow-artifact-finalized', {
-        requestId: request.id, sandboxTaskId: request.taskId, workflowOperation: request.operation,
-        artifact: input.artifact, sha256: result.artifactSha256 as string, semanticDigest: result.semanticDigest as string
-      });
-      fault('after-atomic-rename');
-      return response(result);
-    });
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    const code = (error as { code?: string })?.code ?? /^([A-Z][A-Z0-9_]+)/u.exec(message)?.[1] ?? 'TASK_WORKFLOW_REQUEST_INVALID';
-    return executionResult({ status: 'failed', changed: publicationCommitted ? null : false, error: { code, message } });
-  }
-}